@wairon/cli 5.1.1-dev.50 → 5.1.1-dev.52

package/dist/index.js

@@ -1233,7 +1233,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.50";
+    WAIRON_VERSION = "5.1.1-dev.52";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -3387,10 +3387,26 @@ function writeSpecFile(filePath, document) {
 function listSpecFiles(specsDir) {
   return listFilesRecursive(specsDir, SPEC_FILE_EXTENSION);
 }
-var SPEC_FILE_EXTENSION;
+function removeSpecFile(filePath, specsRoot) {
+  if (!fs5.existsSync(filePath)) return false;
+  fs5.unlinkSync(filePath);
+  pruneEmptyDirs(path8.dirname(filePath), path8.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 = path8.dirname(at);
+  }
+}
+var fs5, path8, SPEC_FILE_EXTENSION;
 var init_spec_files = __esm({
   "src/core/spec-files.ts"() {
     "use strict";
+    fs5 = __toESM(require("fs"));
+    path8 = __toESM(require("path"));
     init_fs();
     init_yaml();
     SPEC_FILE_EXTENSION = ".yaml";
@@ -4135,14 +4151,14 @@ function embedJson(value) {
 }
 function loadCytoscapeLib() {
   const candidates = [
-    path8.resolve(__dirname, "..", "templates", "canvas", "cytoscape.min.js"),
+    path9.resolve(__dirname, "..", "templates", "canvas", "cytoscape.min.js"),
     // src/core & dist/cli
-    path8.resolve(__dirname, "templates", "canvas", "cytoscape.min.js")
+    path9.resolve(__dirname, "templates", "canvas", "cytoscape.min.js")
     // dist (library entry)
   ];
   for (const p of candidates) {
-    if (fs5.existsSync(p)) {
-      return fs5.readFileSync(p, "utf-8").replace(/<\/script/gi, "<\\/script");
+    if (fs6.existsSync(p)) {
+      return fs6.readFileSync(p, "utf-8").replace(/<\/script/gi, "<\\/script");
     }
   }
   throw new Error("Vendored cytoscape bundle not found (templates/canvas/cytoscape.min.js) \u2014 the wairon installation is incomplete.");
@@ -4154,12 +4170,12 @@ function renderCanvasHtml(model) {
 function escapeHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-var fs5, path8, CANVAS_TEMPLATE;
+var fs6, path9, CANVAS_TEMPLATE;
 var init_canvas = __esm({
   "src/core/canvas.ts"() {
     "use strict";
-    fs5 = __toESM(require("fs"));
-    path8 = __toESM(require("path"));
+    fs6 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
     init_specs2();
     init_models();
     init_diagram_export();
@@ -8354,7 +8370,7 @@ function packStoreDir() {
 function packFiles(dir, prefix = "") {
   let entries;
   try {
-    entries = fs6.readdirSync(dir, { withFileTypes: true });
+    entries = fs7.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -8362,25 +8378,25 @@ function packFiles(dir, prefix = "") {
   for (const e of entries) {
     if (DIGEST_EXCLUDED.has(e.name)) continue;
     const rel2 = prefix ? `${prefix}/${e.name}` : e.name;
-    if (e.isDirectory()) out.push(...packFiles(path9.join(dir, e.name), rel2));
+    if (e.isDirectory()) out.push(...packFiles(path10.join(dir, e.name), rel2));
     else if (e.isFile()) out.push(rel2);
   }
   return out.sort();
 }
 function computePackDigest(packDir) {
   const hash = crypto2.createHash("sha256");
-  const abs = path9.resolve(packDir);
+  const abs = path10.resolve(packDir);
   let isFile = false;
   try {
-    isFile = fs6.statSync(abs).isFile();
+    isFile = fs7.statSync(abs).isFile();
   } catch {
   }
-  const entries = isFile ? [[path9.basename(abs), abs]] : packFiles(abs).map((rel2) => [rel2, path9.join(abs, rel2)]);
+  const entries = isFile ? [[path10.basename(abs), abs]] : packFiles(abs).map((rel2) => [rel2, path10.join(abs, rel2)]);
   for (const [rel2, full] of entries) {
     hash.update(rel2);
     hash.update("\0");
     try {
-      hash.update(fs6.readFileSync(full));
+      hash.update(fs7.readFileSync(full));
     } catch {
     }
     hash.update("\0");
@@ -8389,7 +8405,7 @@ function computePackDigest(packDir) {
 }
 function readInstallRecord(packPath) {
   try {
-    const raw = readYamlFile(path9.join(packPath, INSTALL_RECORD));
+    const raw = readYamlFile(path10.join(packPath, INSTALL_RECORD));
     return raw && typeof raw === "object" ? raw : {};
   } catch {
     return {};
@@ -8419,14 +8435,14 @@ function installedFrom(location, name, version) {
 function versionedEntries(nameDir, fallbackName) {
   let versions;
   try {
-    versions = fs6.readdirSync(nameDir, { withFileTypes: true });
+    versions = fs7.readdirSync(nameDir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const v of versions) {
     if (!v.isDirectory()) continue;
-    const versionDir = path9.join(nameDir, v.name);
+    const versionDir = path10.join(nameDir, v.name);
     const entryFile = packDirEntry(versionDir);
     if (!entryFile) continue;
     out.push(installedFrom(versionDir, declaredName(entryFile) ?? fallbackName, v.name));
@@ -8434,7 +8450,7 @@ function versionedEntries(nameDir, fallbackName) {
   return out;
 }
 function storeEntryPacks(store, entry) {
-  const full = path9.join(store, entry.name);
+  const full = path10.join(store, entry.name);
   if (entry.isFile()) {
     if (!PACK_FILE_RE.test(entry.name)) return [];
     const name = declaredName(full) ?? entry.name.replace(PACK_FILE_RE, "");
@@ -8449,7 +8465,7 @@ function listInstalledPacks() {
   const store = packStoreDir();
   let entries;
   try {
-    entries = fs6.readdirSync(store, { withFileTypes: true });
+    entries = fs7.readdirSync(store, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -8466,17 +8482,17 @@ function resolveInstalledPack(name, version) {
   return candidates[0];
 }
 function installPackFromDirectory(sourceDir, origin) {
-  const abs = path9.resolve(sourceDir);
+  const abs = path10.resolve(sourceDir);
   const entryFile = packDirEntry(abs);
   if (!entryFile) {
     throw new Error(`"${sourceDir}" is not a pack directory (no pack.yaml | pack.cjs | index.cjs | \u2026).`);
   }
-  const manifest = readManifest(entryFile, path9.dirname(entryFile));
+  const manifest = readManifest(entryFile, path10.dirname(entryFile));
   const version = manifest.version && manifest.version.length > 0 ? manifest.version : UNVERSIONED;
-  const dest = path9.join(packStoreDir(), manifest.name, version);
-  fs6.rmSync(dest, { recursive: true, force: true });
-  fs6.mkdirSync(path9.dirname(dest), { recursive: true });
-  fs6.cpSync(abs, dest, { recursive: true });
+  const dest = path10.join(packStoreDir(), manifest.name, version);
+  fs7.rmSync(dest, { recursive: true, force: true });
+  fs7.mkdirSync(path10.dirname(dest), { recursive: true });
+  fs7.cpSync(abs, dest, { recursive: true });
   const digest2 = computePackDigest(dest);
   const record = {
     origin,
@@ -8484,7 +8500,7 @@ function installPackFromDirectory(sourceDir, origin) {
     waironVersion: WAIRON_VERSION,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeYamlFile(path9.join(dest, INSTALL_RECORD), record);
+  writeYamlFile(path10.join(dest, INSTALL_RECORD), record);
   return {
     name: manifest.name,
     version,
@@ -8499,23 +8515,23 @@ function uninstallPack(name, version) {
   const targets = listInstalledPacks().filter((p) => p.name === name && (!version || p.version === version));
   if (targets.length === 0) return false;
   for (const target of targets) {
-    fs6.rmSync(target.path, { recursive: true, force: true });
-    const parent = path9.dirname(target.path);
-    if (path9.resolve(parent) === path9.resolve(packStoreDir())) continue;
+    fs7.rmSync(target.path, { recursive: true, force: true });
+    const parent = path10.dirname(target.path);
+    if (path10.resolve(parent) === path10.resolve(packStoreDir())) continue;
     try {
-      if (fs6.readdirSync(parent).length === 0) fs6.rmdirSync(parent);
+      if (fs7.readdirSync(parent).length === 0) fs7.rmdirSync(parent);
     } catch {
     }
   }
   return true;
 }
-var crypto2, fs6, path9, UNVERSIONED, INSTALL_RECORD, DIGEST_EXCLUDED, PACK_FILE_RE;
+var crypto2, fs7, path10, UNVERSIONED, INSTALL_RECORD, DIGEST_EXCLUDED, PACK_FILE_RE;
 var init_packstore = __esm({
   "src/core/packstore.ts"() {
     "use strict";
     crypto2 = __toESM(require("crypto"));
-    fs6 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
+    fs7 = __toESM(require("fs"));
+    path10 = __toESM(require("path"));
     init_yaml();
     init_defaults();
     init_version();
@@ -8542,26 +8558,26 @@ function emptyExtensions() {
   return { packNames: [], packs: [], rules: [], profiles: {}, languages: {}, skills: [], patterns: [], guarantees: [], assertions: [], instructions: [], errors: [], selectionFailures: [] };
 }
 function globalPacksDir() {
-  return process.env.WAIRON_PACKS_DIR ?? path10.join(os2.homedir(), ".wairon", "packs");
+  return process.env.WAIRON_PACKS_DIR ?? path11.join(os2.homedir(), ".wairon", "packs");
 }
 function packDirEntry(dir) {
   for (const name of PACK_DIR_ENTRIES) {
-    const p = path10.join(dir, name);
-    if (fs7.existsSync(p)) return p;
+    const p = path11.join(dir, name);
+    if (fs8.existsSync(p)) return p;
   }
   return null;
 }
 function latestVersionDir(nameDir) {
   let versions;
   try {
-    versions = fs7.readdirSync(nameDir, { withFileTypes: true });
+    versions = fs8.readdirSync(nameDir, { withFileTypes: true });
   } catch {
     return null;
   }
   let best = null;
   for (const v of versions) {
     if (!v.isDirectory()) continue;
-    const dir = path10.join(nameDir, v.name);
+    const dir = path11.join(nameDir, v.name);
     if (!packDirEntry(dir)) continue;
     if (!best || isNewerVersion(best.version, v.name)) best = { version: v.name, dir };
   }
@@ -8570,13 +8586,13 @@ function latestVersionDir(nameDir) {
 function discoverPacks(dir) {
   let entries;
   try {
-    entries = fs7.readdirSync(dir, { withFileTypes: true });
+    entries = fs8.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const refs = [];
   for (const e of entries.sort((a, b) => compareOrdinal(a.name, b.name))) {
-    const full = path10.join(dir, e.name);
+    const full = path11.join(dir, e.name);
     if (e.isDirectory()) {
       if (packDirEntry(full)) refs.push(full);
       else {
@@ -8606,17 +8622,17 @@ function mergePack(out, pack, ref, scope, packDir) {
       foreignBuiltins: [.../* @__PURE__ */ new Set([...existing.foreignBuiltins, ...def.foreignBuiltins])]
     } : def;
   }
-  for (const s of pack.skills) out.skills.push({ ...s, pack: pack.name, packVersion: pack.version, sourcePath: path10.resolve(packDir, s.source) });
+  for (const s of pack.skills) out.skills.push({ ...s, pack: pack.name, packVersion: pack.version, sourcePath: path11.resolve(packDir, s.source) });
   for (const p of pack.patterns) out.patterns.push({ ...p, pack: pack.name });
   out.guarantees = [.../* @__PURE__ */ new Set([...out.guarantees, ...pack.guarantees])];
   for (const a of pack.assertions) out.assertions.push({ ...a, pack: pack.name, fullCode: assertionFullCode(pack.name, a.code) });
   for (const b of pack.instructions) out.instructions.push({ ...b, pack: pack.name });
 }
 function resolvePackRef(ref, projectRoot) {
-  const pathLike = ref.startsWith(".") || path10.isAbsolute(ref) || isYamlPath(ref);
+  const pathLike = ref.startsWith(".") || path11.isAbsolute(ref) || isYamlPath(ref);
   if (!pathLike) return ref;
-  const resolved = path10.resolve(projectRoot, ref);
-  if (fs7.existsSync(resolved) && fs7.statSync(resolved).isDirectory()) {
+  const resolved = path11.resolve(projectRoot, ref);
+  if (fs8.existsSync(resolved) && fs8.statSync(resolved).isDirectory()) {
     const entry = packDirEntry(resolved);
     if (!entry) throw new Error(`directory pack has no entry file (${PACK_DIR_ENTRIES.join(" | ")})`);
     return entry;
@@ -8629,7 +8645,7 @@ function readManifest(target, projectRoot) {
     if (raw == null) throw new Error("file not found or empty");
     return { ...DeclarativePackSchema.parse(raw), rules: [] };
   }
-  const req = (0, import_module.createRequire)(path10.join(projectRoot, "package.json"));
+  const req = (0, import_module.createRequire)(path11.join(projectRoot, "package.json"));
   const modRaw = req(target);
   const mod = modRaw?.default ?? modRaw;
   const parsed = DeclarativePackSchema.parse({
@@ -8657,7 +8673,7 @@ function loadExtensionPacks(refs, projectRoot) {
     try {
       const target = resolvePackRef(ref, projectRoot);
       const manifest = readManifest(target, projectRoot);
-      mergePack(out, manifest, ref, scope, path10.dirname(target));
+      mergePack(out, manifest, ref, scope, path11.dirname(target));
       for (const r of manifest.rules) out.rules.push(r);
     } catch (e) {
       out.errors.push(`Extension pack "${ref}" failed to load: ${e instanceof Error ? e.message : String(e)}`);
@@ -8703,7 +8719,7 @@ function defaultPackSelections() {
       const entry = packDirEntry(pack.path) ?? pack.path;
       let manifest;
       try {
-        manifest = readManifest(entry, path10.dirname(entry));
+        manifest = readManifest(entry, path11.dirname(entry));
       } catch {
         continue;
       }
@@ -8742,7 +8758,7 @@ function diagnoseProjectPacks() {
     const globalsApplied = [];
     if (globalsOn) {
       for (const ref of discoverPacks(globalPacksDir())) {
-        const match = installed.find((p) => path10.resolve(p.path) === path10.resolve(ref));
+        const match = installed.find((p) => path11.resolve(p.path) === path11.resolve(ref));
         if (match) globalsApplied.push({ name: match.name, version: match.version });
       }
     }
@@ -8820,7 +8836,7 @@ function verifyIntegrity(selection, packDir, where) {
   };
 }
 function detectBundleStoreDrift(selection, bundleDir) {
-  const bundledVersion = path10.basename(bundleDir);
+  const bundledVersion = path11.basename(bundleDir);
   const installed = resolveInstalledPack(selection.name, bundledVersion);
   if (!installed) return void 0;
   const bundleDigest = computePackDigest(bundleDir);
@@ -8834,34 +8850,34 @@ function detectBundleStoreDrift(selection, bundleDir) {
   };
 }
 function findBundledPack(projectRoot, selection) {
-  const base = path10.join(projectRoot, ".wai", "packs", selection.name);
+  const base = path11.join(projectRoot, ".wai", "packs", selection.name);
   if (selection.version) {
-    const pinned = path10.join(base, selection.version);
+    const pinned = path11.join(base, selection.version);
     return packDirEntry(pinned) ? pinned : null;
   }
   if (packDirEntry(base)) return base;
   let versions;
   try {
-    versions = fs7.readdirSync(base, { withFileTypes: true });
+    versions = fs8.readdirSync(base, { withFileTypes: true });
   } catch {
     return null;
   }
   let best = null;
   for (const v of versions) {
     if (!v.isDirectory()) continue;
-    const dir = path10.join(base, v.name);
+    const dir = path11.join(base, v.name);
     if (!packDirEntry(dir)) continue;
     if (!best || isNewerVersion(best.version, v.name)) best = { version: v.name, dir };
   }
   return best?.dir ?? null;
 }
-var fs7, os2, path10, import_module, import_zod9, ProfileDefSchema, LanguagePackDefSchema, PackSkillSchema, PackInstructionBlockSchema, PackInstructionsSchema, PatternDefSchema, AssertionSelectorSchema, assertionBase, PackAssertionSchema, DeclarativePackSchema, EXTENDABLE_BUILTIN_SKILLS, GLOBAL_PACKS_DEFAULT, PACK_DIR_ENTRIES, isYamlPath;
+var fs8, os2, path11, import_module, import_zod9, ProfileDefSchema, LanguagePackDefSchema, PackSkillSchema, PackInstructionBlockSchema, PackInstructionsSchema, PatternDefSchema, AssertionSelectorSchema, assertionBase, PackAssertionSchema, DeclarativePackSchema, EXTENDABLE_BUILTIN_SKILLS, GLOBAL_PACKS_DEFAULT, PACK_DIR_ENTRIES, isYamlPath;
 var init_extensions = __esm({
   "src/core/extensions.ts"() {
     "use strict";
-    fs7 = __toESM(require("fs"));
+    fs8 = __toESM(require("fs"));
     os2 = __toESM(require("os"));
-    path10 = __toESM(require("path"));
+    path11 = __toESM(require("path"));
     import_module = require("module");
     import_zod9 = require("zod");
     init_yaml();
@@ -9053,21 +9069,21 @@ function buildCodeIndex(model) {
   const declarations = /* @__PURE__ */ new Map();
   const anchors = /* @__PURE__ */ new Map();
   const findingAnchors = /* @__PURE__ */ new Map();
-  const namesAt = (cache, path27, make) => {
-    const cached = cache.get(path27);
+  const namesAt = (cache, path28, make) => {
+    const cached = cache.get(path28);
     if (cached) return cached;
-    const f = facts.get(path27);
+    const f = facts.get(path28);
     if (!f) return NO_NAMES;
     const built = make(f);
-    cache.set(path27, built);
+    cache.set(path28, built);
     return built;
   };
   const republished = /* @__PURE__ */ new Map();
-  const republishedFrom = (path27) => {
-    const cached = republished.get(path27);
+  const republishedFrom = (path28) => {
+    const cached = republished.get(path28);
     if (cached) return cached;
-    const out = /* @__PURE__ */ new Set([path27]);
-    const queue = [path27];
+    const out = /* @__PURE__ */ new Set([path28]);
+    const queue = [path28];
     while (queue.length) {
       const from = queue.pop();
       const f = facts.get(from);
@@ -9080,7 +9096,7 @@ function buildCodeIndex(model) {
         }
       }
     }
-    republished.set(path27, out);
+    republished.set(path28, out);
     return out;
   };
   const NO_ORIGIN = /* @__PURE__ */ new Set();
@@ -9089,9 +9105,9 @@ function buildCodeIndex(model) {
     return to ? republishedFrom(to) : NO_ORIGIN;
   };
   const scopeOf = (site, from) => {
-    const path27 = pathKey(site.from ?? from);
-    const f = facts.get(path27);
-    return f?.status === "analyzed" && f.analysisGrade === "exact" ? { path: path27, facts: f } : void 0;
+    const path28 = pathKey(site.from ?? from);
+    const f = facts.get(path28);
+    return f?.status === "analyzed" && f.analysisGrade === "exact" ? { path: path28, facts: f } : void 0;
   };
   const originOf = (site, from) => {
     const resolved = scopeOf(site, from);
@@ -9130,14 +9146,14 @@ function buildCodeIndex(model) {
     if (site.via) for (const typeName of localTypesOf(f, site.via)) widenThroughType(typeName);
     return out;
   };
-  const declarationsAt = (path27) => namesAt(declarations, pathKey(path27), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
+  const declarationsAt = (path28) => namesAt(declarations, pathKey(path28), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
   return {
     paths,
     exactPaths,
-    factsAt: (path27) => facts.get(pathKey(path27)),
+    factsAt: (path28) => facts.get(pathKey(path28)),
     declarationsAt,
-    anchorsAt: (path27) => namesAt(anchors, pathKey(path27), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
-    findingAnchorsAt: (path27) => namesAt(findingAnchors, pathKey(path27), (f) => new Set(f.anchoredNames)),
+    anchorsAt: (path28) => namesAt(anchors, pathKey(path28), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
+    findingAnchorsAt: (path28) => namesAt(findingAnchors, pathKey(path28), (f) => new Set(f.anchoredNames)),
     originOf,
     possibleOriginsOf
   };
@@ -9175,10 +9191,10 @@ function buildRealizationIndex(ctx) {
   return {
     paths,
     implementationsOf: (compId) => implsByComponent.get(compId) ?? NONE_IMPL,
-    implementationsAt: (path27) => implsByPath.get(pathKey(path27)) ?? NONE_IMPL,
+    implementationsAt: (path28) => implsByPath.get(pathKey(path28)) ?? NONE_IMPL,
     filesOf: (compId) => filesByComponent.get(compId) ?? NONE_PATH,
     filesIn: (subsystemId) => filesBySubsystem.get(subsystemId) ?? NONE_PATH,
-    componentsAt: (path27) => componentsByPath.get(pathKey(path27)) ?? NONE_COMP
+    componentsAt: (path28) => componentsByPath.get(pathKey(path28)) ?? NONE_COMP
   };
 }
 function buildImportGraph(index, universe) {
@@ -9190,22 +9206,22 @@ function buildImportGraph(index, universe) {
       if (to && to !== from) into.add(to);
     }
   };
-  const importsOf = (path27) => {
-    const cached = imports.get(path27);
+  const importsOf = (path28) => {
+    const cached = imports.get(path28);
     if (cached) return cached;
-    const facts = index.factsAt(path27);
+    const facts = index.factsAt(path28);
     const out = /* @__PURE__ */ new Set();
-    if (facts?.status === "analyzed") resolveAll(path27, facts.imports, out);
-    imports.set(path27, out);
+    if (facts?.status === "analyzed") resolveAll(path28, facts.imports, out);
+    imports.set(path28, out);
     return out;
   };
-  const tracesOf = (path27) => {
-    const cached = traces.get(path27);
+  const tracesOf = (path28) => {
+    const cached = traces.get(path28);
     if (cached) return cached;
-    const facts = index.factsAt(path27);
-    const out = new Set(importsOf(path27));
-    if (facts?.status === "analyzed") resolveAll(path27, facts.reexports, out);
-    traces.set(path27, out);
+    const facts = index.factsAt(path28);
+    const out = new Set(importsOf(path28));
+    if (facts?.status === "analyzed") resolveAll(path28, facts.reexports, out);
+    traces.set(path28, out);
     return out;
   };
   return {
@@ -10675,11 +10691,11 @@ var init_unconditional_call_cycles = __esm({
           const memberEdges = keys.flatMap((k) => (adjacency.get(k) ?? []).filter((e) => inScc.has(e.toKey)));
           if (memberEdges.length === 0) continue;
           const anchor = [...memberEdges].sort((a, b) => byCodeUnit(a.fromKey, b.fromKey) || byCodeUnit(a.impl.id, b.impl.id) || a.stepNumber - b.stepNumber)[0];
-          const path27 = [...keys].sort(byCodeUnit).join(" \u2192 ");
+          const path28 = [...keys].sort(byCodeUnit).join(" \u2192 ");
           ctx.addIssue(
             "warning",
             "UNCONDITIONAL_CALL_CYCLE",
-            `Call cycle with no guard: ${path27} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
+            `Call cycle with no guard: ${path28} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
             anchor.impl.id,
             memberEdges.some((e) => ctx.isImplementationDraft(e.impl))
           );
@@ -13769,11 +13785,11 @@ var init_hidden_state = __esm({
             byPath.set(key, list);
           }
         }
-        for (const path27 of code.exactPaths) {
-          const facts = code.factsAt(path27);
+        for (const path28 of code.exactPaths) {
+          const facts = code.factsAt(path28);
           const bindings = facts.topLevelMutableBindings ?? [];
           if (bindings.length === 0) continue;
-          const mapped = byPath.get(path27) ?? [];
+          const mapped = byPath.get(path28) ?? [];
           if (mapped.length === 0) continue;
           if (!mapped.every((m) => isStatelessLogic(m.component))) continue;
           const anchor = [...mapped].sort((a, b) => a.impl.id.localeCompare(b.impl.id))[0];
@@ -13846,7 +13862,7 @@ var init_dependency_conformance = __esm({
           }
           return false;
         };
-        const draftAt = (path27) => realization.implementationsAt(path27).some((impl) => ctx.isImplementationDraft(impl));
+        const draftAt = (path28) => realization.implementationsAt(path28).some((impl) => ctx.isImplementationDraft(impl));
         for (const fromPath of mappedPaths) {
           const fromComponents = realization.componentsAt(fromPath);
           for (const toPath of graph.importsOf(fromPath)) {
@@ -15857,7 +15873,7 @@ function resolveTypeScript(projectRoot) {
     return cached.ts;
   }
   let ts = null;
-  const bases = [path11.join(projectRoot, "package.json"), __filename];
+  const bases = [path12.join(projectRoot, "package.json"), __filename];
   for (const base of bases) {
     try {
       const req = (0, import_module2.createRequire)(base);
@@ -16072,7 +16088,7 @@ function walkExact(ts, sourceText, fileName) {
 }
 function resolveRelativeModule(fromFile, specifier) {
   if (!specifier.startsWith(".")) return null;
-  const base = path11.resolve(path11.dirname(fromFile), specifier);
+  const base = path12.resolve(path12.dirname(fromFile), specifier);
   const candidates = [
     base,
     base.replace(/\.js$/, ".ts"),
@@ -16080,12 +16096,12 @@ function resolveRelativeModule(fromFile, specifier) {
     `${base}.ts`,
     `${base}.tsx`,
     `${base}.js`,
-    path11.join(base, "index.ts"),
-    path11.join(base, "index.js")
+    path12.join(base, "index.ts"),
+    path12.join(base, "index.js")
   ];
   for (const c of candidates) {
     try {
-      if (fs8.statSync(c).isFile()) return c;
+      if (fs9.statSync(c).isFile()) return c;
     } catch {
     }
   }
@@ -16093,11 +16109,11 @@ function resolveRelativeModule(fromFile, specifier) {
 }
 function reexportTarget(ts, filePath, specifier, projectRoot, visited, exactCache) {
   const target = resolveRelativeModule(filePath, specifier);
-  if (!target || path11.relative(projectRoot, target).startsWith("..")) return null;
+  if (!target || path12.relative(projectRoot, target).startsWith("..")) return null;
   let targetFacts = exactCache.get(target);
   if (targetFacts === void 0) {
     try {
-      targetFacts = walkExact(ts, fs8.readFileSync(target, "utf8"), target);
+      targetFacts = walkExact(ts, fs9.readFileSync(target, "utf8"), target);
     } catch {
       targetFacts = null;
     }
@@ -16115,7 +16131,7 @@ function carryBody(facts, target, targetPath, local, exported, projectRoot) {
   if (score !== void 0) facts.complexity.set(exported, Math.max(facts.complexity.get(exported) ?? 0, score));
   const targetCalls = target.calls.get(local);
   if (!targetCalls) return;
-  const carriedFrom = pathKey(path11.relative(projectRoot, targetPath));
+  const carriedFrom = pathKey(path12.relative(projectRoot, targetPath));
   const sites = facts.calls.get(exported) ?? /* @__PURE__ */ new Map();
   for (const [key, site] of targetCalls) sites.set(carriedFrom + "|" + key, { ...site, from: site.from ?? carriedFrom });
   facts.calls.set(exported, sites);
@@ -16145,24 +16161,24 @@ function walkDeclaredRoots(roots, exclude, projectRoot) {
   const excluded = exclude.map(pathKey);
   const isExcluded = (key) => excluded.some((e) => key === e || key.startsWith(`${e}/`));
   const record = (absolute) => {
-    const key = pathKey(path11.relative(projectRoot, absolute));
+    const key = pathKey(path12.relative(projectRoot, absolute));
     if (seen.has(key) || isExcluded(key)) return;
-    if (!EXTENSION_LANGUAGE[path11.extname(key).toLowerCase()]) return;
+    if (!EXTENSION_LANGUAGE[path12.extname(key).toLowerCase()]) return;
     seen.add(key);
     found.push(key);
   };
   const descend = (dir) => {
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs9.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries.slice().sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
-      const child = path11.join(dir, entry.name);
+      const child = path12.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        if (isExcluded(pathKey(path11.relative(projectRoot, child)))) continue;
+        if (isExcluded(pathKey(path12.relative(projectRoot, child)))) continue;
         descend(child);
       } else if (entry.isFile()) {
         record(child);
@@ -16171,13 +16187,13 @@ function walkDeclaredRoots(roots, exclude, projectRoot) {
   };
   for (const root of roots) {
     const key = pathKey(root);
-    if (path11.isAbsolute(key) || path11.normalize(key).split(path11.sep)[0] === "..") continue;
-    const absolute = path11.resolve(projectRoot, key);
-    if (path11.relative(projectRoot, absolute).startsWith("..")) continue;
+    if (path12.isAbsolute(key) || path12.normalize(key).split(path12.sep)[0] === "..") continue;
+    const absolute = path12.resolve(projectRoot, key);
+    if (path12.relative(projectRoot, absolute).startsWith("..")) continue;
     if (isExcluded(key)) continue;
     let stat;
     try {
-      stat = fs8.statSync(absolute);
+      stat = fs9.statSync(absolute);
     } catch {
       continue;
     }
@@ -16203,23 +16219,23 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
     if (seen.has(sourcePath)) continue;
     seen.add(sourcePath);
     const empty = { declaredNames: [], anchoredNames: [], exportedNames: [], imports: [], reexports: [] };
-    if (path11.isAbsolute(sourcePath) || path11.normalize(sourcePath).split(path11.sep)[0] === "..") {
+    if (path12.isAbsolute(sourcePath) || path12.normalize(sourcePath).split(path12.sep)[0] === "..") {
       files.push({ path: sourcePath, status: "escaped", ...empty });
       continue;
     }
-    const absolute = path11.resolve(projectRoot, sourcePath);
-    if (path11.relative(projectRoot, absolute).startsWith("..")) {
+    const absolute = path12.resolve(projectRoot, sourcePath);
+    if (path12.relative(projectRoot, absolute).startsWith("..")) {
       files.push({ path: sourcePath, status: "escaped", ...empty });
       continue;
     }
     let buffer;
     try {
-      const stat = fs8.statSync(absolute);
+      const stat = fs9.statSync(absolute);
       if (!stat.isFile()) {
         files.push({ path: sourcePath, status: "missing", ...empty });
         continue;
       }
-      buffer = fs8.readFileSync(absolute);
+      buffer = fs9.readFileSync(absolute);
     } catch {
       files.push({ path: sourcePath, status: "missing", ...empty });
       continue;
@@ -16229,7 +16245,7 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
       continue;
     }
     const text = buffer.toString("utf8");
-    const language = EXTENSION_LANGUAGE[path11.extname(sourcePath).toLowerCase()];
+    const language = EXTENSION_LANGUAGE[path12.extname(sourcePath).toLowerCase()];
     let analyzed;
     if (language === "typescript" || language === "javascript") {
       const ts = resolveTypeScript(projectRoot);
@@ -16273,7 +16289,7 @@ function readTestFiles(testRoots, projectRoot) {
   for (const key of walkDeclaredRoots(testRoots, [], projectRoot)) {
     let text;
     try {
-      const buffer = fs8.readFileSync(path11.resolve(projectRoot, key));
+      const buffer = fs9.readFileSync(path12.resolve(projectRoot, key));
       if (looksBinary(buffer)) continue;
       text = buffer.toString("utf8");
     } catch {
@@ -16310,12 +16326,12 @@ function findTestsReferencing(methods, projectRoot, testRoots = []) {
   }
   return found;
 }
-var fs8, path11, import_module2, EXTENSION_LANGUAGE, C_FAMILY_COMMENTS, NAMED_IMPORT_BINDINGS_RE, JS_PATTERNS, LANGUAGE_PATTERNS, PATTERN_ANALYSIS_MAX_BYTES, IDENTIFIER_RE, STRING_RE, tsResolutionCache, TS_RESOLUTION_RETRY_MS;
+var fs9, path12, import_module2, EXTENSION_LANGUAGE, C_FAMILY_COMMENTS, NAMED_IMPORT_BINDINGS_RE, JS_PATTERNS, LANGUAGE_PATTERNS, PATTERN_ANALYSIS_MAX_BYTES, IDENTIFIER_RE, STRING_RE, tsResolutionCache, TS_RESOLUTION_RETRY_MS;
 var init_source_analysis = __esm({
   "src/core/source-analysis.ts"() {
     "use strict";
-    fs8 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
     import_module2 = require("module");
     init_models();
     EXTENSION_LANGUAGE = {
@@ -17082,28 +17098,28 @@ var init_gate_identity = __esm({
 
 // src/core/variants.ts
 function globalVariantsDir() {
-  return process.env.WAIRON_VARIANTS_DIR ?? path12.join(os3.homedir(), ".wairon", "variants");
+  return process.env.WAIRON_VARIANTS_DIR ?? path13.join(os3.homedir(), ".wairon", "variants");
 }
 function builtinVariantsDir() {
   const candidates = [
-    path12.resolve(__dirname, "..", "templates", "variants"),
+    path13.resolve(__dirname, "..", "templates", "variants"),
     // src/core & dist/cli
-    path12.resolve(__dirname, "templates", "variants")
+    path13.resolve(__dirname, "templates", "variants")
     // dist (library entry)
   ];
-  return candidates.find((dir) => fs9.existsSync(dir)) ?? candidates[0];
+  return candidates.find((dir) => fs10.existsSync(dir)) ?? candidates[0];
 }
 function projectVariantsDir() {
-  return path12.join(getProjectRoot(), ".wai", "variants");
+  return path13.join(getProjectRoot(), ".wai", "variants");
 }
 function variantFiles(dir) {
   let entries;
   try {
-    entries = fs9.readdirSync(dir, { withFileTypes: true });
+    entries = fs10.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
-  return entries.filter((e) => e.isFile() && /\.ya?ml$/i.test(e.name)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => path12.join(dir, e.name));
+  return entries.filter((e) => e.isFile() && /\.ya?ml$/i.test(e.name)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => path13.join(dir, e.name));
 }
 function parseVariants(raw) {
   if (raw == null) return [];
@@ -17212,13 +17228,13 @@ function rebasedText(content, fromBase, toBase, rebasedContent) {
   }
   return serializeYaml(rebasedContent);
 }
-var fs9, os3, path12, import_zod10, VariantDefSchema;
+var fs10, os3, path13, import_zod10, VariantDefSchema;
 var init_variants = __esm({
   "src/core/variants.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"));
+    fs10 = __toESM(require("fs"));
     os3 = __toESM(require("os"));
-    path12 = __toESM(require("path"));
+    path13 = __toESM(require("path"));
     import_zod10 = require("zod");
     init_yaml();
     init_fs();
@@ -17608,7 +17624,7 @@ var init_openapi = __esm({
 
 // src/core/surfaces.ts
 function surfacesDir(rootDir) {
-  return path13.join(rootDir, ".wai", SURFACES_DIRNAME);
+  return path14.join(rootDir, ".wai", SURFACES_DIRNAME);
 }
 function audienceRank(audience) {
   const idx = SURFACE_AUDIENCES.indexOf(audience ?? "instance");
@@ -17766,12 +17782,12 @@ function projectSubsystemSurface(subsystemId) {
 }
 function listSnapshots(rootDir = getProjectRoot()) {
   const dir = surfacesDir(rootDir);
-  if (!fs10.existsSync(dir)) return [];
+  if (!fs11.existsSync(dir)) return [];
   const out = [];
-  for (const file of fs10.readdirSync(dir)) {
+  for (const file of fs11.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      out.push(SurfaceSnapshotSchema.parse(readYamlFile(path13.join(dir, file))));
+      out.push(SurfaceSnapshotSchema.parse(readYamlFile(path14.join(dir, file))));
     } catch {
     }
   }
@@ -17785,10 +17801,10 @@ function snapshotFilename(projectName) {
 }
 function writeSnapshotIfChanged(snapshot, rootDir) {
   const dir = surfacesDir(rootDir);
-  fs10.mkdirSync(dir, { recursive: true });
-  const p = path13.join(dir, snapshotFilename(snapshot.projectName));
+  fs11.mkdirSync(dir, { recursive: true });
+  const p = path14.join(dir, snapshotFilename(snapshot.projectName));
   const next = SurfaceSnapshotSchema.parse(snapshot);
-  if (fs10.existsSync(p)) {
+  if (fs11.existsSync(p)) {
     try {
       const existing = SurfaceSnapshotSchema.parse(readYamlFile(p));
       if (surfaceContentKey(existing) === surfaceContentKey(next)) {
@@ -17805,19 +17821,19 @@ function saveSnapshot(snapshot, rootDir = getProjectRoot()) {
 }
 function removeSnapshot(projectName, rootDir = getProjectRoot()) {
   const dir = surfacesDir(rootDir);
-  const direct = path13.join(dir, snapshotFilename(projectName));
-  if (fs10.existsSync(direct)) {
-    fs10.unlinkSync(direct);
+  const direct = path14.join(dir, snapshotFilename(projectName));
+  if (fs11.existsSync(direct)) {
+    fs11.unlinkSync(direct);
     return true;
   }
-  if (!fs10.existsSync(dir)) return false;
-  for (const file of fs10.readdirSync(dir)) {
+  if (!fs11.existsSync(dir)) return false;
+  for (const file of fs11.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-    const p = path13.join(dir, file);
+    const p = path14.join(dir, file);
     try {
       const snap = SurfaceSnapshotSchema.parse(readYamlFile(p));
       if (snap.projectName === projectName) {
-        fs10.unlinkSync(p);
+        fs11.unlinkSync(p);
         return true;
       }
     } catch {
@@ -17829,11 +17845,11 @@ function loadSurfaceSnapshots() {
   return listSnapshots();
 }
 function listMountSnapshots(mounts) {
-  const bound2 = path13.resolve(getProjectRoot());
+  const bound2 = path14.resolve(getProjectRoot());
   const out = [];
   for (const namespace of mounts) {
     const dir = resolveSubprojectForNamespace(namespace);
-    if (!dir || path13.resolve(dir) === bound2) continue;
+    if (!dir || path14.resolve(dir) === bound2) continue;
     const snapshots = listSnapshots(dir);
     if (snapshots.length > 0) out.push({ namespace, snapshots });
   }
@@ -17851,24 +17867,24 @@ function selectPortalSpec(renderedSet, portalId) {
   return [hit];
 }
 function perPortalPath(resolvedOut, portalId) {
-  const ext = path13.extname(resolvedOut);
+  const ext = path14.extname(resolvedOut);
   const stem = ext ? resolvedOut.slice(0, -ext.length) : resolvedOut;
   return `${stem}.${safeFilenamePart(portalId)}${ext}`;
 }
 function writeSurfaceFile(outPath, snapshot, renderedSet) {
-  const resolved = path13.resolve(outPath);
-  fs10.mkdirSync(path13.dirname(resolved), { recursive: true });
+  const resolved = path14.resolve(outPath);
+  fs11.mkdirSync(path14.dirname(resolved), { recursive: true });
   if (!renderedSet || renderedSet.length === 0) {
     writeYamlFile(resolved, snapshot);
     return [resolved];
   }
   if (renderedSet.length === 1) {
-    fs10.writeFileSync(resolved, renderedSet[0].document);
+    fs11.writeFileSync(resolved, renderedSet[0].document);
     return [resolved];
   }
   return renderedSet.map((spec) => {
     const target = perPortalPath(resolved, spec.portalId);
-    fs10.writeFileSync(target, spec.document);
+    fs11.writeFileSync(target, spec.document);
     return target;
   });
 }
@@ -17890,14 +17906,14 @@ function exportSurface(maxAudience, format, outPath, portalId) {
   return exportResult(snapshot, renderedSet, writtenPaths);
 }
 function importSurface(sourcePath, origin) {
-  const resolved = path13.resolve(sourcePath);
-  if (!fs10.existsSync(resolved)) {
+  const resolved = path14.resolve(sourcePath);
+  if (!fs11.existsSync(resolved)) {
     throw new Error(`Surface document not found: ${resolved}`);
   }
-  const body = fs10.readFileSync(resolved, "utf8");
+  const body = fs11.readFileSync(resolved, "utf8");
   let snapshot;
   if (isOpenApiDocument(body)) {
-    const projectName = path13.basename(resolved).replace(/\.(json|ya?ml)$/i, "");
+    const projectName = path14.basename(resolved).replace(/\.(json|ya?ml)$/i, "");
     snapshot = fromOpenApi(body, projectName);
     snapshot = { ...snapshot, origin };
   } else {
@@ -17960,12 +17976,12 @@ function surfaceContentKey(snapshot) {
   const { stateId, generatedAt, origin, ...content } = snapshot;
   return JSON.stringify(content);
 }
-var fs10, path13, SURFACES_DIRNAME, CROSS_BOUNDARY_TARGETS;
+var fs11, path14, SURFACES_DIRNAME, CROSS_BOUNDARY_TARGETS;
 var init_surfaces = __esm({
   "src/core/surfaces.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
     init_fs();
     init_yaml();
     init_filenames();
@@ -17984,12 +18000,12 @@ function digest(content) {
   return crypto4.createHash("sha256").update(normalized, "utf8").digest("hex");
 }
 function currentSpecDigests(root = getProjectRoot()) {
-  const mountDirs = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::")).map((s) => `${path14.resolve(root, s.projectPath).split(path14.sep).join("/")}/`);
+  const mountDirs = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::")).map((s) => `${path15.resolve(root, s.projectPath).split(path15.sep).join("/")}/`);
   const out = {};
   for (const [abs, content] of snapshotSpecFiles()) {
-    const normalized = path14.resolve(abs).split(path14.sep).join("/");
+    const normalized = path15.resolve(abs).split(path15.sep).join("/");
     if (mountDirs.some((dir) => normalized.startsWith(dir))) continue;
-    out[path14.relative(root, abs).split(path14.sep).join("/")] = digest(content);
+    out[path15.relative(root, abs).split(path15.sep).join("/")] = digest(content);
   }
   return out;
 }
@@ -18047,17 +18063,17 @@ function currentChildPins(mounts, root = getProjectRoot()) {
   const pins = {};
   for (const mount of mounts) {
     if (!mount.projectPath || mount.id.includes("::")) continue;
-    const child = readLockRecordAt(path14.resolve(root, mount.projectPath));
+    const child = readLockRecordAt(path15.resolve(root, mount.projectPath));
     if (child) pins[mount.id] = pinOf(child.stateId);
   }
   return pins;
 }
-var crypto4, path14;
+var crypto4, path15;
 var init_approval = __esm({
   "src/core/approval.ts"() {
     "use strict";
     crypto4 = __toESM(require("crypto"));
-    path14 = __toESM(require("path"));
+    path15 = __toESM(require("path"));
     init_fs();
     init_specs2();
     init_lockfile();
@@ -18345,13 +18361,13 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
 function resolveThroughParent(boundRoot, treatAllAsComplete, childRules) {
   const reach = getRequestParentReach();
   if (reach && !reach.parentReach) return null;
-  const ceiling = reach?.topRoot ? path15.resolve(reach.topRoot) : void 0;
+  const ceiling = reach?.topRoot ? path16.resolve(reach.topRoot) : void 0;
   const chain = [];
-  let top = path15.resolve(boundRoot);
+  let top = path16.resolve(boundRoot);
   while (top !== ceiling) {
     const hop = findChainingParent(top, ceiling);
     if (!hop) break;
-    const next = path15.resolve(hop.parentRoot);
+    const next = path16.resolve(hop.parentRoot);
     if (ceiling && !isWithinOrEqual(ceiling, next)) break;
     chain.unshift(hop.subsystemId);
     top = next;
@@ -18398,8 +18414,8 @@ function isIdChar(ch) {
   return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_" || ch === "-" || ch === "." || ch === ":";
 }
 function isWithinOrEqual(dir, target) {
-  const rel2 = path15.relative(dir, target);
-  return rel2 === "" || !rel2.startsWith("..") && !path15.isAbsolute(rel2);
+  const rel2 = path16.relative(dir, target);
+  return rel2 === "" || !rel2.startsWith("..") && !path16.isAbsolute(rel2);
 }
 function dedupeIssues(list) {
   const seen = /* @__PURE__ */ new Set();
@@ -18420,7 +18436,7 @@ function settledStatusBearing(loaded) {
   if (!settled || settled.size === 0) return [];
   const root = getProjectRoot();
   const index = scanAllSpecs();
-  const rel2 = (abs) => path15.relative(root, abs).split(path15.sep).join("/");
+  const rel2 = (abs) => path16.relative(root, abs).split(path16.sep).join("/");
   const out = [];
   const take = (specs, paths) => {
     for (const spec of specs) {
@@ -18450,7 +18466,7 @@ function computeGateStateId() {
   registerBuiltinRules();
   return computeGateIdentity(content, extensions, ruleSequence(), inputs, gate);
 }
-var path15, RESOLUTION_FAILURE_CODES, SEVERITY_RANK;
+var path16, RESOLUTION_FAILURE_CODES, SEVERITY_RANK;
 var init_validation = __esm({
   "src/core/validation.ts"() {
     "use strict";
@@ -18466,7 +18482,7 @@ var init_validation = __esm({
     init_source_analysis();
     init_specs2();
     init_fs();
-    path15 = __toESM(require("path"));
+    path16 = __toESM(require("path"));
     init_approval();
     RESOLUTION_FAILURE_CODES = /* @__PURE__ */ new Set([
       "UNDEFINED_TYPE_REFERENCE",
@@ -19109,42 +19125,42 @@ function rebaseReference(ref, mount, direction, isMoved = () => false) {
   return relativizeId(travels ? qualifyId(left, to, NO_ROOT_SUBSYSTEMS) : target, to);
 }
 function isWithin(dir, file) {
-  const d = path16.resolve(dir);
-  const f = path16.resolve(file);
-  return f === d || f.startsWith(d + path16.sep);
+  const d = path17.resolve(dir);
+  const f = path17.resolve(file);
+  return f === d || f.startsWith(d + path17.sep);
 }
 function canonicalPath(target) {
-  let existing = path16.resolve(target);
+  let existing = path17.resolve(target);
   const rest = [];
   for (; ; ) {
     try {
-      fs11.lstatSync(existing);
+      fs12.lstatSync(existing);
       break;
     } catch {
-      const up = path16.dirname(existing);
-      if (up === existing) return path16.resolve(target);
-      rest.unshift(path16.basename(existing));
+      const up = path17.dirname(existing);
+      if (up === existing) return path17.resolve(target);
+      rest.unshift(path17.basename(existing));
       existing = up;
     }
   }
   try {
-    return path16.join(fs11.realpathSync.native(existing), ...rest);
+    return path17.join(fs12.realpathSync.native(existing), ...rest);
   } catch {
     return null;
   }
 }
 function chainDirKey(dir) {
-  return canonicalPath(dir) ?? path16.resolve(dir);
+  return canonicalPath(dir) ?? path17.resolve(dir);
 }
 function projectPathEscapesRoot(projectRoot, projectPath, resolvedChildDir) {
-  if (path16.isAbsolute(projectPath) || !isWithin(projectRoot, resolvedChildDir)) return true;
+  if (path17.isAbsolute(projectPath) || !isWithin(projectRoot, resolvedChildDir)) return true;
   const root = canonicalPath(projectRoot);
   const child = canonicalPath(resolvedChildDir);
   return root === null || child === null || !isWithin(root, child);
 }
 function assertContainedProjectPath(projectRoot, projectPath) {
-  const root = path16.resolve(projectRoot);
-  const resolved = path16.resolve(root, projectPath);
+  const root = path17.resolve(projectRoot);
+  const resolved = path17.resolve(root, projectPath);
   if (projectPathEscapesRoot(root, projectPath, resolved)) {
     throw new Error(
       `projectPath "${projectPath}" must resolve within the project root "${root}", but resolves to "${resolved}"; absolute, ../-escaping and link-escaping paths are rejected so a chained subproject is always contained by its parent.`
@@ -19155,12 +19171,12 @@ function assertContainedProjectPath(projectRoot, projectPath) {
 function findChainingParent(childRoot, ceiling) {
   let childResolved;
   try {
-    childResolved = path16.resolve(childRoot);
+    childResolved = path17.resolve(childRoot);
   } catch {
     return null;
   }
-  const bound2 = ceiling ? path16.resolve(ceiling) : void 0;
-  let dir = path16.dirname(childResolved);
+  const bound2 = ceiling ? path17.resolve(ceiling) : void 0;
+  let dir = path17.dirname(childResolved);
   for (let hops = 0; hops < 32; hops++) {
     if (bound2 && !isWithin(bound2, dir)) break;
     const specsDir = aiPathsAt(dir).specsDir();
@@ -19176,7 +19192,7 @@ function findChainingParent(childRoot, ceiling) {
           const projectPath = raw.projectPath;
           if (typeof projectPath === "string" && projectPath.trim() !== "") {
             try {
-              const mountDir = path16.resolve(dir, projectPath);
+              const mountDir = path17.resolve(dir, projectPath);
               if (mountDir === childResolved && !projectPathEscapesRoot(dir, projectPath, mountDir)) {
                 const id = raw.id;
                 return { parentRoot: dir, subsystemId: typeof id === "string" ? id : "?" };
@@ -19187,14 +19203,14 @@ function findChainingParent(childRoot, ceiling) {
         }
       }
     }
-    const up = path16.dirname(dir);
+    const up = path17.dirname(dir);
     if (up === dir) break;
     dir = up;
   }
   return null;
 }
 function inspectChainedRoots(rootDir = getProjectRoot()) {
-  const root = path16.resolve(rootDir);
+  const root = path17.resolve(rootDir);
   const inspection = { roots: [], skipped: [] };
   const listed = /* @__PURE__ */ new Set();
   const walk2 = (projectDir, prefix, ancestors, depth) => {
@@ -19213,14 +19229,14 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
       const localId = typeof id === "string" ? id : "?";
       let childDir;
       try {
-        childDir = path16.resolve(projectDir, projectPath);
+        childDir = path17.resolve(projectDir, projectPath);
       } catch {
         continue;
       }
       let reason;
       if (projectPathEscapesRoot(projectDir, projectPath, childDir)) reason = "escapes";
       else if (ancestors.has(chainDirKey(childDir))) reason = "cyclic";
-      else if (!fs11.existsSync(childDir)) reason = "missing";
+      else if (!fs12.existsSync(childDir)) reason = "missing";
       else if (depth >= 32) reason = "too-deep";
       if (reason) {
         const mount = prefix ? qualifyDeclaredId(localId, prefix, true) : localId;
@@ -19230,7 +19246,7 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
       const key = chainDirKey(childDir);
       if (listed.has(key)) continue;
       listed.add(key);
-      inspection.roots.push(path16.relative(root, childDir).split(path16.sep).join("/"));
+      inspection.roots.push(path17.relative(root, childDir).split(path17.sep).join("/"));
       walk2(childDir, prefix ? `${prefix}::${localId}` : localId, /* @__PURE__ */ new Set([...ancestors, key]), depth + 1);
     }
   };
@@ -19316,9 +19332,9 @@ function stripNamespaceFromImplementation(spec, prefix) {
 }
 function childRelativeFilePaths(spec, authoringRoot, childRoot) {
   const reexpress = (p) => {
-    if (path16.isAbsolute(p)) return p;
-    const rel2 = path16.relative(childRoot, path16.resolve(authoringRoot, p));
-    const inside = rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path16.sep}`) && !path16.isAbsolute(rel2);
+    if (path17.isAbsolute(p)) return p;
+    const rel2 = path17.relative(childRoot, path17.resolve(authoringRoot, p));
+    const inside = rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path17.sep}`) && !path17.isAbsolute(rel2);
     return inside ? rel2.replace(/\\/g, "/") : p;
   };
   return {
@@ -19353,23 +19369,12 @@ function findOwner(id, components) {
   }) ?? null;
 }
 function moveComponentFolder(fromDir, toDir) {
-  if (path16.normalize(fromDir) === path16.normalize(toDir)) return false;
-  if (!fs11.existsSync(fromDir) || fs11.existsSync(toDir)) return false;
-  ensureDir(path16.dirname(toDir));
-  fs11.renameSync(fromDir, toDir);
+  if (path17.normalize(fromDir) === path17.normalize(toDir)) return false;
+  if (!fs12.existsSync(fromDir) || fs12.existsSync(toDir)) return false;
+  ensureDir(path17.dirname(toDir));
+  fs12.renameSync(fromDir, toDir);
   return true;
 }
-function cleanEmptyDirs(filePath, specsRoot) {
-  let dir = path16.dirname(filePath);
-  while (dir !== specsRoot && dir.startsWith(specsRoot)) {
-    if (fs11.existsSync(dir) && fs11.readdirSync(dir).length === 0) {
-      fs11.rmdirSync(dir);
-      dir = path16.dirname(dir);
-    } else {
-      break;
-    }
-  }
-}
 function formatZodIssues(error) {
   return error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
 }
@@ -19383,13 +19388,13 @@ function parseOrThrow(schema, value, kind, id) {
 function computeSpecTreeSignature(dirs) {
   const parts = [];
   for (const dir of dirs) {
-    if (!fs11.existsSync(dir)) {
+    if (!fs12.existsSync(dir)) {
       parts.push(`${dir}:missing`);
       continue;
     }
     for (const f of listSpecFiles(dir)) {
       try {
-        const st = fs11.statSync(f);
+        const st = fs12.statSync(f);
         parts.push(`${f}:${st.mtimeMs}:${st.size}`);
       } catch {
         parts.push(`${f}:gone`);
@@ -19634,13 +19639,13 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
   const isPlain = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
   const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
   const at = (prefix, key) => prefix ? `${prefix}.${key}` : key;
-  const say = (path27, why) => {
-    out.push(`${path27} \u2014 ${why}`);
+  const say = (path28, why) => {
+    out.push(`${path28} \u2014 ${why}`);
   };
-  const walkValue = (d, m, s, path27, field) => {
+  const walkValue = (d, m, s, path28, field) => {
     if (Array.isArray(d)) {
       if (!Array.isArray(m)) {
-        say(path27, "the level does not have this field, so the write dropped it");
+        say(path28, "the level does not have this field, so the write dropped it");
         return;
       }
       if (field === "narrative" && d.some(carriesEditMarker)) return;
@@ -19648,32 +19653,32 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
         if (carriesEditMarker(element)) continue;
         const key = reportIdentityOf(field, element);
         if (key === null) {
-          if (!same(m, d)) say(path27, "the level does not keep this value, so the write dropped it");
-          else if (same(s, d)) say(path27, "the stored spec already held this value");
+          if (!same(m, d)) say(path28, "the level does not keep this value, so the write dropped it");
+          else if (same(s, d)) say(path28, "the stored spec already held this value");
           return;
         }
         const mMatch = m.find((i) => reportIdentityOf(field, i) === key);
         const sMatch = Array.isArray(s) ? s.find((i) => reportIdentityOf(field, i) === key) : void 0;
         if (mMatch === void 0) {
-          say(at(path27, key), "the write did not store this element");
+          say(at(path28, key), "the write did not store this element");
           continue;
         }
-        walk2(element, mMatch, sMatch, at(path27, key), field);
+        walk2(element, mMatch, sMatch, at(path28, key), field);
       }
       return;
     }
     if (isPlain(d)) {
       if (!isPlain(m)) {
-        say(path27, "the level does not have this field, so the write dropped it");
+        say(path28, "the level does not have this field, so the write dropped it");
         return;
       }
-      walk2(d, m, s, path27, field);
+      walk2(d, m, s, path28, field);
       return;
     }
-    if (!same(m, d)) say(path27, "the write did not store it \u2014 the level's schema does not keep this value");
-    else if (same(s, d)) say(path27, "the stored spec already held this value");
+    if (!same(m, d)) say(path28, "the write did not store it \u2014 the level's schema does not keep this value");
+    else if (same(s, d)) say(path28, "the stored spec already held this value");
   };
-  function walk2(d, m, s, path27, container) {
+  function walk2(d, m, s, path28, container) {
     for (const [key, value] of Object.entries(d)) {
       if (DELTA_VERBS.has(key) || JUMP_LABEL_TWINS.has(key)) continue;
       if (key === "label" && LABEL_TWIN_CONTAINERS.has(container)) continue;
@@ -19683,13 +19688,13 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
           if (typeof name !== "string") continue;
           const had = isPlain(s) && s[name] !== void 0;
           const still = isPlain(m) && m[name] !== void 0;
-          if (!had) say(at(path27, name), "unset named a field the stored spec did not have");
-          else if (still) say(at(path27, name), "unset did not remove it");
+          if (!had) say(at(path28, name), "unset named a field the stored spec did not have");
+          else if (still) say(at(path28, name), "unset did not remove it");
         }
         continue;
       }
       if (value === void 0 || value === null) continue;
-      const here = at(path27, key);
+      const here = at(path28, key);
       const mValue = isPlain(m) ? m[key] : void 0;
       const sValue = isPlain(s) ? s[key] : void 0;
       if (mValue === void 0) {
@@ -19782,7 +19787,7 @@ function refusedMoveSummary(from, to, methods, refusals, alternatives) {
   return `Refused: moving ${namedMethods(methods)} from "${from}" to "${to}" is refused by ${refusals.join(", ")}. Nothing was written. ` + (cheapest ? `The cheapest legal home is "${cheapest.component}" (${cheapest.newDependencies.length} new dependenc${cheapest.newDependencies.length === 1 ? "y" : "ies"}, ${cheapest.dependencyCount} of ${cheapest.dependencyLimit}).` : `No component of this subsystem can take them as they stand \u2014 ${alternatives.length} were weighed.`);
 }
 function workspaceFor(rootDir) {
-  const key = path16.resolve(rootDir);
+  const key = path17.resolve(rootDir);
   let ws = workspaces.get(key);
   if (!ws) {
     ws = new SpecWorkspace(key);
@@ -19912,13 +19917,13 @@ function snapshotInputKey(snapshot) {
   return canonicalize(content);
 }
 function consumedSurfaceInputsAt(rootDir) {
-  const dir = path16.join(rootDir, ".wai", "surfaces");
+  const dir = path17.join(rootDir, ".wai", "surfaces");
   if (!pathExists(dir)) return [];
   const keys = [];
-  for (const file of fs11.readdirSync(dir)) {
+  for (const file of fs12.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      keys.push(snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path16.join(dir, file)))));
+      keys.push(snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path17.join(dir, file)))));
     } catch {
     }
   }
@@ -19926,7 +19931,7 @@ function consumedSurfaceInputsAt(rootDir) {
 }
 function consumedContractInputs() {
   const root = getProjectRoot();
-  const roots = [root, ...listChainedRoots(root).map((rel2) => path16.join(root, rel2))];
+  const roots = [root, ...listChainedRoots(root).map((rel2) => path17.join(root, rel2))];
   return roots.flatMap(consumedSurfaceInputsAt);
 }
 function readLockState(current2) {
@@ -19962,7 +19967,7 @@ function markSelectionsBundled(bundled) {
   projectConfigRepository.markSelectionsBundled(bundled);
 }
 function computeStateIdAt(root) {
-  const resolved = path16.resolve(root);
+  const resolved = path17.resolve(root);
   return runWithProjectRoot(resolved, () => {
     workspaceFor(resolved).invalidate();
     const system = loadSystemSpec();
@@ -20000,7 +20005,7 @@ function snapshotSpecFiles() {
 }
 function restoreSpecFiles(snapshot) {
   for (const [file, content] of snapshot) {
-    fs11.writeFileSync(file, content);
+    fs12.writeFileSync(file, content);
   }
 }
 function findLegacySpecFiles() {
@@ -20012,12 +20017,12 @@ function updateSpec(kind, id, delta, hooks, dryRun) {
 function moveMethods(from, to, methods, hooks, dryRun) {
   return current().moveMethods(from, to, methods, hooks, dryRun);
 }
-var fs11, path16, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, COMPONENT_AUTH_SOURCE, DELTA_VERBS, JUMP_LABEL_TWINS, LABEL_TWIN_CONTAINERS, SpecWorkspace, DEFAULT_DEPENDENCY_LIMIT, PROSE_FIELDS, workspaces;
+var fs12, path17, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, COMPONENT_AUTH_SOURCE, DELTA_VERBS, JUMP_LABEL_TWINS, LABEL_TWIN_CONTAINERS, SpecWorkspace, DEFAULT_DEPENDENCY_LIMIT, PROSE_FIELDS, workspaces;
 var init_specs2 = __esm({
   "src/core/specs.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path16 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path17 = __toESM(require("path"));
     init_loader();
     init_project_config();
     init_fs();
@@ -20052,7 +20057,7 @@ var init_specs2 = __esm({
         this.rootSubsystems = /* @__PURE__ */ new Set();
         this.scanVisitedSpecDirs = [];
         this.loaderIssues = [];
-        this.rootDir = path16.resolve(rootDir);
+        this.rootDir = path17.resolve(rootDir);
         this.paths = aiPathsAt(this.rootDir);
       }
       invalidate() {
@@ -20095,8 +20100,8 @@ var init_specs2 = __esm({
        * qualifies the spec itself — so scoping a validate to a mount keeps it.
        */
       loaderIssueSpecId(file, rawId, namespacePrefix) {
-        const stem = path16.basename(file, ".yaml");
-        const local = rawId ?? (stem.startsWith(".") ? path16.basename(path16.dirname(file)) : stem);
+        const stem = path17.basename(file, ".yaml");
+        const local = rawId ?? (stem.startsWith(".") ? path17.basename(path17.dirname(file)) : stem);
         return namespacePrefix ? qualifyId(local, namespacePrefix, this.rootSubsystems) : local;
       }
       scanSpecsForProject(projectDir, namespacePrefix, visitedDirs, maxDepth, currentDepth) {
@@ -20106,10 +20111,10 @@ var init_specs2 = __esm({
         this.scanVisitedSpecDirs.push(specsDir);
         if (!pathExists(specsDir)) return index;
         const files = listSpecFiles(specsDir);
-        const systemYaml = path16.normalize(projectPaths.specsSystem());
+        const systemYaml = path17.normalize(projectPaths.specsSystem());
         const localSubprojects = [];
         for (const file of files) {
-          const normFile = path16.normalize(file);
+          const normFile = path17.normalize(file);
           if (normFile === systemYaml) continue;
           let detectedType = "spec";
           let rawId;
@@ -20153,7 +20158,7 @@ var init_specs2 = __esm({
             } else if ("contract" in raw) {
               detectedType = "implementation";
               const parsed = ImplementationSpecSchema.parse(raw);
-              const normalizeSourcePath = (p) => path16.relative(projectDir, path16.resolve(projectDir, p)).replace(/\\/g, "/");
+              const normalizeSourcePath = (p) => path17.relative(projectDir, path17.resolve(projectDir, p)).replace(/\\/g, "/");
               if (parsed.sourcePath) parsed.sourcePath = normalizeSourcePath(parsed.sourcePath);
               for (const method of parsed.methods) {
                 if (method.sourcePath) method.sourcePath = normalizeSourcePath(method.sourcePath);
@@ -20279,7 +20284,7 @@ var init_specs2 = __esm({
         }
         if (currentDepth < maxDepth) {
           for (const subproj of localSubprojects) {
-            const childDir = path16.resolve(projectDir, subproj.projectPath);
+            const childDir = path17.resolve(projectDir, subproj.projectPath);
             const mountId = namespacePrefix ? qualifyDeclaredId(subproj.subsystemId, namespacePrefix, true) : subproj.subsystemId;
             if (projectPathEscapesRoot(projectDir, subproj.projectPath, childDir)) {
               this.loaderIssues.push({
@@ -20299,7 +20304,7 @@ var init_specs2 = __esm({
               });
               continue;
             }
-            if (!fs11.existsSync(childDir)) {
+            if (!fs12.existsSync(childDir)) {
               this.loaderIssues.push({
                 severity: "error",
                 code: "SUBPROJECT_NOT_FOUND",
@@ -20342,7 +20347,7 @@ var init_specs2 = __esm({
           const index = this.scanAll();
           const sub = index.subsystems.find((s) => s.id === currentPrefix);
           if (sub && sub.projectPath) {
-            const nextDir = path16.resolve(currentDir, sub.projectPath);
+            const nextDir = path17.resolve(currentDir, sub.projectPath);
             if (projectPathEscapesRoot(currentDir, sub.projectPath, nextDir)) {
               this.loaderIssues.push({
                 severity: "error",
@@ -20394,9 +20399,9 @@ var init_specs2 = __esm({
           return index.paths.subsystem[matches[0]];
         }
         if (pathExists(this.paths.specsSubsystemsDir()) && listFiles(this.paths.specsSubsystemsDir(), ".yaml").length > 0) {
-          return path16.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
+          return path17.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
         }
-        return path16.join(this.paths.specsDir(), id, ".index.yaml");
+        return path17.join(this.paths.specsDir(), id, ".index.yaml");
       }
       getComponentPath(id, subsystemId) {
         const index = this.scanAll();
@@ -20416,21 +20421,21 @@ var init_specs2 = __esm({
         if (owner) {
           const ownerPath = index.paths.component[owner.id];
           if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-            return path16.join(path16.dirname(ownerPath), id, ".index.yaml");
+            return path17.join(path17.dirname(ownerPath), id, ".index.yaml");
           }
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path16.dirname(subPath);
+          const subDir = path17.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path16.join(subDir, id, ".index.yaml");
+            return path17.join(subDir, id, ".index.yaml");
           }
         }
         if (pathExists(this.paths.specsComponentsDir()) && listFiles(this.paths.specsComponentsDir(), ".yaml").length > 0) {
-          return path16.join(this.paths.specsComponentsDir(), `${id}.yaml`);
+          return path17.join(this.paths.specsComponentsDir(), `${id}.yaml`);
         }
         const targetSubsystem = subsystemId || "default";
-        return path16.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
+        return path17.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
       }
       getInterfacePath(id, componentId) {
         const index = this.scanAll();
@@ -20456,16 +20461,16 @@ var init_specs2 = __esm({
         }
         if (componentId) {
           const compPath = this.getComponentPath(componentId);
-          const compDir = path16.dirname(compPath);
+          const compDir = path17.dirname(compPath);
           if (compPath.endsWith(".index.yaml")) {
-            return path16.join(compDir, ".interface.yaml");
+            return path17.join(compDir, ".interface.yaml");
           }
         }
         if (pathExists(this.paths.specsInterfacesDir()) && listFiles(this.paths.specsInterfacesDir(), ".yaml").length > 0) {
-          return path16.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
+          return path17.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
         }
         const targetComponent = componentId || "default";
-        return path16.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
+        return path17.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
       }
       getImplementationPath(id, contractId) {
         const index = this.scanAll();
@@ -20491,16 +20496,16 @@ var init_specs2 = __esm({
         }
         if (contractId) {
           const intfPath = this.getInterfacePath(contractId);
-          const intfDir = path16.dirname(intfPath);
+          const intfDir = path17.dirname(intfPath);
           if (intfPath.endsWith(".interface.yaml")) {
-            return path16.join(intfDir, ".implementation.yaml");
+            return path17.join(intfDir, ".implementation.yaml");
           }
         }
         if (pathExists(this.paths.specsImplementationsDir()) && listFiles(this.paths.specsImplementationsDir(), ".yaml").length > 0) {
-          return path16.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
+          return path17.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
         }
         const targetContract = contractId ? contractId.replace(/^i/, "") : "default";
-        return path16.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
+        return path17.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
       }
       getTypePath(id, subsystemId, group) {
         const index = this.scanAll();
@@ -20531,7 +20536,7 @@ var init_specs2 = __esm({
           const groupPath = index.paths.group[targetGroup] || index.paths.group[plainGroup];
           if (groupPath) {
             const localId2 = id.split("::").pop();
-            return path16.join(path16.dirname(groupPath), `${localId2}.yaml`);
+            return path17.join(path17.dirname(groupPath), `${localId2}.yaml`);
           }
         }
         let localId = id;
@@ -20544,12 +20549,12 @@ var init_specs2 = __esm({
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path16.dirname(subPath);
+          const subDir = path17.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path16.join(subDir, "types", `${localId}.yaml`);
+            return path17.join(subDir, "types", `${localId}.yaml`);
           }
         }
-        return path16.join(this.paths.specsTypesDir(), `${localId}.yaml`);
+        return path17.join(this.paths.specsTypesDir(), `${localId}.yaml`);
       }
       getGroupPath(id, subsystemId) {
         const index = this.scanAll();
@@ -20583,12 +20588,12 @@ var init_specs2 = __esm({
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path16.dirname(subPath);
+          const subDir = path17.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path16.join(subDir, "types", localId, ".index.yaml");
+            return path17.join(subDir, "types", localId, ".index.yaml");
           }
         }
-        return path16.join(this.paths.specsTypesDir(), localId, ".index.yaml");
+        return path17.join(this.paths.specsTypesDir(), localId, ".index.yaml");
       }
       // -------------------------------------------------------------------------
       // Level 0: System
@@ -20611,7 +20616,7 @@ var init_specs2 = __esm({
       }
       saveSystemSpec(spec) {
         const p = this.paths.specsSystem();
-        ensureDir(path16.dirname(p));
+        ensureDir(path17.dirname(p));
         writeSpecFile(p, parseOrThrow(SystemSpecSchema, spec, "system", spec.name));
         invalidateSpecCache();
       }
@@ -20733,7 +20738,7 @@ var init_specs2 = __esm({
       }
       saveSubsystemSpec(spec, opts) {
         const p = this.getSubsystemPath(spec.id);
-        ensureDir(path16.dirname(p));
+        ensureDir(path17.dirname(p));
         const { prefix } = splitNamespace(spec.id);
         if (!prefix && spec.projectPath && spec.projectPath.trim() !== "") {
           assertContainedProjectPath(this.rootDir, spec.projectPath);
@@ -20767,9 +20772,7 @@ var init_specs2 = __esm({
       }
       deleteSubsystemSpec(id) {
         const p = this.getSubsystemPath(id);
-        if (!fs11.existsSync(p)) return false;
-        fs11.unlinkSync(p);
-        cleanEmptyDirs(p, path16.resolve(this.paths.specsDir()));
+        if (!removeSpecFile(p, this.paths.specsDir())) return false;
         invalidateSpecCache();
         return true;
       }
@@ -20802,7 +20805,7 @@ var init_specs2 = __esm({
       saveComponentSpec(spec, opts) {
         const notices = [];
         const p = this.getComponentPath(spec.id, spec.subsystem);
-        ensureDir(path16.dirname(p));
+        ensureDir(path17.dirname(p));
         const specToWrite = this.prepareComponentForWrite(spec);
         const existing = this.loadComponentSpec(spec.id);
         if (existing) {
@@ -20819,7 +20822,7 @@ var init_specs2 = __esm({
         const subsystemChanged = existing && existing.subsystem !== spec.subsystem && splitNamespace(existing.subsystem).localId !== splitNamespace(spec.subsystem).localId;
         if (subsystemChanged && !p.endsWith(".index.yaml")) {
           notices.push(
-            `component "${spec.id}" already exists at ${path16.relative(this.rootDir, p)} \u2014 the flat layout re-saves in place and never relocates the file. The subsystem field is now "${spec.subsystem}" (was "${existing.subsystem}").`
+            `component "${spec.id}" already exists at ${path17.relative(this.rootDir, p)} \u2014 the flat layout re-saves in place and never relocates the file. The subsystem field is now "${spec.subsystem}" (was "${existing.subsystem}").`
           );
         }
         specToWrite.updatedAt = opts?.preserveUpdatedAt && existing?.updatedAt ? existing.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
@@ -20830,9 +20833,7 @@ var init_specs2 = __esm({
       }
       deleteComponentSpec(id) {
         const p = this.getComponentPath(id);
-        if (!fs11.existsSync(p)) return false;
-        fs11.unlinkSync(p);
-        cleanEmptyDirs(p, path16.resolve(this.paths.specsDir()));
+        if (!removeSpecFile(p, this.paths.specsDir())) return false;
         invalidateSpecCache();
         return true;
       }
@@ -20845,12 +20846,12 @@ var init_specs2 = __esm({
         if (owner) {
           const ownerPath = index.paths.component[owner.id];
           if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-            const ownerSubDir = path16.dirname(this.getSubsystemPath(owner.subsystem));
-            return path16.join(ownerSubDir, owner.id, comp.id);
+            const ownerSubDir = path17.dirname(this.getSubsystemPath(owner.subsystem));
+            return path17.join(ownerSubDir, owner.id, comp.id);
           }
         }
-        const subDir = path16.dirname(this.getSubsystemPath(comp.subsystem));
-        return path16.join(subDir, comp.id);
+        const subDir = path17.dirname(this.getSubsystemPath(comp.subsystem));
+        return path17.join(subDir, comp.id);
       }
       /**
        * Move component folders so the physical tree mirrors ownership: each owned
@@ -20866,7 +20867,7 @@ var init_specs2 = __esm({
           if (!currentPath) continue;
           const desiredDir = this.desiredComponentDir(comp, index);
           if (!desiredDir) continue;
-          if (moveComponentFolder(path16.dirname(currentPath), desiredDir)) moved.push(comp.id);
+          if (moveComponentFolder(path17.dirname(currentPath), desiredDir)) moved.push(comp.id);
         }
         if (moved.length) invalidateSpecCache();
         return moved;
@@ -20922,7 +20923,7 @@ var init_specs2 = __esm({
         if (!occupantId) return;
         if (occupantId === id || splitNamespace(occupantId).localId === splitNamespace(id).localId) return;
         throw new Error(
-          `Cannot write ${kind} "${id}": ${parentLabel} is already ${kind === "interface" ? "served by" : "implemented by"} "${occupantId}" at ${path16.relative(this.rootDir, p)}, and both ids resolve to that one file. Re-author "${occupantId}" instead, or delete it first if you meant to replace it.`
+          `Cannot write ${kind} "${id}": ${parentLabel} is already ${kind === "interface" ? "served by" : "implemented by"} "${occupantId}" at ${path17.relative(this.rootDir, p)}, and both ids resolve to that one file. Re-author "${occupantId}" instead, or delete it first if you meant to replace it.`
         );
       }
       /** Returns non-fatal placement notices (see saveTypeSpec) — empty when there is nothing to clarify. */
@@ -20930,12 +20931,12 @@ var init_specs2 = __esm({
         const notices = [];
         const p = this.getInterfacePath(spec.id, spec.component);
         this.assertPathHoldsNoOtherSpec(p, spec.id, "interface", `component "${spec.component}"`);
-        ensureDir(path16.dirname(p));
+        ensureDir(path17.dirname(p));
         const specToWrite = this.prepareInterfaceForWrite(spec);
         const existing = this.loadInterfaceSpec(spec.id);
         if (existing && existing.component !== spec.component && splitNamespace(existing.component).localId !== splitNamespace(spec.component).localId) {
           notices.push(
-            `interface "${spec.id}" already exists at ${path16.relative(this.rootDir, p)} \u2014 re-saving updates the component binding field in place (now "${spec.component}", was "${existing.component}") and never moves the file.`
+            `interface "${spec.id}" already exists at ${path17.relative(this.rootDir, p)} \u2014 re-saving updates the component binding field in place (now "${spec.component}", was "${existing.component}") and never moves the file.`
           );
         }
         if (existing) {
@@ -20958,9 +20959,7 @@ var init_specs2 = __esm({
       }
       deleteInterfaceSpec(id) {
         const p = this.getInterfacePath(id);
-        if (!fs11.existsSync(p)) return false;
-        fs11.unlinkSync(p);
-        cleanEmptyDirs(p, path16.resolve(this.paths.specsDir()));
+        if (!removeSpecFile(p, this.paths.specsDir())) return false;
         invalidateSpecCache();
         return true;
       }
@@ -20994,12 +20993,12 @@ var init_specs2 = __esm({
         const notices = [];
         const p = this.getImplementationPath(spec.id, spec.contract);
         this.assertPathHoldsNoOtherSpec(p, spec.id, "implementation", `contract "${spec.contract}"`);
-        ensureDir(path16.dirname(p));
+        ensureDir(path17.dirname(p));
         const specToWrite = this.prepareImplementationForWrite(spec);
         const existing = this.loadImplementationSpec(spec.id);
         if (existing && existing.contract !== spec.contract && splitNamespace(existing.contract).localId !== splitNamespace(spec.contract).localId) {
           notices.push(
-            `implementation "${spec.id}" already exists at ${path16.relative(this.rootDir, p)} \u2014 re-saving updates the contract binding field in place (now "${spec.contract}", was "${existing.contract}") and never moves the file.`
+            `implementation "${spec.id}" already exists at ${path17.relative(this.rootDir, p)} \u2014 re-saving updates the contract binding field in place (now "${spec.contract}", was "${existing.contract}") and never moves the file.`
           );
         }
         if (existing) {
@@ -21015,9 +21014,7 @@ var init_specs2 = __esm({
       }
       deleteImplementationSpec(id) {
         const p = this.getImplementationPath(id);
-        if (!fs11.existsSync(p)) return false;
-        fs11.unlinkSync(p);
-        cleanEmptyDirs(p, path16.resolve(this.paths.specsDir()));
+        if (!removeSpecFile(p, this.paths.specsDir())) return false;
         invalidateSpecCache();
         return true;
       }
@@ -21042,11 +21039,11 @@ var init_specs2 = __esm({
         const existing = this.loadTypeSpec(spec.id);
         const group = spec.group || (existing ? existing.group : void 0);
         const p = this.getTypePath(spec.id, spec.subsystem, group);
-        ensureDir(path16.dirname(p));
+        ensureDir(path17.dirname(p));
         const subsystemChanged = existing && (existing.subsystem ?? "") !== (spec.subsystem ?? "") && splitNamespace(existing.subsystem ?? "").localId !== splitNamespace(spec.subsystem ?? "").localId;
         if (subsystemChanged) {
           notices.push(
-            `type "${spec.id}" already exists at ${path16.relative(this.rootDir, p)} \u2014 re-saving updates fields in place and never relocates the file. The subsystem field is now "${spec.subsystem ?? "(none)"}" (was "${existing.subsystem ?? "(none)"}").`
+            `type "${spec.id}" already exists at ${path17.relative(this.rootDir, p)} \u2014 re-saving updates fields in place and never relocates the file. The subsystem field is now "${spec.subsystem ?? "(none)"}" (was "${existing.subsystem ?? "(none)"}").`
           );
         }
         if (spec.subsystem && (!existing || subsystemChanged) && !this.getSubsystemPath(spec.subsystem).endsWith(".index.yaml")) {
@@ -21069,9 +21066,7 @@ var init_specs2 = __esm({
       deleteTypeSpec(id) {
         const spec = this.loadTypeSpec(id);
         const p = this.getTypePath(id, spec?.subsystem, spec?.group);
-        if (!fs11.existsSync(p)) return false;
-        fs11.unlinkSync(p);
-        cleanEmptyDirs(p, path16.resolve(this.paths.specsDir()));
+        if (!removeSpecFile(p, this.paths.specsDir())) return false;
         invalidateSpecCache();
         return true;
       }
@@ -21086,7 +21081,7 @@ var init_specs2 = __esm({
       }
       saveGroupSpec(spec, opts) {
         const p = this.getGroupPath(spec.id);
-        ensureDir(path16.dirname(p));
+        ensureDir(path17.dirname(p));
         const specToWrite = this.prepareGroupForWrite(spec);
         const existing = this.loadGroupSpec(spec.id);
         if (existing) {
@@ -21098,9 +21093,7 @@ var init_specs2 = __esm({
       }
       deleteGroupSpec(id) {
         const p = this.getGroupPath(id);
-        if (!fs11.existsSync(p)) return false;
-        fs11.unlinkSync(p);
-        cleanEmptyDirs(p, path16.resolve(this.paths.specsDir()));
+        if (!removeSpecFile(p, this.paths.specsDir())) return false;
         invalidateSpecCache();
         return true;
       }
@@ -21166,7 +21159,7 @@ var init_specs2 = __esm({
         };
         const out = /* @__PURE__ */ new Set();
         const add = (p) => {
-          if (p) out.add(path16.resolve(p));
+          if (p) out.add(path17.resolve(p));
         };
         for (const s of this.loadSubsystemSpecs()) {
           if (!scopeSubsystem || s.id === scopeSubsystem || s.id.startsWith(`${scopeSubsystem}::`)) {
@@ -21237,16 +21230,16 @@ var init_specs2 = __esm({
         const files = /* @__PURE__ */ new Set();
         const sysPath = this.paths.specsSystem();
         if (pathExists(sysPath)) {
-          files.add(path16.resolve(sysPath));
+          files.add(path17.resolve(sysPath));
         }
         for (const group of Object.values(index.paths)) {
           for (const file of Object.values(group)) {
-            files.add(path16.resolve(file));
+            files.add(path17.resolve(file));
           }
         }
         for (const file of files) {
-          if (fs11.existsSync(file)) {
-            snapshot.set(file, fs11.readFileSync(file, "utf8"));
+          if (fs12.existsSync(file)) {
+            snapshot.set(file, fs12.readFileSync(file, "utf8"));
           }
         }
         return snapshot;
@@ -21260,20 +21253,20 @@ var init_specs2 = __esm({
         const files = listSpecFiles(specsDir);
         const legacy = [];
         for (const f of files) {
-          const base = path16.basename(f);
-          const dir = path16.dirname(f);
+          const base = path17.basename(f);
+          const dir = path17.dirname(f);
           if (base === "system.yaml") {
-            legacy.push({ path: f, expected: path16.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path17.join(dir, ".index.yaml") });
           } else if (base === "subsystem.yaml") {
-            legacy.push({ path: f, expected: path16.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path17.join(dir, ".index.yaml") });
           } else if (base === "component.yaml") {
-            legacy.push({ path: f, expected: path16.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path17.join(dir, ".index.yaml") });
           } else if (base === "group.yaml") {
-            legacy.push({ path: f, expected: path16.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path17.join(dir, ".index.yaml") });
           } else if (base === "interface.yaml") {
-            legacy.push({ path: f, expected: path16.join(dir, ".interface.yaml") });
+            legacy.push({ path: f, expected: path17.join(dir, ".interface.yaml") });
           } else if (base === "implementation.yaml") {
-            legacy.push({ path: f, expected: path16.join(dir, ".implementation.yaml") });
+            legacy.push({ path: f, expected: path17.join(dir, ".implementation.yaml") });
           }
         }
         return legacy;
@@ -22284,8 +22277,8 @@ __export(agent_resolver_exports, {
   resolveAgentTopology: () => resolveAgentTopology
 });
 function listFilesRecursiveSafe(dirPath, ext) {
-  if (!fs12.existsSync(dirPath)) return [];
-  const nameLower = path17.basename(dirPath).toLowerCase();
+  if (!fs13.existsSync(dirPath)) return [];
+  const nameLower = path18.basename(dirPath).toLowerCase();
   const IGNORED_DIRS = /* @__PURE__ */ new Set([
     "node_modules",
     "target",
@@ -22300,10 +22293,10 @@ function listFilesRecursiveSafe(dirPath, ext) {
     ".vscode"
   ]);
   if (IGNORED_DIRS.has(nameLower)) return [];
-  const entries = fs12.readdirSync(dirPath, { withFileTypes: true });
+  const entries = fs13.readdirSync(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path17.join(dirPath, entry.name);
+    const fullPath = path18.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...listFilesRecursiveSafe(fullPath, ext));
     } else if (entry.isFile() && entry.name.endsWith(ext)) {
@@ -22316,8 +22309,8 @@ function getProjectFiles(projectDir) {
   let files = projectFilesCache.get(projectDir);
   if (!files) {
     files = [];
-    const srcDir = path17.join(projectDir, "src");
-    const legacySrcDir = path17.join(projectDir, "legacy-src");
+    const srcDir = path18.join(projectDir, "src");
+    const legacySrcDir = path18.join(projectDir, "legacy-src");
     let searchDir = projectDir;
     if (pathExists(srcDir)) {
       searchDir = srcDir;
@@ -22332,7 +22325,7 @@ function getProjectFiles(projectDir) {
       files.push(...listFilesRecursiveSafe(searchDir, ext));
     }
     const rootDir = getProjectRoot();
-    files = files.map((f) => path17.relative(rootDir, f).replace(/\\/g, "/"));
+    files = files.map((f) => path18.relative(rootDir, f).replace(/\\/g, "/"));
     projectFilesCache.set(projectDir, files);
   }
   return files;
@@ -22357,8 +22350,8 @@ function inferSourcePathForComponent(comp, subsystems) {
     let bestFile = null;
     let bestScore = -1;
     for (const f of files) {
-      const ext = path17.extname(f);
-      const base = path17.basename(f, ext).toLowerCase();
+      const ext = path18.extname(f);
+      const base = path18.basename(f, ext).toLowerCase();
       if (candidates.has(base)) {
         let score = 0;
         const normalizedPath = f.toLowerCase();
@@ -22455,7 +22448,7 @@ function resolveAgentTopology() {
   });
   for (const sub of subsystems) {
     if (sub.projectPath) {
-      const mountSpecPath = path17.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/");
+      const mountSpecPath = path18.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/");
       agents.push({
         id: `${sub.id}-owner`,
         name: `${sub.name} (chained subproject)`,
@@ -22477,9 +22470,9 @@ function resolveAgentTopology() {
     }
     const subComponents = components.filter((c) => c.subsystem === sub.id);
     const ownedPaths = [];
-    ownedPaths.push(path17.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/"));
+    ownedPaths.push(path18.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/"));
     for (const c of subComponents) {
-      ownedPaths.push(path17.relative(getProjectRoot(), getComponentPath(c.id, sub.id)).replace(/\\/g, "/"));
+      ownedPaths.push(path18.relative(getProjectRoot(), getComponentPath(c.id, sub.id)).replace(/\\/g, "/"));
     }
     if (!config.rules.generateComponentImplementers) {
       for (const comp of subComponents) {
@@ -22555,10 +22548,10 @@ function resolveAgentTopology() {
       }
       const dependencies = comp.dependsOn.map((depId) => `${depId}-implementer`);
       const readPaths = [
-        path17.relative(getProjectRoot(), AI_PATHS.specsSystem()).replace(/\\/g, "/"),
-        path17.relative(getProjectRoot(), getComponentPath(comp.id, comp.subsystem)).replace(/\\/g, "/"),
-        ...compInterfaces.map((i) => path17.relative(getProjectRoot(), getInterfacePath(i.id, comp.id)).replace(/\\/g, "/")),
-        ...compImpls.map((impl) => path17.relative(getProjectRoot(), getImplementationPath(impl.id, impl.contract)).replace(/\\/g, "/"))
+        path18.relative(getProjectRoot(), AI_PATHS.specsSystem()).replace(/\\/g, "/"),
+        path18.relative(getProjectRoot(), getComponentPath(comp.id, comp.subsystem)).replace(/\\/g, "/"),
+        ...compInterfaces.map((i) => path18.relative(getProjectRoot(), getInterfacePath(i.id, comp.id)).replace(/\\/g, "/")),
+        ...compImpls.map((impl) => path18.relative(getProjectRoot(), getImplementationPath(impl.id, impl.contract)).replace(/\\/g, "/"))
       ];
       agents.push({
         id: `${comp.id}-implementer`,
@@ -22647,12 +22640,12 @@ ${guidance.trim()}
     budget
   };
 }
-var path17, fs12, projectFilesCache, UnknownAgentError;
+var path18, fs13, projectFilesCache, UnknownAgentError;
 var init_agent_resolver = __esm({
   "src/core/agent_resolver.ts"() {
     "use strict";
-    path17 = __toESM(require("path"));
-    fs12 = __toESM(require("fs"));
+    path18 = __toESM(require("path"));
+    fs13 = __toESM(require("fs"));
     init_loader();
     init_project_config();
     init_fs();
@@ -22675,12 +22668,12 @@ var init_agent_resolver = __esm({
 
 // src/config/loader.ts
 function aiPathsAt(rootDir) {
-  const resolvedRoot = path18.resolve(rootDir);
+  const resolvedRoot = path19.resolve(rootDir);
   const aiDirAt2 = (...segments) => {
-    const waiPath = path18.join(resolvedRoot, ".wai");
-    const waironPath = path18.join(resolvedRoot, ".wairon");
-    const base = !fs13.existsSync(waiPath) && fs13.existsSync(waironPath) ? waironPath : waiPath;
-    return path18.join(base, ...segments);
+    const waiPath = path19.join(resolvedRoot, ".wai");
+    const waironPath = path19.join(resolvedRoot, ".wairon");
+    const base = !fs14.existsSync(waiPath) && fs14.existsSync(waironPath) ? waironPath : waiPath;
+    return path19.join(base, ...segments);
   };
   const specsDir = () => projectConfigRepositoryAt(resolvedRoot).specsDir();
   return {
@@ -22697,12 +22690,12 @@ function aiPathsAt(rootDir) {
     contextDomainsMd: () => aiDirAt2("context", "domains.md"),
     contextWaironGuideMd: () => aiDirAt2("context", "wairon-guide.md"),
     specsDir,
-    specsSystem: () => path18.join(specsDir(), ".index.yaml"),
-    specsSubsystemsDir: () => path18.join(specsDir(), "subsystems"),
-    specsComponentsDir: () => path18.join(specsDir(), "components"),
-    specsInterfacesDir: () => path18.join(specsDir(), "interfaces"),
-    specsImplementationsDir: () => path18.join(specsDir(), "implementations"),
-    specsTypesDir: () => path18.join(specsDir(), "types")
+    specsSystem: () => path19.join(specsDir(), ".index.yaml"),
+    specsSubsystemsDir: () => path19.join(specsDir(), "subsystems"),
+    specsComponentsDir: () => path19.join(specsDir(), "components"),
+    specsInterfacesDir: () => path19.join(specsDir(), "interfaces"),
+    specsImplementationsDir: () => path19.join(specsDir(), "implementations"),
+    specsTypesDir: () => path19.join(specsDir(), "types")
   };
 }
 function isProjectInitialized() {
@@ -22733,12 +22726,12 @@ function loadTopologyConfig() {
 function saveTopologyConfig(config) {
   writeYamlFile(AI_PATHS.topologyConfig(), config);
 }
-var fs13, path18, AI_PATHS;
+var fs14, path19, AI_PATHS;
 var init_loader = __esm({
   "src/config/loader.ts"() {
     "use strict";
-    fs13 = __toESM(require("fs"));
-    path18 = __toESM(require("path"));
+    fs14 = __toESM(require("fs"));
+    path19 = __toESM(require("path"));
     init_fs();
     init_yaml();
     init_errors();
@@ -22779,7 +22772,7 @@ __export(domains_exports, {
   resolveDomains: () => resolveDomains
 });
 function rel(p) {
-  return path19.relative(process.cwd(), p).replace(/\\/g, "/");
+  return path20.relative(process.cwd(), p).replace(/\\/g, "/");
 }
 function deriveSubsystemDomains() {
   const subsystems = loadSubsystemSpecs();
@@ -22829,11 +22822,11 @@ function removeFreeStandingDomain(id) {
   config.domains.splice(idx, 1);
   saveTopologyConfig(config);
 }
-var path19;
+var path20;
 var init_domains = __esm({
   "src/core/domains.ts"() {
     "use strict";
-    path19 = __toESM(require("path"));
+    path20 = __toESM(require("path"));
     init_loader();
     init_specs2();
     init_errors();
@@ -22888,7 +22881,7 @@ function provisionProject(name) {
 function ensureProjectInitialized(fallbackName) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paths = aiPathsAt(getProjectRoot());
-  const hasSystem = fs14.existsSync(paths.specsSystem());
+  const hasSystem = fs15.existsSync(paths.specsSystem());
   let name = fallbackName;
   if (hasSystem) {
     const existing = loadSystemSpec();
@@ -22910,11 +22903,11 @@ function ensureProjectInitialized(fallbackName) {
 function walkChainedSubprojects(projectRoot, onChild) {
   const visited = /* @__PURE__ */ new Set();
   const walk2 = (dir) => {
-    const resolved = path20.resolve(dir);
+    const resolved = path21.resolve(dir);
     if (visited.has(resolved)) return;
     visited.add(resolved);
     const specsDir = aiPathsAt(dir).specsDir();
-    if (!fs14.existsSync(specsDir)) return;
+    if (!fs15.existsSync(specsDir)) return;
     for (const file of listFilesRecursive(specsDir, ".yaml")) {
       let raw;
       try {
@@ -22932,7 +22925,7 @@ function walkChainedSubprojects(projectRoot, onChild) {
         continue;
       }
       const id = raw.id;
-      onChild(childDir, typeof id === "string" ? id : path20.basename(childDir));
+      onChild(childDir, typeof id === "string" ? id : path21.basename(childDir));
       walk2(childDir);
     }
   };
@@ -22941,7 +22934,7 @@ function walkChainedSubprojects(projectRoot, onChild) {
 function listDirectChainedSubprojects(projectRoot) {
   const out = [];
   const specsDir = aiPathsAt(projectRoot).specsDir();
-  if (!fs14.existsSync(specsDir)) return out;
+  if (!fs15.existsSync(specsDir)) return out;
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
     let raw;
     try {
@@ -22959,12 +22952,12 @@ function listDirectChainedSubprojects(projectRoot) {
       continue;
     }
     const id = raw.id;
-    out.push({ dir, subsystemId: typeof id === "string" ? id : path20.basename(dir) });
+    out.push({ dir, subsystemId: typeof id === "string" ? id : path21.basename(dir) });
   }
   return out;
 }
 function childHasSpecsButNoConfig(childDir) {
-  return fs14.existsSync(aiPathsAt(childDir).specsDir()) && !projectConfigRepositoryAt(childDir).exists();
+  return fs15.existsSync(aiPathsAt(childDir).specsDir()) && !projectConfigRepositoryAt(childDir).exists();
 }
 function findChainingSubprojectsMissingConfig(projectRoot) {
   const missing = [];
@@ -23013,14 +23006,14 @@ function moveSubsystemProject(subsystemId, newProjectPath) {
   const oldDir = assertContainedProjectPath(root, sub.projectPath);
   const newDir = assertContainedProjectPath(root, nextPath);
   if (oldDir !== newDir) {
-    if (!fs14.existsSync(oldDir)) {
+    if (!fs15.existsSync(oldDir)) {
       throw new WaironError(`Subproject directory not found at its current path: ${oldDir}`);
     }
-    if (fs14.existsSync(newDir)) {
+    if (fs15.existsSync(newDir)) {
       throw new WaironError(`Target directory already exists: ${newDir}`);
     }
-    ensureDir(path20.dirname(newDir));
-    fs14.renameSync(oldDir, newDir);
+    ensureDir(path21.dirname(newDir));
+    fs15.renameSync(oldDir, newDir);
   }
   saveSubsystemSpec({ ...sub, projectPath: nextPath, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
   invalidateSpecCache();
@@ -23029,9 +23022,9 @@ function toPosixPath(p) {
   return p.replace(/\\/g, "/");
 }
 function isWithinDir(dir, file) {
-  const d = path20.resolve(dir);
-  const f = path20.resolve(file);
-  return f === d || f.startsWith(d + path20.sep);
+  const d = path21.resolve(dir);
+  const f = path21.resolve(file);
+  return f === d || f.startsWith(d + path21.sep);
 }
 function externalizeSubsystem(subsystemId, projectPath) {
   if (subsystemId.includes("::")) {
@@ -23043,14 +23036,14 @@ function externalizeSubsystem(subsystemId, projectPath) {
   }
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
-  const fooDir = path20.join(parentSpecsDir, subsystemId);
-  if (!fs14.existsSync(fooDir)) {
+  const fooDir = path21.join(parentSpecsDir, subsystemId);
+  if (!fs15.existsSync(fooDir)) {
     throw new WaironError(`subsystem specs directory not found: ${fooDir}`);
   }
   const relPath = toPosixPath(projectPath);
   const childDir = assertContainedProjectPath(parentRoot, relPath);
-  const childFooDir = path20.join(childDir, ".wai", "specs", subsystemId);
-  if (fs14.existsSync(childFooDir)) {
+  const childFooDir = path21.join(childDir, ".wai", "specs", subsystemId);
+  if (fs15.existsSync(childFooDir)) {
     throw new WaironError(`target already contains a "${subsystemId}" subsystem: ${childFooDir}`);
   }
   const renameMap = buildRenameMap(
@@ -23062,18 +23055,18 @@ function externalizeSubsystem(subsystemId, projectPath) {
   runWithProjectRoot(childDir, () => {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     projectConfigRepository.create(defaultProjectConfig(childSystemName, now));
-    ensureDir(path20.join(childDir, ".wai", "specs"));
+    ensureDir(path21.join(childDir, ".wai", "specs"));
     saveSystemSpec(bootstrapSystemSpec(childSystemName, now));
   });
-  ensureDir(path20.dirname(childFooDir));
-  fs14.renameSync(fooDir, childFooDir);
+  ensureDir(path21.dirname(childFooDir));
+  fs15.renameSync(fooDir, childFooDir);
   rebaseImplementationPaths(childFooDir, parentRoot, childDir);
-  patchSubsystemIndex(path20.join(childFooDir, ".index.yaml"), (s) => {
+  patchSubsystemIndex(path21.join(childFooDir, ".index.yaml"), (s) => {
     s.parentSystem = childSystemName;
     delete s.projectPath;
   });
   ensureDir(fooDir);
-  writeYamlFile(path20.join(fooDir, ".index.yaml"), {
+  writeYamlFile(path21.join(fooDir, ".index.yaml"), {
     id: subsystemId,
     name: foo.name,
     description: foo.description,
@@ -23100,9 +23093,9 @@ function internalizeSubsystem(subsystemId) {
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
   const childDir = assertContainedProjectPath(parentRoot, foo.projectPath);
-  const childWai = path20.join(childDir, ".wai");
-  const childFooDir = path20.join(childDir, ".wai", "specs", subsystemId);
-  if (!fs14.existsSync(childFooDir)) {
+  const childWai = path21.join(childDir, ".wai");
+  const childFooDir = path21.join(childDir, ".wai", "specs", subsystemId);
+  if (!fs15.existsSync(childFooDir)) {
     throw new WaironError(`external subproject missing subsystem "${subsystemId}": ${childFooDir}`);
   }
   const childOwnSubs = runWithProjectRoot(childDir, () => loadSubsystemSpecs()).filter((s) => !s.id.includes("::"));
@@ -23115,16 +23108,16 @@ function internalizeSubsystem(subsystemId) {
     false
   );
   const parentSystemName = loadSystemSpec()?.name ?? foo.parentSystem;
-  const fooDir = path20.join(parentSpecsDir, subsystemId);
-  fs14.rmSync(fooDir, { recursive: true, force: true });
-  ensureDir(path20.dirname(fooDir));
-  fs14.renameSync(childFooDir, fooDir);
+  const fooDir = path21.join(parentSpecsDir, subsystemId);
+  fs15.rmSync(fooDir, { recursive: true, force: true });
+  ensureDir(path21.dirname(fooDir));
+  fs15.renameSync(childFooDir, fooDir);
   rebaseImplementationPaths(fooDir, childDir, parentRoot);
-  patchSubsystemIndex(path20.join(fooDir, ".index.yaml"), (s) => {
+  patchSubsystemIndex(path21.join(fooDir, ".index.yaml"), (s) => {
     s.parentSystem = parentSystemName;
     delete s.projectPath;
   });
-  fs14.rmSync(childWai, { recursive: true, force: true });
+  fs15.rmSync(childWai, { recursive: true, force: true });
   rewriteRefsInDir(parentSpecsDir, renameMap, fooDir);
   rebaseMovedRefs(fooDir, subsystemId, "outOf");
   invalidateSpecCache();
@@ -23202,8 +23195,8 @@ function rebaseImplementationPaths(specsDir, fromRoot, toRoot) {
     let changed = false;
     const rebase = (holder, key) => {
       const p = holder[key];
-      if (typeof p !== "string" || p === "" || path20.isAbsolute(p)) return;
-      const next = toPosixPath(path20.relative(toRoot, path20.resolve(fromRoot, p)));
+      if (typeof p !== "string" || p === "" || path21.isAbsolute(p)) return;
+      const next = toPosixPath(path21.relative(toRoot, path21.resolve(fromRoot, p)));
       if (next !== p) {
         holder[key] = next;
         changed = true;
@@ -23219,7 +23212,7 @@ function rebaseImplementationPaths(specsDir, fromRoot, toRoot) {
   }
 }
 function patchSubsystemIndex(indexPath, mutate) {
-  if (!fs14.existsSync(indexPath)) return;
+  if (!fs15.existsSync(indexPath)) return;
   const raw = readYamlFile(indexPath);
   mutate(raw);
   raw.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -23280,28 +23273,28 @@ function moveRenamedSpecs(componentId, newId, component, movingInterface, moving
   if (movedInterface) saveInterfaceSpec({ ...movedInterface, id: interfaceId, component: newId });
   if (movedImplementation) {
     const oldFile = getImplementationPath(movedImplementation.id);
-    if (path20.resolve(getImplementationPath(implementationId, movedImplementation.contract)) === path20.resolve(oldFile)) {
-      fs14.unlinkSync(oldFile);
+    if (path21.resolve(getImplementationPath(implementationId, movedImplementation.contract)) === path21.resolve(oldFile)) {
+      fs15.unlinkSync(oldFile);
     }
     saveImplementationSpec({ ...movedImplementation, id: implementationId });
   }
-  removeSpecFile(getComponentPath(componentId), componentId);
-  if (movingInterface) removeSpecFile(getInterfacePath(movingInterface.id), movingInterface.id);
-  if (movingImplementation) removeSpecFile(getImplementationPath(movingImplementation.id), movingImplementation.id);
+  removeSpecFile2(getComponentPath(componentId), componentId);
+  if (movingInterface) removeSpecFile2(getInterfacePath(movingInterface.id), movingInterface.id);
+  if (movingImplementation) removeSpecFile2(getImplementationPath(movingImplementation.id), movingImplementation.id);
   invalidateSpecCache();
 }
-function removeSpecFile(file, id) {
-  if (!fs14.existsSync(file)) return;
+function removeSpecFile2(file, id) {
+  if (!fs15.existsSync(file)) return;
   try {
     if (readYamlFile(file)?.id !== id) return;
   } catch {
     return;
   }
-  fs14.unlinkSync(file);
-  const specsRoot = path20.resolve(aiPathsAt(getProjectRoot()).specsDir());
-  for (let dir = path20.dirname(path20.resolve(file)); dir !== specsRoot && isWithinDir(specsRoot, dir); dir = path20.dirname(dir)) {
-    if (fs14.readdirSync(dir).length > 0) break;
-    fs14.rmdirSync(dir);
+  fs15.unlinkSync(file);
+  const specsRoot = path21.resolve(aiPathsAt(getProjectRoot()).specsDir());
+  for (let dir = path21.dirname(path21.resolve(file)); dir !== specsRoot && isWithinDir(specsRoot, dir); dir = path21.dirname(dir)) {
+    if (fs15.readdirSync(dir).length > 0) break;
+    fs15.rmdirSync(dir);
   }
 }
 function renameMethod(componentId, methodName, newName, pinSymbol) {
@@ -23398,12 +23391,12 @@ function collectMentions(specsDir, methodName, moved) {
 function identifierPattern(methodName) {
   return new RegExp(`(?<![A-Za-z0-9_])${methodName}(?![A-Za-z0-9_])`);
 }
-var fs14, path20, METHOD_NAME, PROSE_FIELDS2;
+var fs15, path21, METHOD_NAME, PROSE_FIELDS2;
 var init_provision = __esm({
   "src/core/provision.ts"() {
     "use strict";
-    fs14 = __toESM(require("fs"));
-    path20 = __toESM(require("path"));
+    fs15 = __toESM(require("fs"));
+    path21 = __toESM(require("path"));
     init_specs2();
     init_loader();
     init_project_config();
@@ -23565,16 +23558,16 @@ function packNamespace(pack) {
   return pack.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
 function extensionsFor(builtin, packSkills) {
-  return packSkills.filter((s) => s.extends === builtin && fs15.existsSync(s.sourcePath));
+  return packSkills.filter((s) => s.extends === builtin && fs16.existsSync(s.sourcePath));
 }
 function composeBuiltinSkill(name, packSkills) {
   const srcPath = skillTemplatePath(name);
-  const base = fs15.existsSync(srcPath) ? fs15.readFileSync(srcPath, "utf-8") : "";
+  const base = fs16.existsSync(srcPath) ? fs16.readFileSync(srcPath, "utf-8") : "";
   const sections = extensionsFor(name, packSkills);
   if (sections.length === 0) return base;
   const parts = [base.trimEnd()];
   for (const section of sections) {
-    const body = fs15.readFileSync(section.sourcePath, "utf-8").replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+    const body = fs16.readFileSync(section.sourcePath, "utf-8").replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
     parts.push(`## Platform: ${section.pack}`, body.trim());
   }
   return `${parts.join("\n\n")}
@@ -23590,16 +23583,16 @@ function readFrontmatter(raw, fallbackName) {
   return { name: field("name") || fallbackName, description: field("description") };
 }
 function builtinSkillsDir() {
-  return path21.resolve(__dirname, "..", "templates", "skills");
+  return path22.resolve(__dirname, "..", "templates", "skills");
 }
 function skillTemplatePath(name) {
-  return path21.join(builtinSkillsDir(), `${name}.md`);
+  return path22.join(builtinSkillsDir(), `${name}.md`);
 }
 function skillDestPath(type, destDir, name) {
   if (type === "claude" || type === "codex" || type === "gemini" || type === "agy") {
-    return path21.join(destDir, name, "SKILL.md");
+    return path22.join(destDir, name, "SKILL.md");
   }
-  return path21.join(destDir, `${name}.md`);
+  return path22.join(destDir, `${name}.md`);
 }
 function skillsDirForTarget(type) {
   switch (type) {
@@ -23634,22 +23627,22 @@ function exportSddSkills(targetTypes) {
     ensureDir(destDir);
     destinations.push(destDir);
     for (const name of SKILL_NAMES) {
-      if (!fs15.existsSync(skillTemplatePath(name))) continue;
+      if (!fs16.existsSync(skillTemplatePath(name))) continue;
       const content = composeBuiltinSkill(name, packSkills.filter((s) => s.targets.includes(type)));
       const destPath = skillDestPath(type, destDir, name);
-      ensureDir(path21.dirname(destPath));
-      fs15.writeFileSync(destPath, content, "utf-8");
+      ensureDir(path22.dirname(destPath));
+      fs16.writeFileSync(destPath, content, "utf-8");
       fileCount++;
     }
     for (const skill of packSkills) {
       if (skill.extends !== void 0) continue;
       if (!skill.targets.includes(type)) continue;
-      if (!fs15.existsSync(skill.sourcePath)) continue;
+      if (!fs16.existsSync(skill.sourcePath)) continue;
       const id = packSkillId(skill);
-      const content = fs15.readFileSync(skill.sourcePath, "utf-8");
+      const content = fs16.readFileSync(skill.sourcePath, "utf-8");
       const destPath = skillDestPath(type, destDir, id);
-      ensureDir(path21.dirname(destPath));
-      fs15.writeFileSync(destPath, content, "utf-8");
+      ensureDir(path22.dirname(destPath));
+      fs16.writeFileSync(destPath, content, "utf-8");
       fileCount++;
     }
   }
@@ -23662,12 +23655,12 @@ function checkSkillFreshness(type) {
   const packSkills = loadProjectExtensions2().skills.filter((s) => s.targets.includes(type));
   for (const name of SKILL_NAMES) {
     const destPath = skillDestPath(type, dir, name);
-    if (!fs15.existsSync(destPath)) {
+    if (!fs16.existsSync(destPath)) {
       result.missing.push(name);
       continue;
     }
     const want = composeBuiltinSkill(name, packSkills);
-    const have = fs15.readFileSync(destPath, "utf-8");
+    const have = fs16.readFileSync(destPath, "utf-8");
     if (have === want) result.ok.push(name);
     else result.stale.push(name);
   }
@@ -23679,7 +23672,7 @@ function activeTargetTypes2() {
   return activeTargetTypes(config);
 }
 function readSkillFrontmatter(name) {
-  return readFrontmatter(fs15.readFileSync(skillTemplatePath(name), "utf-8"), name);
+  return readFrontmatter(fs16.readFileSync(skillTemplatePath(name), "utf-8"), name);
 }
 function listSkillResources() {
   const builtin = RESOURCE_SKILL_IDS.map((id) => {
@@ -23693,9 +23686,9 @@ function listSkillResources() {
       defaultForHostedMcp: true
     };
   });
-  const pack = loadProjectExtensions2().skills.filter((s) => s.extends === void 0 && fs15.existsSync(s.sourcePath)).map((skill) => {
+  const pack = loadProjectExtensions2().skills.filter((s) => s.extends === void 0 && fs16.existsSync(s.sourcePath)).map((skill) => {
     const id = packSkillId(skill);
-    const fm = readFrontmatter(fs15.readFileSync(skill.sourcePath, "utf-8"), id);
+    const fm = readFrontmatter(fs16.readFileSync(skill.sourcePath, "utf-8"), id);
     return {
       id,
       name: fm.name,
@@ -23711,8 +23704,8 @@ function readSkillResource(resourceId) {
   const packSkills = loadProjectExtensions2().skills;
   if (SKILL_NAMES.includes(resourceId)) return composeBuiltinSkill(resourceId, packSkills);
   const packSkill = packSkills.find((s) => s.extends === void 0 && packSkillId(s) === resourceId);
-  if (packSkill) return fs15.readFileSync(packSkill.sourcePath, "utf-8");
-  return fs15.readFileSync(skillTemplatePath(resourceId), "utf-8");
+  if (packSkill) return fs16.readFileSync(packSkill.sourcePath, "utf-8");
+  return fs16.readFileSync(skillTemplatePath(resourceId), "utf-8");
 }
 function listResources() {
   return listSkillResources();
@@ -23725,12 +23718,12 @@ function readResource(resourceId) {
   if (!known) throw new SkillResourceNotFoundError(resourceId);
   return readSkillResource(resourceId);
 }
-var path21, fs15, SKILL_NAMES, SKILL_RESOURCE_SCHEME, RESOURCE_SKILL_IDS, SkillResourceNotFoundError;
+var path22, fs16, SKILL_NAMES, SKILL_RESOURCE_SCHEME, RESOURCE_SKILL_IDS, SkillResourceNotFoundError;
 var init_skills = __esm({
   "src/core/skills.ts"() {
     "use strict";
-    path21 = __toESM(require("path"));
-    fs15 = __toESM(require("fs"));
+    path22 = __toESM(require("path"));
+    fs16 = __toESM(require("fs"));
     init_fs();
     init_defaults();
     init_project();
@@ -26395,7 +26388,7 @@ var require_dist = __commonJS({
       scaffoldPack: () => scaffoldPack2
     });
     module2.exports = __toCommonJS2(src_exports2);
-    var path27 = __toESM2(require("path"));
+    var path28 = __toESM2(require("path"));
     var import_js_yaml3 = require("js-yaml");
     var import_js_yaml = require("js-yaml");
     var import_crypto = require("crypto");
@@ -26958,8 +26951,8 @@ var require_dist = __commonJS({
     function slug(name) {
       return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
     }
-    var fs17 = __toESM2(require("fs"));
-    var path28 = __toESM2(require("path"));
+    var fs18 = __toESM2(require("fs"));
+    var path29 = __toESM2(require("path"));
     var import_fflate = require_node();
     var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".hg", ".svn"]);
     function listEntries(archive) {
@@ -26997,9 +26990,9 @@ var require_dist = __commonJS({
     }
     function writeTree(destDir, files) {
       for (const file of files) {
-        const absolute = path28.join(destDir, file.path);
-        fs17.mkdirSync(path28.dirname(absolute), { recursive: true });
-        fs17.writeFileSync(absolute, file.contents);
+        const absolute = path29.join(destDir, file.path);
+        fs18.mkdirSync(path29.dirname(absolute), { recursive: true });
+        fs18.writeFileSync(absolute, file.contents);
       }
     }
     function classifyKind(name, symlinks) {
@@ -27008,14 +27001,14 @@ var require_dist = __commonJS({
       return "file";
     }
     function walkPackDir(root, current2, out) {
-      for (const entry of fs17.readdirSync(current2, { withFileTypes: true })) {
+      for (const entry of fs18.readdirSync(current2, { withFileTypes: true })) {
         if (entry.isDirectory()) {
           if (SKIP_DIRS.has(entry.name)) continue;
-          walkPackDir(root, path28.join(current2, entry.name), out);
+          walkPackDir(root, path29.join(current2, entry.name), out);
         } else if (entry.isFile()) {
-          const absolute = path28.join(current2, entry.name);
-          const relative22 = path28.relative(root, absolute).split(path28.sep).join("/");
-          out.push({ path: relative22, contents: fs17.readFileSync(absolute) });
+          const absolute = path29.join(current2, entry.name);
+          const relative22 = path29.relative(root, absolute).split(path29.sep).join("/");
+          out.push({ path: relative22, contents: fs18.readFileSync(absolute) });
         }
       }
     }
@@ -27065,7 +27058,7 @@ var require_dist = __commonJS({
     function scaffoldPack(request) {
       const files = render(request);
       writeTree(request.targetDir, files);
-      return files.map((file) => path27.join(request.targetDir, file.path));
+      return files.map((file) => path28.join(request.targetDir, file.path));
     }
     function buildPack(sourceDir) {
       const files = readPackDir(sourceDir);
@@ -27122,7 +27115,7 @@ var require_dist = __commonJS({
       }
       const manifest = parseManifest(decode(envelope.contents));
       verifyIntegrity2(manifest, files);
-      const directory = path27.resolve(destDir);
+      const directory = path28.resolve(destDir);
       writeTree(directory, files);
       const result = {
         directory,
@@ -27200,7 +27193,7 @@ var require_dist = __commonJS({
       }
       const manifest = parseTreeManifest(decode(envelope.contents));
       verifyTreeIntegrity(manifest, files);
-      const directory = path27.resolve(destDir);
+      const directory = path28.resolve(destDir);
       writeTree(directory, files);
       const result = {
         destDir: directory,
@@ -27215,7 +27208,7 @@ var require_dist = __commonJS({
       return normalized === "." ? ".wai/" : `${normalized}/.wai/`;
     }
     function normalizeRootPath(relativePath) {
-      const posix2 = relativePath.split(path27.sep).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
+      const posix2 = relativePath.split(path28.sep).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
       return posix2 === "" || posix2 === "." ? "." : posix2;
     }
     function slugify(projectName) {
@@ -27303,41 +27296,41 @@ function hasAuthoredSpecs(root) {
   if (!pathExists(specsDir)) {
     return false;
   }
-  const systemIndex = path22.resolve(paths.specsSystem());
+  const systemIndex = path23.resolve(paths.specsSystem());
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
-    if (path22.resolve(file) !== systemIndex) {
+    if (path23.resolve(file) !== systemIndex) {
       return true;
     }
   }
   return false;
 }
 function createStagingDir(destDir) {
-  const root = path22.resolve(destDir);
-  fs16.mkdirSync(root, { recursive: true });
-  const stagingDir = fs16.mkdtempSync(path22.join(root, STAGING_PREFIX));
+  const root = path23.resolve(destDir);
+  fs17.mkdirSync(root, { recursive: true });
+  const stagingDir = fs17.mkdtempSync(path23.join(root, STAGING_PREFIX));
   return stagingDir;
 }
 function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
-  const root = path22.resolve(destDir);
-  const backupDir = path22.join(root, BACKUP_DIR, timestampSlug());
+  const root = path23.resolve(destDir);
+  const backupDir = path23.join(root, BACKUP_DIR, timestampSlug());
   let backedUp = false;
   for (const rootRel of roots) {
     const relative9 = rootRel === "." ? "" : rootRel;
-    const stagedSpecDir = path22.join(stagingDir, relative9, ".wai");
-    if (!fs16.existsSync(stagedSpecDir)) continue;
-    const liveSpecDir = liveSpecDirFor(path22.join(root, relative9));
-    if (backupExisting && liveSpecDir && fs16.existsSync(liveSpecDir)) {
-      const backupTarget = path22.join(backupDir, relative9, path22.basename(liveSpecDir));
-      fs16.mkdirSync(path22.dirname(backupTarget), { recursive: true });
-      fs16.renameSync(liveSpecDir, backupTarget);
+    const stagedSpecDir = path23.join(stagingDir, relative9, ".wai");
+    if (!fs17.existsSync(stagedSpecDir)) continue;
+    const liveSpecDir = liveSpecDirFor(path23.join(root, relative9));
+    if (backupExisting && liveSpecDir && fs17.existsSync(liveSpecDir)) {
+      const backupTarget = path23.join(backupDir, relative9, path23.basename(liveSpecDir));
+      fs17.mkdirSync(path23.dirname(backupTarget), { recursive: true });
+      fs17.renameSync(liveSpecDir, backupTarget);
       backedUp = true;
-    } else if (liveSpecDir && fs16.existsSync(liveSpecDir)) {
-      fs16.rmSync(liveSpecDir, { recursive: true, force: true });
+    } else if (liveSpecDir && fs17.existsSync(liveSpecDir)) {
+      fs17.rmSync(liveSpecDir, { recursive: true, force: true });
     }
-    const target = path22.join(root, relative9, ".wai");
-    fs16.mkdirSync(path22.dirname(target), { recursive: true });
-    if (fs16.existsSync(target)) fs16.rmSync(target, { recursive: true, force: true });
-    fs16.renameSync(stagedSpecDir, target);
+    const target = path23.join(root, relative9, ".wai");
+    fs17.mkdirSync(path23.dirname(target), { recursive: true });
+    if (fs17.existsSync(target)) fs17.rmSync(target, { recursive: true, force: true });
+    fs17.renameSync(stagedSpecDir, target);
   }
   if (backedUp) {
     return backupDir;
@@ -27346,7 +27339,7 @@ function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
 }
 function discardStagingDir(stagingDir) {
   try {
-    fs16.rmSync(stagingDir, { recursive: true, force: true });
+    fs17.rmSync(stagingDir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -27360,7 +27353,7 @@ function exportSpecTree(includeDerived, allowPartial) {
   const skipped = [...inspection.skipped];
   const roots = [{ relativePath: ".", waiDir: aiPathsAt(root).root() }];
   for (const rel2 of inspection.roots) {
-    const waiDir = aiPathsAt(path22.resolve(root, rel2)).root();
+    const waiDir = aiPathsAt(path23.resolve(root, rel2)).root();
     if (pathExists(waiDir)) {
       roots.push({ relativePath: rel2, waiDir });
     } else {
@@ -27391,7 +27384,7 @@ function importSpecTree(archive, options) {
   if (!info.compatible) {
     throw new Error("incompatible .waitree archive (format or minimum wairon version)");
   }
-  const destDir = path22.resolve(options.destDir ?? getProjectRoot());
+  const destDir = path23.resolve(options.destDir ?? getProjectRoot());
   const occupied = hasSpecTree(destDir);
   const authored = hasAuthoredSpecs(destDir);
   if (authored && options.replaceExisting !== true) {
@@ -27422,21 +27415,21 @@ function importSpecTree(archive, options) {
   return result;
 }
 function liveSpecDirFor(rootDir) {
-  const modern = path22.join(rootDir, ".wai");
-  if (fs16.existsSync(modern)) return modern;
-  const legacy = path22.join(rootDir, ".wairon");
-  if (fs16.existsSync(legacy)) return legacy;
+  const modern = path23.join(rootDir, ".wai");
+  if (fs17.existsSync(modern)) return modern;
+  const legacy = path23.join(rootDir, ".wairon");
+  if (fs17.existsSync(legacy)) return legacy;
   return null;
 }
 function timestampSlug() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
-var fs16, path22, sdkPortal, STAGING_PREFIX, BACKUP_DIR;
+var fs17, path23, sdkPortal, STAGING_PREFIX, BACKUP_DIR;
 var init_treetransfer = __esm({
   "src/core/treetransfer.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"));
-    path22 = __toESM(require("path"));
+    fs17 = __toESM(require("fs"));
+    path23 = __toESM(require("path"));
     sdkPortal = __toESM(require_dist());
     init_loader();
     init_fs();
@@ -28139,7 +28132,7 @@ var WAIRON_MANAGED_MARKER = "wairon:managed";
 var WAIRON_MANAGED_BANNER = `<!-- ${WAIRON_MANAGED_MARKER} \u2014 generated by \`wairon generate\`; do not edit, changes are overwritten -->`;
 
 // src/exporters/claude.ts
-var path23 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 init_fs();
 var MODEL_BY_TIER = {
   small: "haiku",
@@ -28179,7 +28172,7 @@ var ClaudeExporter = class {
   outputPath(ctx) {
     const { agent, target, projectRoot } = ctx;
     const outputDir = "outputDir" in target ? target.outputDir : ".claude/agents";
-    return path23.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+    return path24.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
   }
   export(ctx) {
     const { agent, renderedInstructions, budget } = ctx;
@@ -28204,7 +28197,7 @@ var ClaudeExporter = class {
 };
 
 // src/exporters/custom.ts
-var path24 = __toESM(require("path"));
+var path25 = __toESM(require("path"));
 init_fs();
 var CustomExporter = class {
   constructor() {
@@ -28215,7 +28208,7 @@ var CustomExporter = class {
     if (!("outputDir" in target)) {
       throw new Error("CustomExporter requires target.outputDir");
     }
-    return path24.resolve(projectRoot, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+    return path25.resolve(projectRoot, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
   }
   export(ctx) {
     const { agent, target, renderedInstructions } = ctx;
@@ -28238,7 +28231,7 @@ var CustomExporter = class {
 };
 
 // src/exporters/gemini.ts
-var path25 = __toESM(require("path"));
+var path26 = __toESM(require("path"));
 init_fs();
 var GeminiExporter = class {
   constructor() {
@@ -28247,7 +28240,7 @@ var GeminiExporter = class {
   outputPath(ctx) {
     const { agent, target, projectRoot } = ctx;
     const outputDir = "outputDir" in target ? target.outputDir : ".gemini/agents";
-    return path25.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
+    return path26.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
   }
   export(ctx) {
     const { agent, renderedInstructions } = ctx;
@@ -28272,7 +28265,7 @@ function yamlString(value) {
 }
 
 // src/exporters/generate.ts
-var path26 = __toESM(require("path"));
+var path27 = __toESM(require("path"));
 init_core();
 init_execution_profile();
 init_budget_policy();
@@ -28348,7 +28341,7 @@ function resolveExpectedOutputPaths(agents, projectConfig, projectRoot = getProj
       const targetConfig = resolveTargetConfig(agentTarget, projectConfig);
       if (!targetConfig) continue;
       const ctx = { agent, projectRoot, target: targetConfig };
-      expected.add(path26.resolve(getExporter(targetConfig).outputPath(ctx)));
+      expected.add(path27.resolve(getExporter(targetConfig).outputPath(ctx)));
     }
   }
   return expected;