@wairon/cli 5.1.1-dev.56 → 5.1.1-dev.58

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.56";
+    WAIRON_VERSION = "5.1.1-dev.58";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -546,6 +546,21 @@ var init_yaml = __esm({
 });
 
 // src/models/execution.ts
+function summarize(budget, profile) {
+  const lines = [
+    `- **Work shape**: ${profile.breadth} breadth, ${profile.reasoningDepth} reasoning${profile.writes ? "" : ", read-only"}${profile.delegates ? ", delegating" : ""}`,
+    `- **Why**: ${profile.rationale}`
+  ];
+  if (budget.modelTier) lines.push(`- **Capability tier**: ${budget.modelTier}`);
+  if (budget.effort) lines.push(`- **Effort**: ${budget.effort}`);
+  if (budget.maxTurns !== void 0) {
+    lines.push(`- **Turn ceiling**: ${budget.maxTurns} (a circuit breaker \u2014 hitting it should read as a scoping error, not a limit to work up to)`);
+  }
+  lines.push(`- **Tool grant**: ${budget.toolClass}`);
+  lines.push(`- **May delegate further**: ${budget.allowNestedDelegation ? "yes" : "no"}`);
+  lines.push(`- **MCP access**: ${budget.mcp}`);
+  return lines;
+}
 var import_zod, WorkBreadthSchema, ReasoningDepthSchema, ExecutionProfileSchema, ModelTierSchema, EffortTierSchema, ToolClassSchema, McpAccessSchema, ExecutionBudgetSchema, BudgetTierSchema, BUDGET_TIER_DESCRIPTIONS, ExecutionConfigSchema;
 var init_execution = __esm({
   "src/models/execution.ts"() {
@@ -1570,172 +1585,162 @@ var init_paths = __esm({
   }
 });
 
-// src/core/detection.ts
-function detectDomainCandidates(projectRoot2, alreadyTrackedPaths = /* @__PURE__ */ new Set(), alreadyTrackedIds = /* @__PURE__ */ new Set()) {
-  const candidates = /* @__PURE__ */ new Map();
-  for (const c of detectGitSubmodules(projectRoot2)) {
-    candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
-  }
-  for (const c of detectNestedGitRepos(projectRoot2)) {
-    if (!candidates.has(c.path)) {
-      candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
+// src/utils/canonical-json.ts
+function canonicalize(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function compareOrdinal(a, b) {
+  if (a < b) return -1;
+  return a > b ? 1 : 0;
+}
+function sortKeys(v) {
+  if (Array.isArray(v)) return v.map(sortKeys);
+  if (v && typeof v === "object") {
+    const src = v;
+    const out = {};
+    for (const k of Object.keys(src).sort()) {
+      if (k === "createdAt" || k === "updatedAt") continue;
+      out[k] = sortKeys(src[k]);
     }
+    return out;
   }
-  const gitPaths = new Set(
-    Array.from(candidates.values()).filter((c) => c.type === "git-submodule" || c.type === "git-repo").map((c) => c.path)
-  );
-  for (const c of detectPackageRoots(projectRoot2)) {
-    if (candidates.has(c.path)) continue;
-    const insideGit = Array.from(gitPaths).some(
-      (gp) => c.path === gp || c.path.startsWith(gp + "/")
-    );
-    if (insideGit) continue;
-    candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
-  }
-  const sorted = Array.from(candidates.values()).sort((a, b) => a.path.localeCompare(b.path));
-  return deduplicateIds(sorted, alreadyTrackedIds);
+  return v;
 }
-function deduplicateIds(candidates, existingIds = /* @__PURE__ */ new Set()) {
-  const idCount = /* @__PURE__ */ new Map();
-  for (const id of existingIds) {
-    idCount.set(id, (idCount.get(id) ?? 0) + 1);
-  }
-  for (const c of candidates) {
-    idCount.set(c.suggestedId, (idCount.get(c.suggestedId) ?? 0) + 1);
+var init_canonical_json = __esm({
+  "src/utils/canonical-json.ts"() {
+    "use strict";
   }
-  return candidates.map((c) => {
-    if ((idCount.get(c.suggestedId) ?? 0) <= 1) return c;
-    const parts = c.path.split("/");
-    const qualifiedId2 = parts.length >= 2 ? pathToId(`${parts[parts.length - 2]}-${parts[parts.length - 1]}`) : c.suggestedId;
-    return { ...c, suggestedId: qualifiedId2 };
-  });
+});
+
+// src/core/statehash.ts
+function inIdentityOrder(specs) {
+  return specs.map((spec) => ({ spec, content: canonicalize(spec) })).sort((a, b) => compareOrdinal(a.spec.id, b.spec.id) || compareOrdinal(a.content, b.content)).map((entry) => entry.spec);
 }
-function parseGitmodules(filePath) {
-  const content = fs7.readFileSync(filePath, "utf-8");
-  const entries = [];
-  let current2 = {};
-  for (const line2 of content.split("\n")) {
-    const trimmed = line2.trim();
-    const headerMatch = trimmed.match(/^\[submodule "(.+)"\]$/);
-    if (headerMatch) {
-      if (current2.path) entries.push(current2);
-      current2 = { name: headerMatch[1] };
-      continue;
-    }
-    const keyVal = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
-    if (keyVal) {
-      const [, key, value] = keyVal;
-      if (key === "path") current2.path = value.trim();
-      if (key === "url") current2.url = value.trim();
-    }
+function computeStateId() {
+  const tree = {
+    system: loadSystemSpec(),
+    subsystems: inIdentityOrder(loadSubsystemSpecs()),
+    components: inIdentityOrder(loadComponentSpecs()),
+    interfaces: inIdentityOrder(loadInterfaceSpecs()),
+    implementations: inIdentityOrder(loadImplementationSpecs()),
+    types: inIdentityOrder(loadTypeSpecs())
+  };
+  const digest2 = crypto.createHash("sha256").update(canonicalize(tree)).digest("hex");
+  return { algorithm: CONTENT_ALGORITHM, digest: digest2 };
+}
+function stateIdEquals(a, b) {
+  return !!a && !!b && a.algorithm === b.algorithm && a.digest === b.digest;
+}
+var crypto, CONTENT_ALGORITHM;
+var init_statehash = __esm({
+  "src/core/statehash.ts"() {
+    "use strict";
+    crypto = __toESM(require("crypto"));
+    init_specs2();
+    init_canonical_json();
+    CONTENT_ALGORITHM = "sha256";
   }
-  if (current2.path) entries.push(current2);
-  return entries;
+});
+
+// src/core/lockfile.ts
+function lockPath() {
+  return aiDir("lock.json");
 }
-function detectGitSubmodules(projectRoot2) {
-  const gitmodulesPath = path8.join(projectRoot2, ".gitmodules");
-  if (!fs7.existsSync(gitmodulesPath)) return [];
-  return parseGitmodules(gitmodulesPath).map((entry) => ({
-    suggestedId: pathToId(entry.path),
-    suggestedName: pathToName(entry.path),
-    path: normalizePath(entry.path),
-    type: "git-submodule",
-    alreadyTracked: false
-  }));
+function normalizeApprover(value) {
+  if (value && typeof value === "object" && typeof value.id === "string") {
+    const v = value;
+    const source = v.source === "git" || v.source === "hosted" || v.source === "os" ? v.source : "legacy";
+    return { id: v.id, ...v.name ? { name: v.name } : {}, source };
+  }
+  return { id: typeof value === "string" && value ? value : "unknown", source: "legacy" };
 }
-function detectNestedGitRepos(projectRoot2) {
-  const results = [];
-  walkForGit(projectRoot2, projectRoot2, 0, results);
-  return results;
+function describeApprover(who) {
+  const label = who.name ? `${who.name} (${who.id})` : who.id;
+  return who.source === "hosted" ? `${label} [authenticated]` : label;
 }
-function walkForGit(projectRoot2, currentDir, depth, results) {
-  if (depth > MAX_SCAN_DEPTH) return;
-  let entries;
+function readLockRecord() {
   try {
-    entries = fs7.readdirSync(currentDir, { withFileTypes: true });
+    return normalizeRecord(JSON.parse(fs7.readFileSync(lockPath(), "utf8")));
   } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
-    const fullPath = path8.join(currentDir, entry.name);
-    const relPath = normalizePath(path8.relative(projectRoot2, fullPath));
-    if (relPath === "" || relPath === ".") continue;
-    const gitPath = path8.join(fullPath, ".git");
-    if (fs7.existsSync(gitPath)) {
-      results.push({
-        suggestedId: pathToId(relPath),
-        suggestedName: pathToName(relPath),
-        path: relPath,
-        type: "git-repo",
-        alreadyTracked: false
-      });
-      continue;
-    }
-    walkForGit(projectRoot2, fullPath, depth + 1, results);
+    return null;
   }
 }
-function detectPackageRoots(projectRoot2) {
-  const results = [];
-  walkForPackages(projectRoot2, projectRoot2, 0, results);
-  return results;
-}
-function walkForPackages(projectRoot2, currentDir, depth, results) {
-  if (depth > MAX_SCAN_DEPTH) return;
-  let entries;
+function readLockRecordAt(root) {
   try {
-    entries = fs7.readdirSync(currentDir, { withFileTypes: true });
+    return normalizeRecord(JSON.parse(fs7.readFileSync(aiDirAt(root, "lock.json"), "utf8")));
   } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
-    const fullPath = path8.join(currentDir, entry.name);
-    const relPath = normalizePath(path8.relative(projectRoot2, fullPath));
-    if (relPath === "" || relPath === ".") continue;
-    const hasMarker = PACKAGE_MARKERS.some((m) => fs7.existsSync(path8.join(fullPath, m)));
-    if (hasMarker) {
-      results.push({
-        suggestedId: pathToId(relPath),
-        suggestedName: pathToName(relPath),
-        path: relPath,
-        type: "package-root",
-        alreadyTracked: false
-      });
-    }
-    walkForPackages(projectRoot2, fullPath, depth + 1, results);
+    return null;
   }
 }
-function pathToId(relPath) {
-  const basename15 = path8.basename(relPath);
-  return basename15.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+function normalizeRecord(raw) {
+  const record2 = raw;
+  return { ...record2, lockedBy: normalizeApprover(record2.lockedBy) };
 }
-function pathToName(relPath) {
-  const id = pathToId(relPath);
-  return id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+function writeLockRecord(record2) {
+  const p = lockPath();
+  fs7.mkdirSync(path8.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp`;
+  fs7.writeFileSync(tmp, JSON.stringify(withSortedMaps(record2), null, 2) + "\n");
+  fs7.renameSync(tmp, p);
 }
-function normalizePath(p) {
-  return p.replace(/\\/g, "/");
+function withSortedMaps(record2) {
+  const sorted = (m) => {
+    if (!m) return void 0;
+    const out = {};
+    for (const k of Object.keys(m).sort()) out[k] = m[k];
+    return out;
+  };
+  const specs = sorted(record2.specs);
+  const children = sorted(record2.children);
+  return {
+    ...record2,
+    ...specs ? { specs } : {},
+    ...children ? { children } : {}
+  };
 }
-var fs7, path8, PACKAGE_MARKERS, MAX_SCAN_DEPTH;
-var init_detection = __esm({
-  "src/core/detection.ts"() {
+var fs7, path8;
+var init_lockfile = __esm({
+  "src/core/lockfile.ts"() {
     "use strict";
     fs7 = __toESM(require("fs"));
     path8 = __toESM(require("path"));
-    init_defaults();
-    PACKAGE_MARKERS = [
-      "package.json",
-      "pyproject.toml",
-      "Cargo.toml",
-      "go.mod",
-      "build.gradle",
-      "build.gradle.kts",
-      "pom.xml"
-    ];
-    MAX_SCAN_DEPTH = 5;
+    init_fs();
+  }
+});
+
+// src/core/spec-files.ts
+function readSpecFile(filePath) {
+  return readYamlFile(filePath);
+}
+function writeSpecFile(filePath, document) {
+  writeYamlFile(filePath, document);
+}
+function listSpecFiles(specsDir) {
+  return listFilesRecursive(specsDir, SPEC_FILE_EXTENSION);
+}
+function removeSpecFile(filePath, specsRoot) {
+  if (!fs8.existsSync(filePath)) return false;
+  fs8.unlinkSync(filePath);
+  pruneEmptyDirs(path9.dirname(filePath), path9.resolve(specsRoot));
+  return true;
+}
+function pruneEmptyDirs(dir, specsRoot) {
+  let at = dir;
+  while (at !== specsRoot && at.startsWith(specsRoot)) {
+    if (!fs8.existsSync(at) || fs8.readdirSync(at).length > 0) return;
+    fs8.rmdirSync(at);
+    at = path9.dirname(at);
+  }
+}
+var fs8, path9, SPEC_FILE_EXTENSION;
+var init_spec_files = __esm({
+  "src/core/spec-files.ts"() {
+    "use strict";
+    fs8 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    init_fs();
+    init_yaml();
+    SPEC_FILE_EXTENSION = ".yaml";
   }
 });
 
@@ -3295,7 +3300,7 @@ function hasFunctionBody(facts, symbol) {
 }
 function resolveImport(fromFile, specifier, knownPaths) {
   if (!specifier.startsWith(".")) return void 0;
-  const joined = pathKey(path9.posix.normalize(path9.posix.join(path9.posix.dirname(fromFile), specifier)));
+  const joined = pathKey(path10.posix.normalize(path10.posix.join(path10.posix.dirname(fromFile), specifier)));
   const candidates = [
     joined,
     joined.replace(/\.js$/, ".ts"),
@@ -3311,11 +3316,11 @@ function resolveImport(fromFile, specifier, knownPaths) {
   }
   return void 0;
 }
-var path9, NO_DECLARED_TYPES;
+var path10, NO_DECLARED_TYPES;
 var init_code_model = __esm({
   "src/models/code-model.ts"() {
     "use strict";
-    path9 = __toESM(require("path"));
+    path10 = __toESM(require("path"));
     NO_DECLARED_TYPES = [];
   }
 });
@@ -3356,186 +3361,6 @@ var init_models = __esm({
   }
 });
 
-// src/config/loader.ts
-function loadTopologyConfig() {
-  assertProjectInitialized();
-  if (!pathExists(AI_PATHS.topologyConfig())) return createEmptyTopologyConfig();
-  const raw = readYamlFile(AI_PATHS.topologyConfig());
-  if (!raw) return createEmptyTopologyConfig();
-  return TopologyConfigSchema.parse(raw);
-}
-function saveTopologyConfig(config) {
-  writeYamlFile(AI_PATHS.topologyConfig(), config);
-}
-var init_loader = __esm({
-  "src/config/loader.ts"() {
-    "use strict";
-    init_fs();
-    init_yaml();
-    init_models();
-    init_paths();
-  }
-});
-
-// src/utils/canonical-json.ts
-function canonicalize(value) {
-  return JSON.stringify(sortKeys(value));
-}
-function compareOrdinal(a, b) {
-  if (a < b) return -1;
-  return a > b ? 1 : 0;
-}
-function sortKeys(v) {
-  if (Array.isArray(v)) return v.map(sortKeys);
-  if (v && typeof v === "object") {
-    const src = v;
-    const out = {};
-    for (const k of Object.keys(src).sort()) {
-      if (k === "createdAt" || k === "updatedAt") continue;
-      out[k] = sortKeys(src[k]);
-    }
-    return out;
-  }
-  return v;
-}
-var init_canonical_json = __esm({
-  "src/utils/canonical-json.ts"() {
-    "use strict";
-  }
-});
-
-// src/core/statehash.ts
-function inIdentityOrder(specs) {
-  return specs.map((spec) => ({ spec, content: canonicalize(spec) })).sort((a, b) => compareOrdinal(a.spec.id, b.spec.id) || compareOrdinal(a.content, b.content)).map((entry) => entry.spec);
-}
-function computeStateId() {
-  const tree = {
-    system: loadSystemSpec(),
-    subsystems: inIdentityOrder(loadSubsystemSpecs()),
-    components: inIdentityOrder(loadComponentSpecs()),
-    interfaces: inIdentityOrder(loadInterfaceSpecs()),
-    implementations: inIdentityOrder(loadImplementationSpecs()),
-    types: inIdentityOrder(loadTypeSpecs())
-  };
-  const digest2 = crypto.createHash("sha256").update(canonicalize(tree)).digest("hex");
-  return { algorithm: CONTENT_ALGORITHM, digest: digest2 };
-}
-function stateIdEquals(a, b) {
-  return !!a && !!b && a.algorithm === b.algorithm && a.digest === b.digest;
-}
-var crypto, CONTENT_ALGORITHM;
-var init_statehash = __esm({
-  "src/core/statehash.ts"() {
-    "use strict";
-    crypto = __toESM(require("crypto"));
-    init_specs2();
-    init_canonical_json();
-    CONTENT_ALGORITHM = "sha256";
-  }
-});
-
-// src/core/lockfile.ts
-function lockPath() {
-  return aiDir("lock.json");
-}
-function normalizeApprover(value) {
-  if (value && typeof value === "object" && typeof value.id === "string") {
-    const v = value;
-    const source = v.source === "git" || v.source === "hosted" || v.source === "os" ? v.source : "legacy";
-    return { id: v.id, ...v.name ? { name: v.name } : {}, source };
-  }
-  return { id: typeof value === "string" && value ? value : "unknown", source: "legacy" };
-}
-function describeApprover(who) {
-  const label = who.name ? `${who.name} (${who.id})` : who.id;
-  return who.source === "hosted" ? `${label} [authenticated]` : label;
-}
-function readLockRecord() {
-  try {
-    return normalizeRecord(JSON.parse(fs8.readFileSync(lockPath(), "utf8")));
-  } catch {
-    return null;
-  }
-}
-function readLockRecordAt(root) {
-  try {
-    return normalizeRecord(JSON.parse(fs8.readFileSync(aiDirAt(root, "lock.json"), "utf8")));
-  } catch {
-    return null;
-  }
-}
-function normalizeRecord(raw) {
-  const record2 = raw;
-  return { ...record2, lockedBy: normalizeApprover(record2.lockedBy) };
-}
-function writeLockRecord(record2) {
-  const p = lockPath();
-  fs8.mkdirSync(path10.dirname(p), { recursive: true });
-  const tmp = `${p}.tmp`;
-  fs8.writeFileSync(tmp, JSON.stringify(withSortedMaps(record2), null, 2) + "\n");
-  fs8.renameSync(tmp, p);
-}
-function withSortedMaps(record2) {
-  const sorted = (m) => {
-    if (!m) return void 0;
-    const out = {};
-    for (const k of Object.keys(m).sort()) out[k] = m[k];
-    return out;
-  };
-  const specs = sorted(record2.specs);
-  const children = sorted(record2.children);
-  return {
-    ...record2,
-    ...specs ? { specs } : {},
-    ...children ? { children } : {}
-  };
-}
-var fs8, path10;
-var init_lockfile = __esm({
-  "src/core/lockfile.ts"() {
-    "use strict";
-    fs8 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
-    init_fs();
-  }
-});
-
-// src/core/spec-files.ts
-function readSpecFile(filePath) {
-  return readYamlFile(filePath);
-}
-function writeSpecFile(filePath, document) {
-  writeYamlFile(filePath, document);
-}
-function listSpecFiles(specsDir) {
-  return listFilesRecursive(specsDir, SPEC_FILE_EXTENSION);
-}
-function removeSpecFile(filePath, specsRoot) {
-  if (!fs9.existsSync(filePath)) return false;
-  fs9.unlinkSync(filePath);
-  pruneEmptyDirs(path11.dirname(filePath), path11.resolve(specsRoot));
-  return true;
-}
-function pruneEmptyDirs(dir, specsRoot) {
-  let at = dir;
-  while (at !== specsRoot && at.startsWith(specsRoot)) {
-    if (!fs9.existsSync(at) || fs9.readdirSync(at).length > 0) return;
-    fs9.rmdirSync(at);
-    at = path11.dirname(at);
-  }
-}
-var fs9, path11, SPEC_FILE_EXTENSION;
-var init_spec_files = __esm({
-  "src/core/spec-files.ts"() {
-    "use strict";
-    fs9 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
-    init_fs();
-    init_yaml();
-    SPEC_FILE_EXTENSION = ".yaml";
-  }
-});
-
 // src/core/narrative-labels.ts
 function resolveNarrativeLabels(methodName, steps) {
   const errors = [];
@@ -4274,14 +4099,14 @@ function embedJson(value) {
 }
 function loadCytoscapeLib() {
   const candidates = [
-    path12.resolve(__dirname, "..", "templates", "canvas", "cytoscape.min.js"),
+    path11.resolve(__dirname, "..", "templates", "canvas", "cytoscape.min.js"),
     // src/core & dist/cli
-    path12.resolve(__dirname, "templates", "canvas", "cytoscape.min.js")
+    path11.resolve(__dirname, "templates", "canvas", "cytoscape.min.js")
     // dist (library entry)
   ];
   for (const p of candidates) {
-    if (fs10.existsSync(p)) {
-      return fs10.readFileSync(p, "utf-8").replace(/<\/script/gi, "<\\/script");
+    if (fs9.existsSync(p)) {
+      return fs9.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.");
@@ -4293,12 +4118,12 @@ function renderCanvasHtml(model) {
 function escapeHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-var fs10, path12, CANVAS_TEMPLATE;
+var fs9, path11, CANVAS_TEMPLATE;
 var init_canvas = __esm({
   "src/core/canvas.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path12 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
     init_specs2();
     init_models();
     init_diagram_export();
@@ -8493,7 +8318,7 @@ function packStoreDir() {
 function packFiles(dir, prefix = "") {
   let entries;
   try {
-    entries = fs11.readdirSync(dir, { withFileTypes: true });
+    entries = fs10.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -8501,25 +8326,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(path13.join(dir, e.name), rel2));
+    if (e.isDirectory()) out.push(...packFiles(path12.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 = path13.resolve(packDir);
+  const abs = path12.resolve(packDir);
   let isFile = false;
   try {
-    isFile = fs11.statSync(abs).isFile();
+    isFile = fs10.statSync(abs).isFile();
   } catch {
   }
-  const entries = isFile ? [[path13.basename(abs), abs]] : packFiles(abs).map((rel2) => [rel2, path13.join(abs, rel2)]);
+  const entries = isFile ? [[path12.basename(abs), abs]] : packFiles(abs).map((rel2) => [rel2, path12.join(abs, rel2)]);
   for (const [rel2, full] of entries) {
     hash.update(rel2);
     hash.update("\0");
     try {
-      hash.update(fs11.readFileSync(full));
+      hash.update(fs10.readFileSync(full));
     } catch {
     }
     hash.update("\0");
@@ -8528,7 +8353,7 @@ function computePackDigest(packDir) {
 }
 function readInstallRecord(packPath) {
   try {
-    const raw = readYamlFile(path13.join(packPath, INSTALL_RECORD));
+    const raw = readYamlFile(path12.join(packPath, INSTALL_RECORD));
     return raw && typeof raw === "object" ? raw : {};
   } catch {
     return {};
@@ -8558,14 +8383,14 @@ function installedFrom(location, name, version) {
 function versionedEntries(nameDir, fallbackName) {
   let versions;
   try {
-    versions = fs11.readdirSync(nameDir, { withFileTypes: true });
+    versions = fs10.readdirSync(nameDir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const v of versions) {
     if (!v.isDirectory()) continue;
-    const versionDir = path13.join(nameDir, v.name);
+    const versionDir = path12.join(nameDir, v.name);
     const entryFile = packDirEntry(versionDir);
     if (!entryFile) continue;
     out.push(installedFrom(versionDir, declaredName(entryFile) ?? fallbackName, v.name));
@@ -8573,7 +8398,7 @@ function versionedEntries(nameDir, fallbackName) {
   return out;
 }
 function storeEntryPacks(store, entry) {
-  const full = path13.join(store, entry.name);
+  const full = path12.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, "");
@@ -8588,7 +8413,7 @@ function listInstalledPacks() {
   const store = packStoreDir();
   let entries;
   try {
-    entries = fs11.readdirSync(store, { withFileTypes: true });
+    entries = fs10.readdirSync(store, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -8605,17 +8430,17 @@ function resolveInstalledPack(name, version) {
   return candidates[0];
 }
 function installPackFromDirectory(sourceDir, origin) {
-  const abs = path13.resolve(sourceDir);
+  const abs = path12.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, path13.dirname(entryFile));
+  const manifest = readManifest(entryFile, path12.dirname(entryFile));
   const version = manifest.version && manifest.version.length > 0 ? manifest.version : UNVERSIONED;
-  const dest = path13.join(packStoreDir(), manifest.name, version);
-  fs11.rmSync(dest, { recursive: true, force: true });
-  fs11.mkdirSync(path13.dirname(dest), { recursive: true });
-  fs11.cpSync(abs, dest, { recursive: true });
+  const dest = path12.join(packStoreDir(), manifest.name, version);
+  fs10.rmSync(dest, { recursive: true, force: true });
+  fs10.mkdirSync(path12.dirname(dest), { recursive: true });
+  fs10.cpSync(abs, dest, { recursive: true });
   const digest2 = computePackDigest(dest);
   const record2 = {
     origin,
@@ -8623,7 +8448,7 @@ function installPackFromDirectory(sourceDir, origin) {
     waironVersion: WAIRON_VERSION,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeYamlFile(path13.join(dest, INSTALL_RECORD), record2);
+  writeYamlFile(path12.join(dest, INSTALL_RECORD), record2);
   return {
     name: manifest.name,
     version,
@@ -8638,23 +8463,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) {
-    fs11.rmSync(target.path, { recursive: true, force: true });
-    const parent = path13.dirname(target.path);
-    if (path13.resolve(parent) === path13.resolve(packStoreDir())) continue;
+    fs10.rmSync(target.path, { recursive: true, force: true });
+    const parent = path12.dirname(target.path);
+    if (path12.resolve(parent) === path12.resolve(packStoreDir())) continue;
     try {
-      if (fs11.readdirSync(parent).length === 0) fs11.rmdirSync(parent);
+      if (fs10.readdirSync(parent).length === 0) fs10.rmdirSync(parent);
     } catch {
     }
   }
   return true;
 }
-var crypto2, fs11, path13, UNVERSIONED, INSTALL_RECORD, DIGEST_EXCLUDED, PACK_FILE_RE;
+var crypto2, fs10, path12, UNVERSIONED, INSTALL_RECORD, DIGEST_EXCLUDED, PACK_FILE_RE;
 var init_packstore = __esm({
   "src/core/packstore.ts"() {
     "use strict";
     crypto2 = __toESM(require("crypto"));
-    fs11 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    fs10 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
     init_yaml();
     init_defaults();
     init_version();
@@ -8681,26 +8506,26 @@ function emptyExtensions() {
   return { packNames: [], packs: [], rules: [], profiles: {}, languages: {}, skills: [], patterns: [], guarantees: [], assertions: [], instructions: [], errors: [], selectionFailures: [] };
 }
 function globalPacksDir() {
-  return process.env.WAIRON_PACKS_DIR ?? path14.join(os4.homedir(), ".wairon", "packs");
+  return process.env.WAIRON_PACKS_DIR ?? path13.join(os4.homedir(), ".wairon", "packs");
 }
 function packDirEntry(dir) {
   for (const name of PACK_DIR_ENTRIES) {
-    const p = path14.join(dir, name);
-    if (fs12.existsSync(p)) return p;
+    const p = path13.join(dir, name);
+    if (fs11.existsSync(p)) return p;
   }
   return null;
 }
 function latestVersionDir(nameDir) {
   let versions;
   try {
-    versions = fs12.readdirSync(nameDir, { withFileTypes: true });
+    versions = fs11.readdirSync(nameDir, { withFileTypes: true });
   } catch {
     return null;
   }
   let best = null;
   for (const v of versions) {
     if (!v.isDirectory()) continue;
-    const dir = path14.join(nameDir, v.name);
+    const dir = path13.join(nameDir, v.name);
     if (!packDirEntry(dir)) continue;
     if (!best || isNewerVersion(best.version, v.name)) best = { version: v.name, dir };
   }
@@ -8709,13 +8534,13 @@ function latestVersionDir(nameDir) {
 function discoverPacks(dir) {
   let entries;
   try {
-    entries = fs12.readdirSync(dir, { withFileTypes: true });
+    entries = fs11.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const refs = [];
   for (const e of entries.sort((a, b) => compareOrdinal(a.name, b.name))) {
-    const full = path14.join(dir, e.name);
+    const full = path13.join(dir, e.name);
     if (e.isDirectory()) {
       if (packDirEntry(full)) refs.push(full);
       else {
@@ -8745,17 +8570,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: path14.resolve(packDir, s.source) });
+  for (const s of pack.skills) out.skills.push({ ...s, pack: pack.name, packVersion: pack.version, sourcePath: path13.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, projectRoot2) {
-  const pathLike = ref.startsWith(".") || path14.isAbsolute(ref) || isYamlPath(ref);
+  const pathLike = ref.startsWith(".") || path13.isAbsolute(ref) || isYamlPath(ref);
   if (!pathLike) return ref;
-  const resolved = path14.resolve(projectRoot2, ref);
-  if (fs12.existsSync(resolved) && fs12.statSync(resolved).isDirectory()) {
+  const resolved = path13.resolve(projectRoot2, ref);
+  if (fs11.existsSync(resolved) && fs11.statSync(resolved).isDirectory()) {
     const entry = packDirEntry(resolved);
     if (!entry) throw new Error(`directory pack has no entry file (${PACK_DIR_ENTRIES.join(" | ")})`);
     return entry;
@@ -8768,7 +8593,7 @@ function readManifest(target, projectRoot2) {
     if (raw == null) throw new Error("file not found or empty");
     return { ...DeclarativePackSchema.parse(raw), rules: [] };
   }
-  const req = (0, import_module.createRequire)(path14.join(projectRoot2, "package.json"));
+  const req = (0, import_module.createRequire)(path13.join(projectRoot2, "package.json"));
   const modRaw = req(target);
   const mod = modRaw?.default ?? modRaw;
   const parsed = DeclarativePackSchema.parse({
@@ -8796,7 +8621,7 @@ function loadExtensionPacks(refs, projectRoot2) {
     try {
       const target = resolvePackRef(ref, projectRoot2);
       const manifest = readManifest(target, projectRoot2);
-      mergePack(out, manifest, ref, scope, path14.dirname(target));
+      mergePack(out, manifest, ref, scope, path13.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)}`);
@@ -8839,7 +8664,7 @@ function defaultPackSelections() {
       const entry = packDirEntry(pack.path) ?? pack.path;
       let manifest;
       try {
-        manifest = readManifest(entry, path14.dirname(entry));
+        manifest = readManifest(entry, path13.dirname(entry));
       } catch {
         continue;
       }
@@ -8878,7 +8703,7 @@ function diagnoseProjectPacks() {
     const globalsApplied = [];
     if (globalsOn) {
       for (const ref of discoverPacks(globalPacksDir())) {
-        const match = installed.find((p) => path14.resolve(p.path) === path14.resolve(ref));
+        const match = installed.find((p) => path13.resolve(p.path) === path13.resolve(ref));
         if (match) globalsApplied.push({ name: match.name, version: match.version });
       }
     }
@@ -8956,7 +8781,7 @@ function verifyIntegrity(selection, packDir, where) {
   };
 }
 function detectBundleStoreDrift(selection, bundleDir) {
-  const bundledVersion = path14.basename(bundleDir);
+  const bundledVersion = path13.basename(bundleDir);
   const installed = resolveInstalledPack(selection.name, bundledVersion);
   if (!installed) return void 0;
   const bundleDigest = computePackDigest(bundleDir);
@@ -8970,34 +8795,34 @@ function detectBundleStoreDrift(selection, bundleDir) {
   };
 }
 function findBundledPack(projectRoot2, selection) {
-  const base = path14.join(projectRoot2, ".wai", "packs", selection.name);
+  const base = path13.join(projectRoot2, ".wai", "packs", selection.name);
   if (selection.version) {
-    const pinned = path14.join(base, selection.version);
+    const pinned = path13.join(base, selection.version);
     return packDirEntry(pinned) ? pinned : null;
   }
   if (packDirEntry(base)) return base;
   let versions;
   try {
-    versions = fs12.readdirSync(base, { withFileTypes: true });
+    versions = fs11.readdirSync(base, { withFileTypes: true });
   } catch {
     return null;
   }
   let best = null;
   for (const v of versions) {
     if (!v.isDirectory()) continue;
-    const dir = path14.join(base, v.name);
+    const dir = path13.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 fs12, os4, path14, 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 fs11, os4, path13, 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";
-    fs12 = __toESM(require("fs"));
+    fs11 = __toESM(require("fs"));
     os4 = __toESM(require("os"));
-    path14 = __toESM(require("path"));
+    path13 = __toESM(require("path"));
     import_module = require("module");
     import_zod9 = require("zod");
     init_yaml();
@@ -14446,12 +14271,109 @@ var init_carried_debt = __esm({
   }
 });
 
+// src/core/rules/heuristic/method-cohesion.ts
+function groupsSharingCollaborators(calledBy) {
+  const parent = /* @__PURE__ */ new Map();
+  const find = (m) => {
+    let root = m;
+    while (parent.get(root) !== root) root = parent.get(root);
+    return root;
+  };
+  const union = (a, b) => {
+    const [ra, rb] = [find(a), find(b)];
+    if (ra !== rb) parent.set(ra, rb);
+  };
+  const methods = [...calledBy.keys()];
+  for (const m of methods) parent.set(m, m);
+  for (let i = 0; i < methods.length; i++) {
+    for (let j = i + 1; j < methods.length; j++) {
+      const shares = [...calledBy.get(methods[i])].some((c) => calledBy.get(methods[j])?.has(c));
+      if (shares) union(methods[i], methods[j]);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const m of methods) {
+    const root = find(m);
+    groups.set(root, [...groups.get(root) ?? [], m]);
+  }
+  return [...groups.values()];
+}
+function isForwardingMethod(narrative) {
+  let handoffs = 0;
+  for (const step of narrative) {
+    if (step.type === "call" || step.type === "dispatch") handoffs++;
+    else if (step.type !== "return") return false;
+  }
+  return handoffs === 1;
+}
+function isPureForwarder(methods) {
+  const narrated = methods.filter((m) => (m.narrative ?? []).length > 0);
+  return narrated.length > 0 && narrated.every((m) => isForwardingMethod(m.narrative ?? []));
+}
+function pureForwarderComponents(ctx) {
+  const realized = /* @__PURE__ */ new Map();
+  for (const impl of ctx.implementations) {
+    const intf = ctx.interfaceMap.get(impl.contract);
+    if (!intf) continue;
+    realized.set(intf.component, [...realized.get(intf.component) ?? [], ...impl.methods]);
+  }
+  return new Set([...realized].filter(([, methods]) => isPureForwarder(methods)).map(([id]) => id));
+}
+var methodCohesionRule;
+var init_method_cohesion = __esm({
+  "src/core/rules/heuristic/method-cohesion.ts"() {
+    "use strict";
+    methodCohesionRule = {
+      name: "method-cohesion",
+      description: "An Orchestrator's methods share collaborators; when they split into groups that call no component in common, the component holds more than one responsibility. Reported only where two or more groups each hold two or more methods, so a single specialized method is not a finding \u2014 and never on a pure forwarder, whose every narrated method is a single hand-off and whose responsibility therefore lives in what it forwards to.",
+      codes: [
+        { code: "INCOHESIVE_METHODS", defaultSeverity: "warning", summary: "Orchestrator's methods form two or more groups of two or more that share no called component" }
+      ],
+      check(ctx) {
+        const subjects = [];
+        for (const impl of ctx.implementations) {
+          const intf = ctx.interfaceMap.get(impl.contract);
+          const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
+          if (!comp || comp.componentType !== "Orchestrator") continue;
+          if (isPureForwarder(impl.methods)) continue;
+          const calledBy = /* @__PURE__ */ new Map();
+          for (const method2 of impl.methods) {
+            const reached = /* @__PURE__ */ new Set();
+            for (const step of method2.narrative ?? []) {
+              if ((step.type === "call" || step.type === "dispatch") && step.targetComponent) reached.add(step.targetComponent);
+            }
+            if (reached.size > 0) calledBy.set(method2.name, reached);
+          }
+          subjects.push({ implementation: impl, component: comp, calledBy });
+        }
+        for (const { component, calledBy } of subjects) {
+          if (calledBy.size < 2) continue;
+          const groups = groupsSharingCollaborators(calledBy).filter((g) => g.length >= 2);
+          if (groups.length < 2) continue;
+          const described = groups.map((g) => {
+            const collaborators = [...new Set(g.flatMap((m) => [...calledBy.get(m)]))].sort();
+            return `${g.join(", ")} (calling ${collaborators.join(", ")})`;
+          }).join("; ");
+          ctx.addIssue(
+            "warning",
+            "INCOHESIVE_METHODS",
+            `Orchestrator "${component.id}" holds ${groups.length} groups of methods that share no called component: ${described}. Split it along those groups, move the logic out until every method is a single hand-off (a pure forwarder is exempt), or acknowledge a deliberate facade with a reasoned lint.allow for INCOHESIVE_METHODS.`,
+            component.id,
+            ctx.isComponentDraft(component.id)
+          );
+        }
+      }
+    };
+  }
+});
+
 // src/core/rules/heuristic/coupling-health.ts
 var DEFAULT_GOD_COMPONENT_THRESHOLD, couplingRule;
 var init_coupling_health = __esm({
   "src/core/rules/heuristic/coupling-health.ts"() {
     "use strict";
     init_models();
+    init_method_cohesion();
     DEFAULT_GOD_COMPONENT_THRESHOLD = 8;
     couplingRule = {
       name: "coupling-health",
@@ -14460,7 +14382,7 @@ var init_coupling_health = __esm({
         { code: "MUTUAL_SUBSYSTEM_DEPENDENCY", defaultSeverity: "warning", summary: "Subsystems depend on each other without a declared trusted link" },
         { code: "INVALID_TRUSTED_LINK", defaultSeverity: "error", summary: "trustedLinks references a non-existent subsystem" },
         { code: "UNUSED_TRUSTED_LINK", defaultSeverity: "warning", summary: "trustedLinks declares a peer no dependency actually reaches" },
-        { code: "GOD_COMPONENT", defaultSeverity: "warning", summary: "Component with excessive dependency fan-out" }
+        { code: "GOD_COMPONENT", defaultSeverity: "warning", summary: "Component with excessive dependency fan-out; not reported on a pure forwarder, whose every narrated method is a single hand-off" }
       ],
       check(ctx) {
         const subsystemDeps = /* @__PURE__ */ new Map();
@@ -14532,9 +14454,10 @@ var init_coupling_health = __esm({
             );
           }
         }
+        const forwarders = pureForwarderComponents(ctx);
         for (const comp of ctx.components) {
           const threshold = ctx.complexityConfigFor(comp.subsystem)?.maxComponentDependencies ?? DEFAULT_GOD_COMPONENT_THRESHOLD;
-          if (comp.dependsOn.length > threshold) {
+          if (comp.dependsOn.length > threshold && !forwarders.has(comp.id)) {
             ctx.addIssue(
               "warning",
               "GOD_COMPONENT",
@@ -15158,6 +15081,7 @@ var init_complexity_and_metadata = __esm({
   "src/core/rules/heuristic/complexity-and-metadata.ts"() {
     "use strict";
     init_models();
+    init_method_cohesion();
     complexityRule = {
       name: "complexity-and-metadata",
       description: "Enforces metadata documentation completeness (checking if descriptions are missing or too short) and structural complexity caps (limits on methods per interface, parameters per method, dependencies per component, and components per subsystem) configured globally or in architectural profiles. A narrative's own length and shape are judged by narrative-complexity.",
@@ -15166,7 +15090,7 @@ var init_complexity_and_metadata = __esm({
         { code: "DESCRIPTION_TOO_SHORT", defaultSeverity: "warning", summary: "Description is shorter than the configured minimum length" },
         { code: "EXCESSIVE_METHODS", defaultSeverity: "warning", summary: "Interface declares more methods than the configured limit" },
         { code: "EXCESSIVE_METHOD_PARAMS", defaultSeverity: "warning", summary: "Interface method declares more parameters than the configured limit" },
-        { code: "EXCESSIVE_DEPENDENCIES", defaultSeverity: "warning", summary: "Component has more dependencies than the configured limit" },
+        { code: "EXCESSIVE_DEPENDENCIES", defaultSeverity: "warning", summary: "Component has more dependencies than the configured limit; not reported on a pure forwarder, whose fan-out is a routing table rather than knowledge" },
         { code: "EXCESSIVE_SUBSYSTEM_COMPONENTS", defaultSeverity: "warning", summary: "Subsystem has more direct components than the configured limit" }
       ],
       check(ctx) {
@@ -15186,6 +15110,7 @@ var init_complexity_and_metadata = __esm({
             );
           }
         }
+        const forwarders = pureForwarderComponents(ctx);
         for (const comp of ctx.components) {
           const docConfig = ctx.documentationConfigFor(comp.subsystem);
           const complexityConfig = ctx.complexityConfigFor(comp.subsystem);
@@ -15199,7 +15124,7 @@ var init_complexity_and_metadata = __esm({
             "Component",
             isDraft
           );
-          if (complexityConfig?.maxComponentDependencies !== void 0 && comp.dependsOn.length > complexityConfig.maxComponentDependencies) {
+          if (complexityConfig?.maxComponentDependencies !== void 0 && comp.dependsOn.length > complexityConfig.maxComponentDependencies && !forwarders.has(comp.id)) {
             ctx.addIssue(
               "warning",
               "EXCESSIVE_DEPENDENCIES",
@@ -15498,90 +15423,6 @@ var init_naming_discipline = __esm({
   }
 });
 
-// src/core/rules/heuristic/method-cohesion.ts
-function groupsSharingCollaborators(calledBy) {
-  const parent = /* @__PURE__ */ new Map();
-  const find = (m) => {
-    let root = m;
-    while (parent.get(root) !== root) root = parent.get(root);
-    return root;
-  };
-  const union = (a, b) => {
-    const [ra, rb] = [find(a), find(b)];
-    if (ra !== rb) parent.set(ra, rb);
-  };
-  const methods = [...calledBy.keys()];
-  for (const m of methods) parent.set(m, m);
-  for (let i = 0; i < methods.length; i++) {
-    for (let j = i + 1; j < methods.length; j++) {
-      const shares = [...calledBy.get(methods[i])].some((c) => calledBy.get(methods[j])?.has(c));
-      if (shares) union(methods[i], methods[j]);
-    }
-  }
-  const groups = /* @__PURE__ */ new Map();
-  for (const m of methods) {
-    const root = find(m);
-    groups.set(root, [...groups.get(root) ?? [], m]);
-  }
-  return [...groups.values()];
-}
-function isForwardingMethod(narrative) {
-  let handoffs = 0;
-  for (const step of narrative) {
-    if (step.type === "call" || step.type === "dispatch") handoffs++;
-    else if (step.type !== "return") return false;
-  }
-  return handoffs === 1;
-}
-var methodCohesionRule;
-var init_method_cohesion = __esm({
-  "src/core/rules/heuristic/method-cohesion.ts"() {
-    "use strict";
-    methodCohesionRule = {
-      name: "method-cohesion",
-      description: "An Orchestrator's methods share collaborators; when they split into groups that call no component in common, the component holds more than one responsibility. Reported only where two or more groups each hold two or more methods, so a single specialized method is not a finding \u2014 and never on a pure forwarder, whose every narrated method is a single hand-off and whose responsibility therefore lives in what it forwards to.",
-      codes: [
-        { code: "INCOHESIVE_METHODS", defaultSeverity: "warning", summary: "Orchestrator's methods form two or more groups of two or more that share no called component" }
-      ],
-      check(ctx) {
-        const subjects = [];
-        for (const impl of ctx.implementations) {
-          const intf = ctx.interfaceMap.get(impl.contract);
-          const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
-          if (!comp || comp.componentType !== "Orchestrator") continue;
-          const narrated = impl.methods.filter((m) => (m.narrative ?? []).length > 0);
-          if (narrated.length > 0 && narrated.every((m) => isForwardingMethod(m.narrative ?? []))) continue;
-          const calledBy = /* @__PURE__ */ new Map();
-          for (const method2 of impl.methods) {
-            const reached = /* @__PURE__ */ new Set();
-            for (const step of method2.narrative ?? []) {
-              if ((step.type === "call" || step.type === "dispatch") && step.targetComponent) reached.add(step.targetComponent);
-            }
-            if (reached.size > 0) calledBy.set(method2.name, reached);
-          }
-          subjects.push({ implementation: impl, component: comp, calledBy });
-        }
-        for (const { component, calledBy } of subjects) {
-          if (calledBy.size < 2) continue;
-          const groups = groupsSharingCollaborators(calledBy).filter((g) => g.length >= 2);
-          if (groups.length < 2) continue;
-          const described = groups.map((g) => {
-            const collaborators = [...new Set(g.flatMap((m) => [...calledBy.get(m)]))].sort();
-            return `${g.join(", ")} (calling ${collaborators.join(", ")})`;
-          }).join("; ");
-          ctx.addIssue(
-            "warning",
-            "INCOHESIVE_METHODS",
-            `Orchestrator "${component.id}" holds ${groups.length} groups of methods that share no called component: ${described}. Split it along those groups, move the logic out until every method is a single hand-off (a pure forwarder is exempt), or acknowledge a deliberate facade with a reasoned lint.allow for INCOHESIVE_METHODS.`,
-            component.id,
-            ctx.isComponentDraft(component.id)
-          );
-        }
-      }
-    };
-  }
-});
-
 // src/core/rules/repository.ts
 function addRule(rule) {
   ruleSet.push(rule);
@@ -15993,7 +15834,7 @@ function resolveTypeScript(projectRoot2) {
     return cached.ts;
   }
   let ts = null;
-  const bases = [path15.join(projectRoot2, "package.json"), __filename];
+  const bases = [path14.join(projectRoot2, "package.json"), __filename];
   for (const base of bases) {
     try {
       const req = (0, import_module2.createRequire)(base);
@@ -16208,7 +16049,7 @@ function walkExact(ts, sourceText, fileName) {
 }
 function resolveRelativeModule(fromFile, specifier) {
   if (!specifier.startsWith(".")) return null;
-  const base = path15.resolve(path15.dirname(fromFile), specifier);
+  const base = path14.resolve(path14.dirname(fromFile), specifier);
   const candidates = [
     base,
     base.replace(/\.js$/, ".ts"),
@@ -16216,12 +16057,12 @@ function resolveRelativeModule(fromFile, specifier) {
     `${base}.ts`,
     `${base}.tsx`,
     `${base}.js`,
-    path15.join(base, "index.ts"),
-    path15.join(base, "index.js")
+    path14.join(base, "index.ts"),
+    path14.join(base, "index.js")
   ];
   for (const c of candidates) {
     try {
-      if (fs13.statSync(c).isFile()) return c;
+      if (fs12.statSync(c).isFile()) return c;
     } catch {
     }
   }
@@ -16229,11 +16070,11 @@ function resolveRelativeModule(fromFile, specifier) {
 }
 function reexportTarget(ts, filePath, specifier, projectRoot2, visited, exactCache) {
   const target = resolveRelativeModule(filePath, specifier);
-  if (!target || path15.relative(projectRoot2, target).startsWith("..")) return null;
+  if (!target || path14.relative(projectRoot2, target).startsWith("..")) return null;
   let targetFacts = exactCache.get(target);
   if (targetFacts === void 0) {
     try {
-      targetFacts = walkExact(ts, fs13.readFileSync(target, "utf8"), target);
+      targetFacts = walkExact(ts, fs12.readFileSync(target, "utf8"), target);
     } catch {
       targetFacts = null;
     }
@@ -16251,7 +16092,7 @@ function carryBody(facts, target, targetPath, local, exported, projectRoot2) {
   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(path15.relative(projectRoot2, targetPath));
+  const carriedFrom = pathKey(path14.relative(projectRoot2, 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);
@@ -16281,24 +16122,24 @@ function walkDeclaredRoots(roots, exclude, projectRoot2) {
   const excluded = exclude.map(pathKey);
   const isExcluded = (key) => excluded.some((e) => key === e || key.startsWith(`${e}/`));
   const record2 = (absolute) => {
-    const key = pathKey(path15.relative(projectRoot2, absolute));
+    const key = pathKey(path14.relative(projectRoot2, absolute));
     if (seen.has(key) || isExcluded(key)) return;
-    if (!EXTENSION_LANGUAGE[path15.extname(key).toLowerCase()]) return;
+    if (!EXTENSION_LANGUAGE[path14.extname(key).toLowerCase()]) return;
     seen.add(key);
     found.push(key);
   };
   const descend = (dir) => {
     let entries;
     try {
-      entries = fs13.readdirSync(dir, { withFileTypes: true });
+      entries = fs12.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 = path15.join(dir, entry.name);
+      const child = path14.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        if (isExcluded(pathKey(path15.relative(projectRoot2, child)))) continue;
+        if (isExcluded(pathKey(path14.relative(projectRoot2, child)))) continue;
         descend(child);
       } else if (entry.isFile()) {
         record2(child);
@@ -16307,13 +16148,13 @@ function walkDeclaredRoots(roots, exclude, projectRoot2) {
   };
   for (const root of roots) {
     const key = pathKey(root);
-    if (path15.isAbsolute(key) || path15.normalize(key).split(path15.sep)[0] === "..") continue;
-    const absolute = path15.resolve(projectRoot2, key);
-    if (path15.relative(projectRoot2, absolute).startsWith("..")) continue;
+    if (path14.isAbsolute(key) || path14.normalize(key).split(path14.sep)[0] === "..") continue;
+    const absolute = path14.resolve(projectRoot2, key);
+    if (path14.relative(projectRoot2, absolute).startsWith("..")) continue;
     if (isExcluded(key)) continue;
     let stat;
     try {
-      stat = fs13.statSync(absolute);
+      stat = fs12.statSync(absolute);
     } catch {
       continue;
     }
@@ -16339,23 +16180,23 @@ function buildCodeModel(implementations, types, projectRoot2, sourceRoots = [],
     if (seen.has(sourcePath)) continue;
     seen.add(sourcePath);
     const empty = { declaredNames: [], anchoredNames: [], exportedNames: [], imports: [], reexports: [] };
-    if (path15.isAbsolute(sourcePath) || path15.normalize(sourcePath).split(path15.sep)[0] === "..") {
+    if (path14.isAbsolute(sourcePath) || path14.normalize(sourcePath).split(path14.sep)[0] === "..") {
       files.push({ path: sourcePath, status: "escaped", ...empty });
       continue;
     }
-    const absolute = path15.resolve(projectRoot2, sourcePath);
-    if (path15.relative(projectRoot2, absolute).startsWith("..")) {
+    const absolute = path14.resolve(projectRoot2, sourcePath);
+    if (path14.relative(projectRoot2, absolute).startsWith("..")) {
       files.push({ path: sourcePath, status: "escaped", ...empty });
       continue;
     }
     let buffer;
     try {
-      const stat = fs13.statSync(absolute);
+      const stat = fs12.statSync(absolute);
       if (!stat.isFile()) {
         files.push({ path: sourcePath, status: "missing", ...empty });
         continue;
       }
-      buffer = fs13.readFileSync(absolute);
+      buffer = fs12.readFileSync(absolute);
     } catch {
       files.push({ path: sourcePath, status: "missing", ...empty });
       continue;
@@ -16365,7 +16206,7 @@ function buildCodeModel(implementations, types, projectRoot2, sourceRoots = [],
       continue;
     }
     const text2 = buffer.toString("utf8");
-    const language = EXTENSION_LANGUAGE[path15.extname(sourcePath).toLowerCase()];
+    const language = EXTENSION_LANGUAGE[path14.extname(sourcePath).toLowerCase()];
     let analyzed;
     if (language === "typescript" || language === "javascript") {
       const ts = resolveTypeScript(projectRoot2);
@@ -16409,7 +16250,7 @@ function readTestFiles(testRoots, projectRoot2) {
   for (const key of walkDeclaredRoots(testRoots, [], projectRoot2)) {
     let text2;
     try {
-      const buffer = fs13.readFileSync(path15.resolve(projectRoot2, key));
+      const buffer = fs12.readFileSync(path14.resolve(projectRoot2, key));
       if (looksBinary(buffer)) continue;
       text2 = buffer.toString("utf8");
     } catch {
@@ -16446,12 +16287,12 @@ function findTestsReferencing(methods, projectRoot2, testRoots = []) {
   }
   return found;
 }
-var fs13, path15, 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 fs12, path14, 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";
-    fs13 = __toESM(require("fs"));
-    path15 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
     import_module2 = require("module");
     init_models();
     EXTENSION_LANGUAGE = {
@@ -17221,28 +17062,28 @@ var init_gate_identity = __esm({
 
 // src/core/variants.ts
 function globalVariantsDir() {
-  return process.env.WAIRON_VARIANTS_DIR ?? path16.join(os5.homedir(), ".wairon", "variants");
+  return process.env.WAIRON_VARIANTS_DIR ?? path15.join(os5.homedir(), ".wairon", "variants");
 }
 function builtinVariantsDir() {
   const candidates = [
-    path16.resolve(__dirname, "..", "templates", "variants"),
+    path15.resolve(__dirname, "..", "templates", "variants"),
     // src/core & dist/cli
-    path16.resolve(__dirname, "templates", "variants")
+    path15.resolve(__dirname, "templates", "variants")
     // dist (library entry)
   ];
-  return candidates.find((dir) => fs14.existsSync(dir)) ?? candidates[0];
+  return candidates.find((dir) => fs13.existsSync(dir)) ?? candidates[0];
 }
 function projectVariantsDir() {
-  return path16.join(getProjectRoot(), ".wai", "variants");
+  return path15.join(getProjectRoot(), ".wai", "variants");
 }
 function variantFiles(dir) {
   let entries;
   try {
-    entries = fs14.readdirSync(dir, { withFileTypes: true });
+    entries = fs13.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) => path16.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) => path15.join(dir, e.name));
 }
 function parseVariants(raw) {
   if (raw == null) return [];
@@ -17351,13 +17192,13 @@ function rebasedText(content, fromBase, toBase, rebasedContent) {
   }
   return serializeYaml(rebasedContent);
 }
-var fs14, os5, path16, import_zod10, VariantDefSchema;
+var fs13, os5, path15, import_zod10, VariantDefSchema;
 var init_variants = __esm({
   "src/core/variants.ts"() {
     "use strict";
-    fs14 = __toESM(require("fs"));
+    fs13 = __toESM(require("fs"));
     os5 = __toESM(require("os"));
-    path16 = __toESM(require("path"));
+    path15 = __toESM(require("path"));
     import_zod10 = require("zod");
     init_yaml();
     init_fs();
@@ -17743,7 +17584,7 @@ var init_openapi = __esm({
 
 // src/core/surfaces.ts
 function surfacesDir(rootDir) {
-  return path17.join(rootDir, ".wai", SURFACES_DIRNAME);
+  return path16.join(rootDir, ".wai", SURFACES_DIRNAME);
 }
 function audienceRank(audience) {
   const idx = SURFACE_AUDIENCES.indexOf(audience ?? "instance");
@@ -17901,12 +17742,12 @@ function projectSubsystemSurface(subsystemId) {
 }
 function listSnapshots(rootDir = getProjectRoot()) {
   const dir = surfacesDir(rootDir);
-  if (!fs15.existsSync(dir)) return [];
+  if (!fs14.existsSync(dir)) return [];
   const out = [];
-  for (const file of fs15.readdirSync(dir)) {
+  for (const file of fs14.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      out.push(SurfaceSnapshotSchema.parse(readYamlFile(path17.join(dir, file))));
+      out.push(SurfaceSnapshotSchema.parse(readYamlFile(path16.join(dir, file))));
     } catch {
     }
   }
@@ -17917,10 +17758,10 @@ function snapshotFilename(projectName) {
 }
 function writeSnapshotIfChanged(snapshot, rootDir) {
   const dir = surfacesDir(rootDir);
-  fs15.mkdirSync(dir, { recursive: true });
-  const p = path17.join(dir, snapshotFilename(snapshot.projectName));
+  fs14.mkdirSync(dir, { recursive: true });
+  const p = path16.join(dir, snapshotFilename(snapshot.projectName));
   const next = SurfaceSnapshotSchema.parse(snapshot);
-  if (fs15.existsSync(p)) {
+  if (fs14.existsSync(p)) {
     try {
       const existing = SurfaceSnapshotSchema.parse(readYamlFile(p));
       if (surfaceContentKey(existing) === surfaceContentKey(next)) {
@@ -17939,11 +17780,11 @@ function loadSurfaceSnapshots() {
   return listSnapshots();
 }
 function listMountSnapshots(mounts) {
-  const bound2 = path17.resolve(getProjectRoot());
+  const bound2 = path16.resolve(getProjectRoot());
   const out = [];
   for (const namespace of mounts) {
     const dir = resolveSubprojectForNamespace(namespace);
-    if (!dir || path17.resolve(dir) === bound2) continue;
+    if (!dir || path16.resolve(dir) === bound2) continue;
     const snapshots = listSnapshots(dir);
     if (snapshots.length > 0) out.push({ namespace, snapshots });
   }
@@ -17961,24 +17802,24 @@ function selectPortalSpec(renderedSet, portalId) {
   return [hit];
 }
 function perPortalPath(resolvedOut, portalId) {
-  const ext = path17.extname(resolvedOut);
+  const ext = path16.extname(resolvedOut);
   const stem2 = ext ? resolvedOut.slice(0, -ext.length) : resolvedOut;
   return `${stem2}.${safeFilenamePart(portalId)}${ext}`;
 }
 function writeSurfaceFile(outPath, snapshot, renderedSet) {
-  const resolved = path17.resolve(outPath);
-  fs15.mkdirSync(path17.dirname(resolved), { recursive: true });
+  const resolved = path16.resolve(outPath);
+  fs14.mkdirSync(path16.dirname(resolved), { recursive: true });
   if (!renderedSet || renderedSet.length === 0) {
     writeYamlFile(resolved, snapshot);
     return [resolved];
   }
   if (renderedSet.length === 1) {
-    fs15.writeFileSync(resolved, renderedSet[0].document);
+    fs14.writeFileSync(resolved, renderedSet[0].document);
     return [resolved];
   }
   return renderedSet.map((spec) => {
     const target = perPortalPath(resolved, spec.portalId);
-    fs15.writeFileSync(target, spec.document);
+    fs14.writeFileSync(target, spec.document);
     return target;
   });
 }
@@ -18000,14 +17841,14 @@ function exportSurface(maxAudience, format, outPath, portalId) {
   return exportResult(snapshot, renderedSet, writtenPaths);
 }
 function importSurface(sourcePath, origin) {
-  const resolved = path17.resolve(sourcePath);
-  if (!fs15.existsSync(resolved)) {
+  const resolved = path16.resolve(sourcePath);
+  if (!fs14.existsSync(resolved)) {
     throw new Error(`Surface document not found: ${resolved}`);
   }
-  const body = fs15.readFileSync(resolved, "utf8");
+  const body = fs14.readFileSync(resolved, "utf8");
   let snapshot;
   if (isOpenApiDocument(body)) {
-    const projectName = path17.basename(resolved).replace(/\.(json|ya?ml)$/i, "");
+    const projectName = path16.basename(resolved).replace(/\.(json|ya?ml)$/i, "");
     snapshot = fromOpenApi(body, projectName);
     snapshot = { ...snapshot, origin };
   } else {
@@ -18070,12 +17911,12 @@ function surfaceContentKey(snapshot) {
   const { stateId, generatedAt, origin, ...content } = snapshot;
   return JSON.stringify(content);
 }
-var fs15, path17, SURFACES_DIRNAME, CROSS_BOUNDARY_TARGETS;
+var fs14, path16, SURFACES_DIRNAME, CROSS_BOUNDARY_TARGETS;
 var init_surfaces = __esm({
   "src/core/surfaces.ts"() {
     "use strict";
-    fs15 = __toESM(require("fs"));
-    path17 = __toESM(require("path"));
+    fs14 = __toESM(require("fs"));
+    path16 = __toESM(require("path"));
     init_fs();
     init_yaml();
     init_filenames();
@@ -18381,13 +18222,13 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
 function resolveThroughParent(boundRoot, treatAllAsComplete, childRules) {
   const reach = getRequestParentReach();
   if (reach && !reach.parentReach) return null;
-  const ceiling = reach?.topRoot ? path18.resolve(reach.topRoot) : void 0;
+  const ceiling = reach?.topRoot ? path17.resolve(reach.topRoot) : void 0;
   const chain = [];
-  let top = path18.resolve(boundRoot);
+  let top = path17.resolve(boundRoot);
   while (top !== ceiling) {
     const hop = findChainingParent(top, ceiling);
     if (!hop) break;
-    const next = path18.resolve(hop.parentRoot);
+    const next = path17.resolve(hop.parentRoot);
     if (ceiling && !isWithinOrEqual(ceiling, next)) break;
     chain.unshift(hop.subsystemId);
     top = next;
@@ -18434,8 +18275,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 = path18.relative(dir, target);
-  return rel2 === "" || !rel2.startsWith("..") && !path18.isAbsolute(rel2);
+  const rel2 = path17.relative(dir, target);
+  return rel2 === "" || !rel2.startsWith("..") && !path17.isAbsolute(rel2);
 }
 function dedupeIssues(list2) {
   const seen = /* @__PURE__ */ new Set();
@@ -18456,7 +18297,7 @@ function settledStatusBearing(loaded) {
   if (!settled || settled.size === 0) return [];
   const root = getProjectRoot();
   const index = scanAllSpecs();
-  const rel2 = (abs) => path18.relative(root, abs).split(path18.sep).join("/");
+  const rel2 = (abs) => path17.relative(root, abs).split(path17.sep).join("/");
   const out = [];
   const take = (specs, paths) => {
     for (const spec of specs) {
@@ -18486,7 +18327,7 @@ function computeGateStateId() {
   registerBuiltinRules();
   return computeGateIdentity(content, extensions, ruleSequence(), inputs, gate);
 }
-var path18, RESOLUTION_FAILURE_CODES, SEVERITY_RANK;
+var path17, RESOLUTION_FAILURE_CODES, SEVERITY_RANK;
 var init_validation = __esm({
   "src/core/validation.ts"() {
     "use strict";
@@ -18502,7 +18343,7 @@ var init_validation = __esm({
     init_source_analysis();
     init_specs2();
     init_fs();
-    path18 = __toESM(require("path"));
+    path17 = __toESM(require("path"));
     init_core();
     RESOLUTION_FAILURE_CODES = /* @__PURE__ */ new Set([
       "UNDEFINED_TYPE_REFERENCE",
@@ -19222,42 +19063,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 = path19.resolve(dir);
-  const f = path19.resolve(file);
-  return f === d || f.startsWith(d + path19.sep);
+  const d = path18.resolve(dir);
+  const f = path18.resolve(file);
+  return f === d || f.startsWith(d + path18.sep);
 }
 function canonicalPath(target) {
-  let existing = path19.resolve(target);
+  let existing = path18.resolve(target);
   const rest = [];
   for (; ; ) {
     try {
-      fs16.lstatSync(existing);
+      fs15.lstatSync(existing);
       break;
     } catch {
-      const up = path19.dirname(existing);
-      if (up === existing) return path19.resolve(target);
-      rest.unshift(path19.basename(existing));
+      const up = path18.dirname(existing);
+      if (up === existing) return path18.resolve(target);
+      rest.unshift(path18.basename(existing));
       existing = up;
     }
   }
   try {
-    return path19.join(fs16.realpathSync.native(existing), ...rest);
+    return path18.join(fs15.realpathSync.native(existing), ...rest);
   } catch {
     return null;
   }
 }
 function chainDirKey(dir) {
-  return canonicalPath(dir) ?? path19.resolve(dir);
+  return canonicalPath(dir) ?? path18.resolve(dir);
 }
 function projectPathEscapesRoot(projectRoot2, projectPath, resolvedChildDir) {
-  if (path19.isAbsolute(projectPath) || !isWithin(projectRoot2, resolvedChildDir)) return true;
+  if (path18.isAbsolute(projectPath) || !isWithin(projectRoot2, resolvedChildDir)) return true;
   const root = canonicalPath(projectRoot2);
   const child = canonicalPath(resolvedChildDir);
   return root === null || child === null || !isWithin(root, child);
 }
 function assertContainedProjectPath(projectRoot2, projectPath) {
-  const root = path19.resolve(projectRoot2);
-  const resolved = path19.resolve(root, projectPath);
+  const root = path18.resolve(projectRoot2);
+  const resolved = path18.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.`
@@ -19268,12 +19109,12 @@ function assertContainedProjectPath(projectRoot2, projectPath) {
 function findChainingParent(childRoot, ceiling) {
   let childResolved;
   try {
-    childResolved = path19.resolve(childRoot);
+    childResolved = path18.resolve(childRoot);
   } catch {
     return null;
   }
-  const bound2 = ceiling ? path19.resolve(ceiling) : void 0;
-  let dir = path19.dirname(childResolved);
+  const bound2 = ceiling ? path18.resolve(ceiling) : void 0;
+  let dir = path18.dirname(childResolved);
   for (let hops = 0; hops < 32; hops++) {
     if (bound2 && !isWithin(bound2, dir)) break;
     const specsDir = aiPathsAt(dir).specsDir();
@@ -19289,7 +19130,7 @@ function findChainingParent(childRoot, ceiling) {
           const projectPath = raw.projectPath;
           if (typeof projectPath === "string" && projectPath.trim() !== "") {
             try {
-              const mountDir = path19.resolve(dir, projectPath);
+              const mountDir = path18.resolve(dir, projectPath);
               if (mountDir === childResolved && !projectPathEscapesRoot(dir, projectPath, mountDir)) {
                 const id = raw.id;
                 return { parentRoot: dir, subsystemId: typeof id === "string" ? id : "?" };
@@ -19300,14 +19141,14 @@ function findChainingParent(childRoot, ceiling) {
         }
       }
     }
-    const up = path19.dirname(dir);
+    const up = path18.dirname(dir);
     if (up === dir) break;
     dir = up;
   }
   return null;
 }
 function inspectChainedRoots(rootDir = getProjectRoot()) {
-  const root = path19.resolve(rootDir);
+  const root = path18.resolve(rootDir);
   const inspection = { roots: [], skipped: [] };
   const listed = /* @__PURE__ */ new Set();
   const walk2 = (projectDir, prefix, ancestors, depth) => {
@@ -19326,14 +19167,14 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
       const localId = typeof id === "string" ? id : "?";
       let childDir;
       try {
-        childDir = path19.resolve(projectDir, projectPath);
+        childDir = path18.resolve(projectDir, projectPath);
       } catch {
         continue;
       }
       let reason;
       if (projectPathEscapesRoot(projectDir, projectPath, childDir)) reason = "escapes";
       else if (ancestors.has(chainDirKey(childDir))) reason = "cyclic";
-      else if (!fs16.existsSync(childDir)) reason = "missing";
+      else if (!fs15.existsSync(childDir)) reason = "missing";
       else if (depth >= 32) reason = "too-deep";
       if (reason) {
         const mount = prefix ? qualifyDeclaredId(localId, prefix, true) : localId;
@@ -19343,7 +19184,7 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
       const key = chainDirKey(childDir);
       if (listed.has(key)) continue;
       listed.add(key);
-      inspection.roots.push(path19.relative(root, childDir).split(path19.sep).join("/"));
+      inspection.roots.push(path18.relative(root, childDir).split(path18.sep).join("/"));
       walk2(childDir, prefix ? `${prefix}::${localId}` : localId, /* @__PURE__ */ new Set([...ancestors, key]), depth + 1);
     }
   };
@@ -19429,9 +19270,9 @@ function stripNamespaceFromImplementation(spec, prefix) {
 }
 function childRelativeFilePaths(spec, authoringRoot, childRoot) {
   const reexpress = (p) => {
-    if (path19.isAbsolute(p)) return p;
-    const rel2 = path19.relative(childRoot, path19.resolve(authoringRoot, p));
-    const inside = rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path19.sep}`) && !path19.isAbsolute(rel2);
+    if (path18.isAbsolute(p)) return p;
+    const rel2 = path18.relative(childRoot, path18.resolve(authoringRoot, p));
+    const inside = rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path18.sep}`) && !path18.isAbsolute(rel2);
     return inside ? rel2.replace(/\\/g, "/") : p;
   };
   return {
@@ -19466,10 +19307,10 @@ function findOwner(id, components) {
   }) ?? null;
 }
 function moveComponentFolder(fromDir, toDir) {
-  if (path19.normalize(fromDir) === path19.normalize(toDir)) return false;
-  if (!fs16.existsSync(fromDir) || fs16.existsSync(toDir)) return false;
-  ensureDir(path19.dirname(toDir));
-  fs16.renameSync(fromDir, toDir);
+  if (path18.normalize(fromDir) === path18.normalize(toDir)) return false;
+  if (!fs15.existsSync(fromDir) || fs15.existsSync(toDir)) return false;
+  ensureDir(path18.dirname(toDir));
+  fs15.renameSync(fromDir, toDir);
   return true;
 }
 function formatZodIssues(error) {
@@ -19485,13 +19326,13 @@ function parseOrThrow(schema, value, kind, id) {
 function computeSpecTreeSignature(dirs) {
   const parts = [];
   for (const dir of dirs) {
-    if (!fs16.existsSync(dir)) {
+    if (!fs15.existsSync(dir)) {
       parts.push(`${dir}:missing`);
       continue;
     }
     for (const f of listSpecFiles(dir)) {
       try {
-        const st = fs16.statSync(f);
+        const st = fs15.statSync(f);
         parts.push(`${f}:${st.mtimeMs}:${st.size}`);
       } catch {
         parts.push(`${f}:gone`);
@@ -19884,7 +19725,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 = path19.resolve(rootDir);
+  const key = path18.resolve(rootDir);
   let ws = workspaces.get(key);
   if (!ws) {
     ws = new SpecWorkspace(key);
@@ -20014,13 +19855,13 @@ function snapshotInputKey(snapshot) {
   return canonicalize(content);
 }
 function consumedSurfaceInputsAt(rootDir) {
-  const dir = path19.join(rootDir, ".wai", "surfaces");
+  const dir = path18.join(rootDir, ".wai", "surfaces");
   if (!pathExists(dir)) return [];
   const keys = [];
-  for (const file of fs16.readdirSync(dir)) {
+  for (const file of fs15.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      keys.push(snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path19.join(dir, file)))));
+      keys.push(snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path18.join(dir, file)))));
     } catch {
     }
   }
@@ -20028,7 +19869,7 @@ function consumedSurfaceInputsAt(rootDir) {
 }
 function consumedContractInputs() {
   const root = getProjectRoot();
-  const roots = [root, ...listChainedRoots(root).map((rel2) => path19.join(root, rel2))];
+  const roots = [root, ...listChainedRoots(root).map((rel2) => path18.join(root, rel2))];
   return roots.flatMap(consumedSurfaceInputsAt);
 }
 function readLockState(current2) {
@@ -20064,7 +19905,7 @@ function markSelectionsBundled(bundled) {
   projectConfigRepository.markSelectionsBundled(bundled);
 }
 function computeStateIdAt(root) {
-  const resolved = path19.resolve(root);
+  const resolved = path18.resolve(root);
   return runWithProjectRoot(resolved, () => {
     workspaceFor(resolved).invalidate();
     const system = loadSystemSpec();
@@ -20102,7 +19943,7 @@ function snapshotSpecFiles() {
 }
 function restoreSpecFiles(snapshot) {
   for (const [file, content] of snapshot) {
-    fs16.writeFileSync(file, content);
+    fs15.writeFileSync(file, content);
   }
 }
 function findLegacySpecFiles() {
@@ -20114,12 +19955,12 @@ function updateSpec(kind, id, delta, hooks, dryRun) {
 function moveMethods(from, to, methods, hooks, dryRun) {
   return current().moveMethods(from, to, methods, hooks, dryRun);
 }
-var fs16, path19, 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 fs15, path18, 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";
-    fs16 = __toESM(require("fs"));
-    path19 = __toESM(require("path"));
+    fs15 = __toESM(require("fs"));
+    path18 = __toESM(require("path"));
     init_paths();
     init_project_config();
     init_fs();
@@ -20154,7 +19995,7 @@ var init_specs2 = __esm({
         this.rootSubsystems = /* @__PURE__ */ new Set();
         this.scanVisitedSpecDirs = [];
         this.loaderIssues = [];
-        this.rootDir = path19.resolve(rootDir);
+        this.rootDir = path18.resolve(rootDir);
         this.paths = aiPathsAt(this.rootDir);
       }
       invalidate() {
@@ -20197,8 +20038,8 @@ var init_specs2 = __esm({
        * qualifies the spec itself — so scoping a validate to a mount keeps it.
        */
       loaderIssueSpecId(file, rawId, namespacePrefix) {
-        const stem2 = path19.basename(file, ".yaml");
-        const local = rawId ?? (stem2.startsWith(".") ? path19.basename(path19.dirname(file)) : stem2);
+        const stem2 = path18.basename(file, ".yaml");
+        const local = rawId ?? (stem2.startsWith(".") ? path18.basename(path18.dirname(file)) : stem2);
         return namespacePrefix ? qualifyId(local, namespacePrefix, this.rootSubsystems) : local;
       }
       scanSpecsForProject(projectDir, namespacePrefix, visitedDirs, maxDepth, currentDepth) {
@@ -20208,10 +20049,10 @@ var init_specs2 = __esm({
         this.scanVisitedSpecDirs.push(specsDir);
         if (!pathExists(specsDir)) return index;
         const files = listSpecFiles(specsDir);
-        const systemYaml = path19.normalize(projectPaths.specsSystem());
+        const systemYaml = path18.normalize(projectPaths.specsSystem());
         const localSubprojects = [];
         for (const file of files) {
-          const normFile = path19.normalize(file);
+          const normFile = path18.normalize(file);
           if (normFile === systemYaml) continue;
           let detectedType = "spec";
           let rawId;
@@ -20255,7 +20096,7 @@ var init_specs2 = __esm({
             } else if ("contract" in raw) {
               detectedType = "implementation";
               const parsed = ImplementationSpecSchema.parse(raw);
-              const normalizeSourcePath = (p) => path19.relative(projectDir, path19.resolve(projectDir, p)).replace(/\\/g, "/");
+              const normalizeSourcePath = (p) => path18.relative(projectDir, path18.resolve(projectDir, p)).replace(/\\/g, "/");
               if (parsed.sourcePath) parsed.sourcePath = normalizeSourcePath(parsed.sourcePath);
               for (const method2 of parsed.methods) {
                 if (method2.sourcePath) method2.sourcePath = normalizeSourcePath(method2.sourcePath);
@@ -20381,7 +20222,7 @@ var init_specs2 = __esm({
         }
         if (currentDepth < maxDepth) {
           for (const subproj of localSubprojects) {
-            const childDir = path19.resolve(projectDir, subproj.projectPath);
+            const childDir = path18.resolve(projectDir, subproj.projectPath);
             const mountId = namespacePrefix ? qualifyDeclaredId(subproj.subsystemId, namespacePrefix, true) : subproj.subsystemId;
             if (projectPathEscapesRoot(projectDir, subproj.projectPath, childDir)) {
               this.loaderIssues.push({
@@ -20401,7 +20242,7 @@ var init_specs2 = __esm({
               });
               continue;
             }
-            if (!fs16.existsSync(childDir)) {
+            if (!fs15.existsSync(childDir)) {
               this.loaderIssues.push({
                 severity: "error",
                 code: "SUBPROJECT_NOT_FOUND",
@@ -20444,7 +20285,7 @@ var init_specs2 = __esm({
           const index = this.scanAll();
           const sub = index.subsystems.find((s) => s.id === currentPrefix);
           if (sub && sub.projectPath) {
-            const nextDir = path19.resolve(currentDir, sub.projectPath);
+            const nextDir = path18.resolve(currentDir, sub.projectPath);
             if (projectPathEscapesRoot(currentDir, sub.projectPath, nextDir)) {
               this.loaderIssues.push({
                 severity: "error",
@@ -20496,9 +20337,9 @@ var init_specs2 = __esm({
           return index.paths.subsystem[matches[0]];
         }
         if (pathExists(this.paths.specsSubsystemsDir()) && listFiles(this.paths.specsSubsystemsDir(), ".yaml").length > 0) {
-          return path19.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
+          return path18.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
         }
-        return path19.join(this.paths.specsDir(), id, ".index.yaml");
+        return path18.join(this.paths.specsDir(), id, ".index.yaml");
       }
       getComponentPath(id, subsystemId) {
         const index = this.scanAll();
@@ -20518,21 +20359,21 @@ var init_specs2 = __esm({
         if (owner) {
           const ownerPath = index.paths.component[owner.id];
           if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-            return path19.join(path19.dirname(ownerPath), id, ".index.yaml");
+            return path18.join(path18.dirname(ownerPath), id, ".index.yaml");
           }
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path19.dirname(subPath);
+          const subDir = path18.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path19.join(subDir, id, ".index.yaml");
+            return path18.join(subDir, id, ".index.yaml");
           }
         }
         if (pathExists(this.paths.specsComponentsDir()) && listFiles(this.paths.specsComponentsDir(), ".yaml").length > 0) {
-          return path19.join(this.paths.specsComponentsDir(), `${id}.yaml`);
+          return path18.join(this.paths.specsComponentsDir(), `${id}.yaml`);
         }
         const targetSubsystem = subsystemId || "default";
-        return path19.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
+        return path18.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
       }
       getInterfacePath(id, componentId) {
         const index = this.scanAll();
@@ -20558,16 +20399,16 @@ var init_specs2 = __esm({
         }
         if (componentId) {
           const compPath = this.getComponentPath(componentId);
-          const compDir = path19.dirname(compPath);
+          const compDir = path18.dirname(compPath);
           if (compPath.endsWith(".index.yaml")) {
-            return path19.join(compDir, ".interface.yaml");
+            return path18.join(compDir, ".interface.yaml");
           }
         }
         if (pathExists(this.paths.specsInterfacesDir()) && listFiles(this.paths.specsInterfacesDir(), ".yaml").length > 0) {
-          return path19.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
+          return path18.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
         }
         const targetComponent = componentId || "default";
-        return path19.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
+        return path18.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
       }
       getImplementationPath(id, contractId) {
         const index = this.scanAll();
@@ -20593,16 +20434,16 @@ var init_specs2 = __esm({
         }
         if (contractId) {
           const intfPath = this.getInterfacePath(contractId);
-          const intfDir = path19.dirname(intfPath);
+          const intfDir = path18.dirname(intfPath);
           if (intfPath.endsWith(".interface.yaml")) {
-            return path19.join(intfDir, ".implementation.yaml");
+            return path18.join(intfDir, ".implementation.yaml");
           }
         }
         if (pathExists(this.paths.specsImplementationsDir()) && listFiles(this.paths.specsImplementationsDir(), ".yaml").length > 0) {
-          return path19.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
+          return path18.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
         }
         const targetContract = contractId ? contractId.replace(/^i/, "") : "default";
-        return path19.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
+        return path18.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
       }
       getTypePath(id, subsystemId, group) {
         const index = this.scanAll();
@@ -20633,7 +20474,7 @@ var init_specs2 = __esm({
           const groupPath = index.paths.group[targetGroup] || index.paths.group[plainGroup];
           if (groupPath) {
             const localId2 = id.split("::").pop();
-            return path19.join(path19.dirname(groupPath), `${localId2}.yaml`);
+            return path18.join(path18.dirname(groupPath), `${localId2}.yaml`);
           }
         }
         let localId = id;
@@ -20646,12 +20487,12 @@ var init_specs2 = __esm({
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path19.dirname(subPath);
+          const subDir = path18.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path19.join(subDir, "types", `${localId}.yaml`);
+            return path18.join(subDir, "types", `${localId}.yaml`);
           }
         }
-        return path19.join(this.paths.specsTypesDir(), `${localId}.yaml`);
+        return path18.join(this.paths.specsTypesDir(), `${localId}.yaml`);
       }
       getGroupPath(id, subsystemId) {
         const index = this.scanAll();
@@ -20685,12 +20526,12 @@ var init_specs2 = __esm({
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path19.dirname(subPath);
+          const subDir = path18.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path19.join(subDir, "types", localId, ".index.yaml");
+            return path18.join(subDir, "types", localId, ".index.yaml");
           }
         }
-        return path19.join(this.paths.specsTypesDir(), localId, ".index.yaml");
+        return path18.join(this.paths.specsTypesDir(), localId, ".index.yaml");
       }
       // -------------------------------------------------------------------------
       // Level 0: System
@@ -20713,7 +20554,7 @@ var init_specs2 = __esm({
       }
       saveSystemSpec(spec) {
         const p = this.paths.specsSystem();
-        ensureDir(path19.dirname(p));
+        ensureDir(path18.dirname(p));
         writeSpecFile(p, parseOrThrow(SystemSpecSchema, spec, "system", spec.name));
         invalidateSpecCache();
       }
@@ -20835,7 +20676,7 @@ var init_specs2 = __esm({
       }
       saveSubsystemSpec(spec, opts) {
         const p = this.getSubsystemPath(spec.id);
-        ensureDir(path19.dirname(p));
+        ensureDir(path18.dirname(p));
         const { prefix } = splitNamespace(spec.id);
         if (!prefix && spec.projectPath && spec.projectPath.trim() !== "") {
           assertContainedProjectPath(this.rootDir, spec.projectPath);
@@ -20902,7 +20743,7 @@ var init_specs2 = __esm({
       saveComponentSpec(spec, opts) {
         const notices = [];
         const p = this.getComponentPath(spec.id, spec.subsystem);
-        ensureDir(path19.dirname(p));
+        ensureDir(path18.dirname(p));
         const specToWrite = this.prepareComponentForWrite(spec);
         const existing = this.loadComponentSpec(spec.id);
         if (existing) {
@@ -20919,7 +20760,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 ${path19.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 ${path18.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();
@@ -20943,12 +20784,12 @@ var init_specs2 = __esm({
         if (owner) {
           const ownerPath = index.paths.component[owner.id];
           if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-            const ownerSubDir = path19.dirname(this.getSubsystemPath(owner.subsystem));
-            return path19.join(ownerSubDir, owner.id, comp.id);
+            const ownerSubDir = path18.dirname(this.getSubsystemPath(owner.subsystem));
+            return path18.join(ownerSubDir, owner.id, comp.id);
           }
         }
-        const subDir = path19.dirname(this.getSubsystemPath(comp.subsystem));
-        return path19.join(subDir, comp.id);
+        const subDir = path18.dirname(this.getSubsystemPath(comp.subsystem));
+        return path18.join(subDir, comp.id);
       }
       /**
        * Move component folders so the physical tree mirrors ownership: each owned
@@ -20964,7 +20805,7 @@ var init_specs2 = __esm({
           if (!currentPath) continue;
           const desiredDir = this.desiredComponentDir(comp, index);
           if (!desiredDir) continue;
-          if (moveComponentFolder(path19.dirname(currentPath), desiredDir)) moved.push(comp.id);
+          if (moveComponentFolder(path18.dirname(currentPath), desiredDir)) moved.push(comp.id);
         }
         if (moved.length) invalidateSpecCache();
         return moved;
@@ -21020,7 +20861,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 ${path19.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 ${path18.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. */
@@ -21028,12 +20869,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(path19.dirname(p));
+        ensureDir(path18.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 ${path19.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 ${path18.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) {
@@ -21090,12 +20931,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(path19.dirname(p));
+        ensureDir(path18.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 ${path19.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 ${path18.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) {
@@ -21136,11 +20977,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(path19.dirname(p));
+        ensureDir(path18.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 ${path19.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 ${path18.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")) {
@@ -21178,7 +21019,7 @@ var init_specs2 = __esm({
       }
       saveGroupSpec(spec, opts) {
         const p = this.getGroupPath(spec.id);
-        ensureDir(path19.dirname(p));
+        ensureDir(path18.dirname(p));
         const specToWrite = this.prepareGroupForWrite(spec);
         const existing = this.loadGroupSpec(spec.id);
         if (existing) {
@@ -21256,7 +21097,7 @@ var init_specs2 = __esm({
         };
         const out = /* @__PURE__ */ new Set();
         const add = (p) => {
-          if (p) out.add(path19.resolve(p));
+          if (p) out.add(path18.resolve(p));
         };
         for (const s of this.loadSubsystemSpecs()) {
           if (!scopeSubsystem || s.id === scopeSubsystem || s.id.startsWith(`${scopeSubsystem}::`)) {
@@ -21327,16 +21168,16 @@ var init_specs2 = __esm({
         const files = /* @__PURE__ */ new Set();
         const sysPath = this.paths.specsSystem();
         if (pathExists(sysPath)) {
-          files.add(path19.resolve(sysPath));
+          files.add(path18.resolve(sysPath));
         }
         for (const group of Object.values(index.paths)) {
           for (const file of Object.values(group)) {
-            files.add(path19.resolve(file));
+            files.add(path18.resolve(file));
           }
         }
         for (const file of files) {
-          if (fs16.existsSync(file)) {
-            snapshot.set(file, fs16.readFileSync(file, "utf8"));
+          if (fs15.existsSync(file)) {
+            snapshot.set(file, fs15.readFileSync(file, "utf8"));
           }
         }
         return snapshot;
@@ -21350,20 +21191,20 @@ var init_specs2 = __esm({
         const files = listSpecFiles(specsDir);
         const legacy = [];
         for (const f of files) {
-          const base = path19.basename(f);
-          const dir = path19.dirname(f);
+          const base = path18.basename(f);
+          const dir = path18.dirname(f);
           if (base === "system.yaml") {
-            legacy.push({ path: f, expected: path19.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path18.join(dir, ".index.yaml") });
           } else if (base === "subsystem.yaml") {
-            legacy.push({ path: f, expected: path19.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path18.join(dir, ".index.yaml") });
           } else if (base === "component.yaml") {
-            legacy.push({ path: f, expected: path19.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path18.join(dir, ".index.yaml") });
           } else if (base === "group.yaml") {
-            legacy.push({ path: f, expected: path19.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path18.join(dir, ".index.yaml") });
           } else if (base === "interface.yaml") {
-            legacy.push({ path: f, expected: path19.join(dir, ".interface.yaml") });
+            legacy.push({ path: f, expected: path18.join(dir, ".interface.yaml") });
           } else if (base === "implementation.yaml") {
-            legacy.push({ path: f, expected: path19.join(dir, ".implementation.yaml") });
+            legacy.push({ path: f, expected: path18.join(dir, ".implementation.yaml") });
           }
         }
         return legacy;
@@ -22366,18 +22207,76 @@ var init_specs2 = __esm({
   }
 });
 
+// src/config/loader.ts
+function loadTopologyConfig() {
+  assertProjectInitialized();
+  if (!pathExists(AI_PATHS.topologyConfig())) return createEmptyTopologyConfig();
+  const raw = readYamlFile(AI_PATHS.topologyConfig());
+  if (!raw) return createEmptyTopologyConfig();
+  return TopologyConfigSchema.parse(raw);
+}
+function saveTopologyConfig(config) {
+  writeYamlFile(AI_PATHS.topologyConfig(), config);
+}
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    "use strict";
+    init_fs();
+    init_yaml();
+    init_models();
+    init_paths();
+  }
+});
+
 // src/core/domains.ts
-var domains_exports = {};
-__export(domains_exports, {
-  addFreeStandingDomain: () => addFreeStandingDomain,
-  deriveSubsystemDomains: () => deriveSubsystemDomains,
-  findDomain: () => findDomain,
-  listFreeStandingDomains: () => listFreeStandingDomains,
-  removeFreeStandingDomain: () => removeFreeStandingDomain,
-  resolveDomains: () => resolveDomains
+function addFreeStandingDomain(domain) {
+  const config = loadTopologyConfig();
+  if (config.domains.some((d) => d.id === domain.id)) {
+    throw new WaironError(`A free-standing domain "${domain.id}" already exists in .wai/topology.yaml.`);
+  }
+  config.domains.push(domain);
+  saveTopologyConfig(config);
+}
+function removeFreeStandingDomain(id) {
+  const config = loadTopologyConfig();
+  const idx = config.domains.findIndex((d) => d.id === id);
+  if (idx === -1) {
+    throw new WaironError(
+      `"${id}" is not a free-standing domain. Subsystem-backed domains are derived from the spec tree and cannot be removed here.`
+    );
+  }
+  config.domains.splice(idx, 1);
+  saveTopologyConfig(config);
+}
+var init_domains = __esm({
+  "src/core/domains.ts"() {
+    "use strict";
+    init_loader();
+    init_errors();
+  }
+});
+
+// src/core/topology.ts
+function addFreeStanding(domain) {
+  addFreeStandingDomain(domain);
+}
+function removeFreeStanding(id) {
+  removeFreeStandingDomain(id);
+}
+function loadConfig() {
+  return loadTopologyConfig();
+}
+var init_topology = __esm({
+  "src/core/topology.ts"() {
+    "use strict";
+    init_domains();
+    init_loader();
+  }
 });
+
+// src/core/domain_projector.ts
 function rel(p) {
-  return path20.relative(process.cwd(), p).replace(/\\/g, "/");
+  return path19.relative(process.cwd(), p).replace(/\\/g, "/");
 }
 function deriveSubsystemDomains() {
   const subsystems = loadSubsystemSpecs();
@@ -22396,45 +22295,210 @@ function deriveSubsystemDomains() {
     };
   });
 }
-function listFreeStandingDomains() {
-  return loadTopologyConfig().domains;
-}
 function resolveDomains() {
-  return [...deriveSubsystemDomains(), ...listFreeStandingDomains()];
-}
-function findDomain(id) {
-  return resolveDomains().find((d) => d.id === id);
+  const derived = deriveSubsystemDomains();
+  const registered = loadConfig().domains;
+  return [...derived, ...registered];
 }
-function addFreeStandingDomain(domain) {
-  const config = loadTopologyConfig();
-  if (config.domains.some((d) => d.id === domain.id)) {
-    throw new WaironError(`A free-standing domain "${domain.id}" already exists in .wai/topology.yaml.`);
+var path19;
+var init_domain_projector = __esm({
+  "src/core/domain_projector.ts"() {
+    "use strict";
+    path19 = __toESM(require("path"));
+    init_specs2();
+    init_topology();
   }
-  if (deriveSubsystemDomains().some((d) => d.id === domain.id)) {
-    throw new WaironError(`Domain id "${domain.id}" collides with a subsystem-derived domain.`);
+});
+
+// src/core/domain_curator.ts
+function registerDomain(domain) {
+  const taken = resolveDomains().find((d) => d.id === domain.id);
+  if (taken) {
+    throw new WaironError(refusal(taken));
   }
-  config.domains.push(domain);
-  saveTopologyConfig(config);
+  addFreeStanding(domain);
 }
-function removeFreeStandingDomain(id) {
-  const config = loadTopologyConfig();
-  const idx = config.domains.findIndex((d) => d.id === id);
-  if (idx === -1) {
-    throw new WaironError(
-      `"${id}" is not a free-standing domain. Subsystem-backed domains are derived from the spec tree and cannot be removed here.`
+function refusal(taken) {
+  return taken.boundTo ? `Domain id "${taken.id}" collides with a subsystem-derived domain.` : `A free-standing domain "${taken.id}" already exists in .wai/topology.yaml.`;
+}
+function unregisterDomain(id) {
+  removeFreeStanding(id);
+}
+var init_domain_curator = __esm({
+  "src/core/domain_curator.ts"() {
+    "use strict";
+    init_domain_projector();
+    init_topology();
+    init_errors();
+  }
+});
+
+// src/core/detection.ts
+function detectDomainCandidates(projectRoot2, alreadyTrackedPaths = /* @__PURE__ */ new Set(), alreadyTrackedIds = /* @__PURE__ */ new Set()) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const c of detectGitSubmodules(projectRoot2)) {
+    candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
+  }
+  for (const c of detectNestedGitRepos(projectRoot2)) {
+    if (!candidates.has(c.path)) {
+      candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
+    }
+  }
+  const gitPaths = new Set(
+    Array.from(candidates.values()).filter((c) => c.type === "git-submodule" || c.type === "git-repo").map((c) => c.path)
+  );
+  for (const c of detectPackageRoots(projectRoot2)) {
+    if (candidates.has(c.path)) continue;
+    const insideGit = Array.from(gitPaths).some(
+      (gp) => c.path === gp || c.path.startsWith(gp + "/")
     );
+    if (insideGit) continue;
+    candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
   }
-  config.domains.splice(idx, 1);
-  saveTopologyConfig(config);
+  const sorted = Array.from(candidates.values()).sort((a, b) => a.path.localeCompare(b.path));
+  return deduplicateIds(sorted, alreadyTrackedIds);
 }
-var path20;
-var init_domains = __esm({
-  "src/core/domains.ts"() {
+function deduplicateIds(candidates, existingIds = /* @__PURE__ */ new Set()) {
+  const idCount = /* @__PURE__ */ new Map();
+  for (const id of existingIds) {
+    idCount.set(id, (idCount.get(id) ?? 0) + 1);
+  }
+  for (const c of candidates) {
+    idCount.set(c.suggestedId, (idCount.get(c.suggestedId) ?? 0) + 1);
+  }
+  return candidates.map((c) => {
+    if ((idCount.get(c.suggestedId) ?? 0) <= 1) return c;
+    const parts = c.path.split("/");
+    const qualifiedId2 = parts.length >= 2 ? pathToId(`${parts[parts.length - 2]}-${parts[parts.length - 1]}`) : c.suggestedId;
+    return { ...c, suggestedId: qualifiedId2 };
+  });
+}
+function parseGitmodules(filePath) {
+  const content = fs16.readFileSync(filePath, "utf-8");
+  const entries = [];
+  let current2 = {};
+  for (const line2 of content.split("\n")) {
+    const trimmed = line2.trim();
+    const headerMatch = trimmed.match(/^\[submodule "(.+)"\]$/);
+    if (headerMatch) {
+      if (current2.path) entries.push(current2);
+      current2 = { name: headerMatch[1] };
+      continue;
+    }
+    const keyVal = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+    if (keyVal) {
+      const [, key, value] = keyVal;
+      if (key === "path") current2.path = value.trim();
+      if (key === "url") current2.url = value.trim();
+    }
+  }
+  if (current2.path) entries.push(current2);
+  return entries;
+}
+function detectGitSubmodules(projectRoot2) {
+  const gitmodulesPath = path20.join(projectRoot2, ".gitmodules");
+  if (!fs16.existsSync(gitmodulesPath)) return [];
+  return parseGitmodules(gitmodulesPath).map((entry) => ({
+    suggestedId: pathToId(entry.path),
+    suggestedName: pathToName(entry.path),
+    path: normalizePath(entry.path),
+    type: "git-submodule",
+    alreadyTracked: false
+  }));
+}
+function detectNestedGitRepos(projectRoot2) {
+  const results = [];
+  walkForGit(projectRoot2, projectRoot2, 0, results);
+  return results;
+}
+function walkForGit(projectRoot2, currentDir, depth, results) {
+  if (depth > MAX_SCAN_DEPTH) return;
+  let entries;
+  try {
+    entries = fs16.readdirSync(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
+    const fullPath = path20.join(currentDir, entry.name);
+    const relPath = normalizePath(path20.relative(projectRoot2, fullPath));
+    if (relPath === "" || relPath === ".") continue;
+    const gitPath = path20.join(fullPath, ".git");
+    if (fs16.existsSync(gitPath)) {
+      results.push({
+        suggestedId: pathToId(relPath),
+        suggestedName: pathToName(relPath),
+        path: relPath,
+        type: "git-repo",
+        alreadyTracked: false
+      });
+      continue;
+    }
+    walkForGit(projectRoot2, fullPath, depth + 1, results);
+  }
+}
+function detectPackageRoots(projectRoot2) {
+  const results = [];
+  walkForPackages(projectRoot2, projectRoot2, 0, results);
+  return results;
+}
+function walkForPackages(projectRoot2, currentDir, depth, results) {
+  if (depth > MAX_SCAN_DEPTH) return;
+  let entries;
+  try {
+    entries = fs16.readdirSync(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
+    const fullPath = path20.join(currentDir, entry.name);
+    const relPath = normalizePath(path20.relative(projectRoot2, fullPath));
+    if (relPath === "" || relPath === ".") continue;
+    const hasMarker = PACKAGE_MARKERS.some((m) => fs16.existsSync(path20.join(fullPath, m)));
+    if (hasMarker) {
+      results.push({
+        suggestedId: pathToId(relPath),
+        suggestedName: pathToName(relPath),
+        path: relPath,
+        type: "package-root",
+        alreadyTracked: false
+      });
+    }
+    walkForPackages(projectRoot2, fullPath, depth + 1, results);
+  }
+}
+function pathToId(relPath) {
+  const basename15 = path20.basename(relPath);
+  return basename15.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function pathToName(relPath) {
+  const id = pathToId(relPath);
+  return id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+var fs16, path20, PACKAGE_MARKERS, MAX_SCAN_DEPTH;
+var init_detection = __esm({
+  "src/core/detection.ts"() {
     "use strict";
+    fs16 = __toESM(require("fs"));
     path20 = __toESM(require("path"));
-    init_loader();
-    init_specs2();
-    init_errors();
+    init_defaults();
+    PACKAGE_MARKERS = [
+      "package.json",
+      "pyproject.toml",
+      "Cargo.toml",
+      "go.mod",
+      "build.gradle",
+      "build.gradle.kts",
+      "pom.xml"
+    ];
+    MAX_SCAN_DEPTH = 5;
   }
 });
 
@@ -23218,21 +23282,6 @@ function resolveBudget(profile, config, agentId) {
   const override = config.overrides[agentId];
   return override ? { ...budget, ...override } : budget;
 }
-function describeBudget(profile, budget) {
-  const lines = [
-    `- **Work shape**: ${profile.breadth} breadth, ${profile.reasoningDepth} reasoning${profile.writes ? "" : ", read-only"}${profile.delegates ? ", delegating" : ""}`,
-    `- **Why**: ${profile.rationale}`
-  ];
-  if (budget.modelTier) lines.push(`- **Capability tier**: ${budget.modelTier}`);
-  if (budget.effort) lines.push(`- **Effort**: ${budget.effort}`);
-  if (budget.maxTurns !== void 0) {
-    lines.push(`- **Turn ceiling**: ${budget.maxTurns} (a circuit breaker \u2014 hitting it should read as a scoping error, not a limit to work up to)`);
-  }
-  lines.push(`- **Tool grant**: ${budget.toolClass}`);
-  lines.push(`- **May delegate further**: ${budget.allowNestedDelegation ? "yes" : "no"}`);
-  lines.push(`- **MCP access**: ${budget.mcp}`);
-  return lines;
-}
 var TIER_ORDER, TIER_STEPS;
 var init_budget_policy = __esm({
   "src/core/budget_policy.ts"() {
@@ -23373,7 +23422,7 @@ function inferSourcePathForComponent(comp, subsystems) {
     return null;
   }
 }
-function summarize(text2, max = 140) {
+function summarize2(text2, max = 140) {
   const clean = text2.replace(/\s+/g, " ").trim();
   const period = clean.indexOf(". ");
   const firstSentence = period > 0 ? clean.slice(0, period + 1) : clean;
@@ -23400,7 +23449,7 @@ function resolveAgentTopology() {
   agents.push({
     id: "system-architect",
     name: `${system.name} Architect`,
-    description: `Global architect for ${system.name} \u2014 owns the spec tree and topology. ${summarize(system.vision)}`,
+    description: `Global architect for ${system.name} \u2014 owns the spec tree and topology. ${summarize2(system.vision)}`,
     template: "architect",
     creationReason: "Automatically inferred from L0 system spec",
     ownedPaths: [".wai/specs/**"],
@@ -23480,7 +23529,7 @@ function resolveAgentTopology() {
     agents.push({
       id: `${sub.id}-owner`,
       name: `${sub.name} Owner`,
-      description: `Owns the ${sub.id} subsystem. ${summarize(sub.description)}`,
+      description: `Owns the ${sub.id} subsystem. ${summarize2(sub.description)}`,
       template: "domain-owner",
       creationReason: `Automatically inferred from L1 subsystem spec: ${sub.id}`,
       domainRoot: sub.id,
@@ -23541,11 +23590,11 @@ function resolveAgentTopology() {
     }
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (const dom of loadTopologyConfig().domains) {
+  for (const dom of loadConfig().domains) {
     agents.push({
       id: `${dom.id}-owner`,
       name: `${dom.name ?? dom.id} Owner`,
-      description: dom.description ? summarize(dom.description) : `Owner agent for the free-standing "${dom.id}" domain.`,
+      description: dom.description ? summarize2(dom.description) : `Owner agent for the free-standing "${dom.id}" domain.`,
       template: "domain-owner",
       creationReason: "Inferred from a free-standing domain in .wai/topology.yaml",
       domainRoot: dom.id,
@@ -23622,7 +23671,7 @@ var init_agent_resolver = __esm({
     "use strict";
     path23 = __toESM(require("path"));
     fs18 = __toESM(require("fs"));
-    init_loader();
+    init_topology();
     init_paths();
     init_registry();
     init_project_config();
@@ -24005,8 +24054,7 @@ function renderDomainsDoc() {
   return lines.join("\n") + "\n";
 }
 function renderWaironGuide() {
-  const { resolveDomains: resolveDomains2 } = (init_domains(), __toCommonJS(domains_exports));
-  const domains = resolveDomains2();
+  const domains = resolveDomains();
   let projectName = "this project";
   try {
     projectName = projectConfigRepository.load()?.name ?? projectName;
@@ -24090,7 +24138,7 @@ var init_context = __esm({
     init_fs();
     init_ai_guide();
     init_stamp();
-    init_domains();
+    init_domain_projector();
     init_project_config();
     CONTEXT_PATHS = {
       dir: () => contextDir(),
@@ -28175,6 +28223,15 @@ var init_approver = __esm({
 });
 
 // src/core/index.ts
+function resolveDomains2() {
+  return resolveDomains();
+}
+function addDomain(domain) {
+  registerDomain(domain);
+}
+function removeDomain(id) {
+  unregisterDomain(id);
+}
 function loadProjectConfig() {
   return projectConfigRepository.load();
 }
@@ -28185,8 +28242,9 @@ var init_core = __esm({
   "src/core/index.ts"() {
     "use strict";
     init_project_config();
+    init_domain_projector();
+    init_domain_curator();
     init_detection();
-    init_domains();
     init_templates();
     init_validation();
     init_extensions();
@@ -28215,6 +28273,8 @@ var init_core = __esm({
     init_approver();
     init_specs2();
     init_project_config();
+    init_execution_profile();
+    init_budget_policy();
   }
 });
 
@@ -28916,7 +28976,7 @@ function renderAgentBriefMarkdown(brief) {
       "",
       "## Execution budget",
       "",
-      ...describeBudget(brief.profile, brief.budget),
+      ...summarize(brief.budget, brief.profile),
       "",
       "Advisory \u2014 apply these when spawning. Map the capability tier onto your host tool's models; a tool that cannot express a field should ignore it rather than approximate it."
     );
@@ -29047,7 +29107,7 @@ function createMcpServer(options = {}) {
     },
     () => {
       try {
-        return json(resolveDomains());
+        return json(resolveDomains2());
       } catch (e) {
         return errText(String(e));
       }
@@ -30299,12 +30359,12 @@ var init_server = __esm({
     init_paths();
     init_validation();
     init_provision();
-    init_domains();
+    init_core();
     init_authoring();
     init_variants();
     init_agent_resolver();
     init_core();
-    init_budget_policy();
+    init_execution();
     init_surfaces();
     TYPE_REF_GRAMMAR = (what) => `${what}: a primitive/builtin or a defined type id (qualified across subsystems, e.g. "billing.Invoice" or "billing::Invoice"). Generics, arrays and UNIONS are all read, at any depth: "Invoice | null" (the commonest shape there is), "Invoice | undefined", "Invoice | Receipt", "Promise<Invoice | null>", "Map<string, Invoice | null>", "Invoice[] | null", "(Invoice | null)[]". Every identifier the string names must resolve \u2014 a union of two defined types means BOTH must exist. A union of string literals ("read" | "write") names no type and resolves to nothing.`;
     staleServerOutput = {
@@ -31062,6 +31122,24 @@ function generateAll2(agents, config, options) {
 function resolveExpectedOutputPaths2(agents, config) {
   return resolveExpectedOutputPaths(agents, config);
 }
+function resolveDomains3() {
+  return resolveDomains2();
+}
+function addDomain2(domain) {
+  addDomain(domain);
+}
+function removeDomain2(id) {
+  removeDomain(id);
+}
+function detectDomainCandidates2(projectRoot2, trackedPaths, trackedIds) {
+  return detectDomainCandidates(projectRoot2, trackedPaths, trackedIds);
+}
+function deriveExecutionProfile2(agent) {
+  return deriveExecutionProfile(agent);
+}
+function resolveBudget2(profile, config, agentId) {
+  return resolveBudget(profile, config, agentId);
+}
 async function runSubsystemAdd(id, options = {}) {
   logger.header("wairon subsystem add");
   if (!projectConfigExists2()) {
@@ -32730,12 +32808,10 @@ async function filteredCheckbox(config) {
 
 // src/commands/domains.ts
 init_paths();
-init_detection();
-init_domains();
 init_domain();
 async function runDomainsList() {
   assertProjectInitialized();
-  const domains = resolveDomains();
+  const domains = resolveDomains3();
   if (domains.length === 0) {
     logger.info("No domains yet.");
     logger.info("Define subsystems in the spec tree, or run `wairon domains scan --add` for free-standing domains.");
@@ -32760,10 +32836,10 @@ function printDomain(domain) {
 async function runDomainsScan(options = {}) {
   assertProjectInitialized();
   const projectRoot2 = fromProjectRoot();
-  const existing = resolveDomains();
+  const existing = resolveDomains3();
   const trackedPaths = new Set(existing.map((d) => d.path).filter((p) => !!p));
   const trackedIds = new Set(existing.map((d) => d.id));
-  const candidates = detectDomainCandidates(projectRoot2, trackedPaths, trackedIds);
+  const candidates = detectDomainCandidates2(projectRoot2, trackedPaths, trackedIds);
   const newCandidates = candidates.filter((c) => !c.alreadyTracked && !trackedIds.has(c.suggestedId));
   if (newCandidates.length === 0) {
     logger.success("No new domain candidates found.");
@@ -32804,7 +32880,7 @@ async function runDomainsScan(options = {}) {
       ownedPaths: [`${candidate.path}/**`]
     });
     try {
-      addFreeStandingDomain(domain);
+      addDomain2(domain);
       logger.success(`Added free-standing domain: ${domain.id} (${candidate.path})`);
       added++;
     } catch (err) {
@@ -32854,13 +32930,13 @@ async function runDomainsAdd(options = {}) {
     path: domainPath.trim() || void 0,
     ownedPaths
   });
-  addFreeStandingDomain(domain);
+  addDomain2(domain);
   logger.success(`Free-standing domain "${domain.id}" added to .wai/topology.yaml.`);
   logger.info("Run `wairon generate` to produce its owner agent.");
 }
 async function runDomainsRemove(id) {
   assertProjectInitialized();
-  const domain = findDomain(id);
+  const domain = resolveDomains3().find((d) => d.id === id);
   if (!domain) {
     logger.error(`Domain "${id}" not found.`);
     process.exit(1);
@@ -32882,7 +32958,7 @@ async function runDomainsRemove(id) {
     logger.info("Cancelled.");
     return;
   }
-  removeFreeStandingDomain(id);
+  removeDomain2(id);
   logger.success(`Domain "${id}" removed. Run \`wairon generate\` to refresh agent files.`);
 }
 
@@ -48320,15 +48396,12 @@ function report(outcome) {
 }
 
 // src/cli/index.ts
-init_budget_policy();
+init_execution();
 
 // src/commands/execution.ts
 var import_chalk21 = __toESM(require("chalk"));
 init_logger();
 init_errors();
-init_agent_resolver();
-init_execution_profile();
-init_budget_policy();
 init_execution();
 function assertInitialized() {
   if (!projectConfigExists2()) {
@@ -48356,7 +48429,7 @@ async function showExecution() {
     logger.info(`Enable with ${import_chalk21.default.bold("wairon execution set-tier default")}.`);
     return;
   }
-  const agents = resolveAgentTopology();
+  const agents = resolveAgentTopology2();
   if (agents.length === 0) {
     logger.blank();
     logger.warn("No agents in the topology yet \u2014 nothing to budget.");
@@ -48364,8 +48437,8 @@ async function showExecution() {
   }
   logger.blank();
   const rows = agents.map((agent) => {
-    const profile = deriveExecutionProfile(agent);
-    const budget = resolveBudget(profile, config.execution, agent.id);
+    const profile = deriveExecutionProfile2(agent);
+    const budget = resolveBudget2(profile, config.execution, agent.id);
     return { agent, profile, budget };
   });
   const idWidth = Math.max(...rows.map((r) => r.agent.id.length));
@@ -48700,7 +48773,7 @@ async function runAgent(action, id) {
       if (brief.budget && brief.profile) {
         logger.blank();
         logger.info("Execution budget (advisory \u2014 apply when spawning):");
-        for (const line2 of describeBudget(brief.profile, brief.budget)) {
+        for (const line2 of summarize(brief.budget, brief.profile)) {
           logger.info(`  ${line2.replace(/^- \*\*(.+?)\*\*: /, "$1: ")}`);
         }
       }