@wairon/cli 5.1.1-dev.53 → 5.1.1-dev.55

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.53";
+    WAIRON_VERSION = "5.1.1-dev.55";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -22768,6 +22768,270 @@ var init_treetransfer = __esm({
   }
 });
 
+// src/exporters/claude.ts
+function toolsFor(budget) {
+  const base = TOOLS_BY_CLASS[budget.toolClass];
+  if (!base) return void 0;
+  if (budget.allowNestedDelegation && !base.includes("Agent")) {
+    return [...base, "Agent"];
+  }
+  if (!budget.allowNestedDelegation) {
+    return base.filter((t) => t !== "Agent");
+  }
+  return base;
+}
+function mcpServersFor(access) {
+  return access === "none" ? "[]" : void 0;
+}
+function yamlScalar(value) {
+  return /[:#\n]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
+}
+var path22, MODEL_BY_TIER, TOOLS_BY_CLASS, ClaudeExporter;
+var init_claude = __esm({
+  "src/exporters/claude.ts"() {
+    "use strict";
+    path22 = __toESM(require("path"));
+    init_fs();
+    MODEL_BY_TIER = {
+      small: "haiku",
+      standard: "sonnet",
+      large: "opus",
+      frontier: "fable"
+    };
+    TOOLS_BY_CLASS = {
+      "read-only": ["Read", "Grep", "Glob"],
+      implement: ["Read", "Grep", "Glob", "Edit", "Write", "Bash"],
+      orchestrate: ["Agent", "SendMessage", "TodoWrite"],
+      // `full` means "inherit everything" — expressed by omitting the field.
+      full: void 0
+    };
+    ClaudeExporter = class {
+      constructor(options = {}) {
+        this.options = options;
+        this.targetType = "claude";
+      }
+      outputPath(ctx) {
+        const { agent, target, projectRoot: projectRoot2 } = ctx;
+        const outputDir = "outputDir" in target ? target.outputDir : ".claude/agents";
+        return path22.resolve(projectRoot2, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+      }
+      export(ctx) {
+        const { agent, renderedInstructions, budget } = ctx;
+        const filePath = this.outputPath(ctx);
+        const frontmatter = [
+          `name: ${agent.name}`,
+          `description: ${yamlScalar(agent.description)}`
+        ];
+        if (budget && this.options.emitBudget) {
+          if (budget.modelTier) frontmatter.push(`model: ${MODEL_BY_TIER[budget.modelTier]}`);
+          if (budget.effort) frontmatter.push(`effort: ${budget.effort}`);
+          if (budget.maxTurns !== void 0) frontmatter.push(`maxTurns: ${budget.maxTurns}`);
+          const tools = toolsFor(budget);
+          if (tools) frontmatter.push(`tools: ${tools.join(", ")}`);
+          const servers = mcpServersFor(budget.mcp);
+          if (servers) frontmatter.push(`mcpServers: ${servers}`);
+        }
+        const content = ["---", ...frontmatter, "---", "", renderedInstructions, ""].join("\n");
+        const changed = writeFileIfChanged(filePath, content);
+        return { outputPath: filePath, content, unchanged: !changed };
+      }
+    };
+  }
+});
+
+// src/exporters/custom.ts
+var path23, CustomExporter;
+var init_custom = __esm({
+  "src/exporters/custom.ts"() {
+    "use strict";
+    path23 = __toESM(require("path"));
+    init_fs();
+    CustomExporter = class {
+      constructor() {
+        this.targetType = "custom";
+      }
+      outputPath(ctx) {
+        const { agent, target, projectRoot: projectRoot2 } = ctx;
+        if (!("outputDir" in target)) {
+          throw new Error("CustomExporter requires target.outputDir");
+        }
+        return path23.resolve(projectRoot2, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+      }
+      export(ctx) {
+        const { agent, target, renderedInstructions } = ctx;
+        const label = "label" in target ? target.label : "Custom";
+        const filePath = this.outputPath(ctx);
+        const content = [
+          "---",
+          `name: ${agent.name}`,
+          `description: ${agent.description}`,
+          `id: ${agent.id}`,
+          `target: ${label}`,
+          "---",
+          "",
+          renderedInstructions,
+          ""
+        ].join("\n");
+        const changed = writeFileIfChanged(filePath, content);
+        return { outputPath: filePath, content, unchanged: !changed };
+      }
+    };
+  }
+});
+
+// src/exporters/gemini.ts
+function yamlString(value) {
+  if (/[:#\[\]{},&*!|>'"%@`]/.test(value) || value.startsWith(" ") || value.endsWith(" ")) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+var path24, GeminiExporter;
+var init_gemini = __esm({
+  "src/exporters/gemini.ts"() {
+    "use strict";
+    path24 = __toESM(require("path"));
+    init_fs();
+    GeminiExporter = class {
+      constructor() {
+        this.targetType = "gemini";
+      }
+      outputPath(ctx) {
+        const { agent, target, projectRoot: projectRoot2 } = ctx;
+        const outputDir = "outputDir" in target ? target.outputDir : ".gemini/agents";
+        return path24.resolve(projectRoot2, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
+      }
+      export(ctx) {
+        const { agent, renderedInstructions } = ctx;
+        const filePath = this.outputPath(ctx);
+        const indentedInstructions = renderedInstructions.split("\n").map((line2) => line2.length > 0 ? `  ${line2}` : "").join("\n");
+        const content = [
+          `name: ${yamlString(agent.name)}`,
+          `description: ${yamlString(agent.description)}`,
+          `system_prompt: |`,
+          indentedInstructions,
+          ""
+        ].join("\n");
+        const changed = writeFileIfChanged(filePath, content);
+        return { outputPath: filePath, content, unchanged: !changed };
+      }
+    };
+  }
+});
+
+// src/exporters/registry.ts
+function getExporter(target) {
+  const type = typeof target === "string" ? target : target.type;
+  const exporter = EXPORTERS.get(type);
+  if (!exporter) {
+    throw new WaironError(`No exporter registered for target type: "${type}"`);
+  }
+  return exporter;
+}
+var EXPORTERS;
+var init_registry2 = __esm({
+  "src/exporters/registry.ts"() {
+    "use strict";
+    init_claude();
+    init_custom();
+    init_gemini();
+    init_errors();
+    EXPORTERS = /* @__PURE__ */ new Map([
+      ["claude", new ClaudeExporter({ emitBudget: true })],
+      ["gemini", new GeminiExporter()],
+      ["agy", new GeminiExporter()],
+      ["cursor", new ClaudeExporter()],
+      ["copilot", new ClaudeExporter()],
+      ["codex", new ClaudeExporter()],
+      ["custom", new CustomExporter()]
+    ]);
+  }
+});
+
+// src/exporters/base.ts
+var WAIRON_MANAGED_MARKER, WAIRON_MANAGED_BANNER;
+var init_base = __esm({
+  "src/exporters/base.ts"() {
+    "use strict";
+    WAIRON_MANAGED_MARKER = "wairon:managed";
+    WAIRON_MANAGED_BANNER = `<!-- ${WAIRON_MANAGED_MARKER} \u2014 generated by \`wairon generate\`; do not edit, changes are overwritten -->`;
+  }
+});
+
+// src/exporters/generate.ts
+function generateAgent(agent, projectConfig, options = {}) {
+  const projectRoot2 = options.projectRoot ?? getProjectRoot();
+  const template = loadTemplate(agent.template, projectConfig.globalTemplatesDir);
+  const rendered = `${WAIRON_MANAGED_BANNER}
+${composeAgentBrief(agent.id).instructions}`;
+  const results = [];
+  const budget = resolveBudget(
+    deriveExecutionProfile(agent),
+    projectConfig.execution,
+    agent.id
+  );
+  for (const agentTarget of agent.targets) {
+    const targetConfig = resolveTargetConfig(agentTarget, projectConfig);
+    if (!targetConfig) continue;
+    if (options.filterTargets) {
+      const type = "type" in targetConfig ? targetConfig.type : targetConfig;
+      if (!options.filterTargets.includes(type)) continue;
+    }
+    if (!options.dryRun) {
+      results.push(getExporter(targetConfig).export({
+        agent,
+        template,
+        renderedInstructions: rendered,
+        projectRoot: projectRoot2,
+        target: targetConfig,
+        budget
+      }));
+    }
+  }
+  return { agent, results };
+}
+function generateAll(agents, projectConfig, options = {}) {
+  let pool = agents;
+  if (options.filterDomainIds && options.filterDomainIds.length > 0) {
+    const ids = new Set(options.filterDomainIds);
+    pool = agents.filter((a) => ids.has(a.domainRoot ?? "root"));
+  }
+  return pool.map((agent) => generateAgent(agent, projectConfig, options));
+}
+function resolveExpectedOutputPaths(agents, projectConfig, projectRoot2 = getProjectRoot()) {
+  const expected = /* @__PURE__ */ new Set();
+  for (const agent of agents) {
+    for (const agentTarget of agent.targets) {
+      const targetConfig = resolveTargetConfig(agentTarget, projectConfig);
+      if (!targetConfig) continue;
+      const ctx = { agent, projectRoot: projectRoot2, target: targetConfig };
+      expected.add(path25.resolve(getExporter(targetConfig).outputPath(ctx)));
+    }
+  }
+  return expected;
+}
+function resolveTargetConfig(agentTarget, projectConfig) {
+  const targetType = typeof agentTarget === "string" ? agentTarget : agentTarget.type;
+  return projectConfig.targets.find((t) => {
+    if (typeof t === "string") return t === targetType;
+    return t.type === targetType;
+  });
+}
+var path25;
+var init_generate = __esm({
+  "src/exporters/generate.ts"() {
+    "use strict";
+    path25 = __toESM(require("path"));
+    init_templates();
+    init_agent_resolver();
+    init_execution_profile();
+    init_budget_policy();
+    init_fs();
+    init_registry2();
+    init_base();
+  }
+});
+
 // src/core/stereotype-migration.ts
 function retireSpecialists(apply) {
   const components = loadComponentSpecs();
@@ -22924,12 +23188,12 @@ function digest(content) {
   return crypto3.createHash("sha256").update(normalized, "utf8").digest("hex");
 }
 function currentSpecDigests(root = getProjectRoot()) {
-  const mountDirs = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::")).map((s) => `${path22.resolve(root, s.projectPath).split(path22.sep).join("/")}/`);
+  const mountDirs = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::")).map((s) => `${path26.resolve(root, s.projectPath).split(path26.sep).join("/")}/`);
   const out = {};
   for (const [abs, content] of snapshotSpecFiles()) {
-    const normalized = path22.resolve(abs).split(path22.sep).join("/");
+    const normalized = path26.resolve(abs).split(path26.sep).join("/");
     if (mountDirs.some((dir) => normalized.startsWith(dir))) continue;
-    out[path22.relative(root, abs).split(path22.sep).join("/")] = digest(content);
+    out[path26.relative(root, abs).split(path26.sep).join("/")] = digest(content);
   }
   return out;
 }
@@ -22987,7 +23251,7 @@ function currentChildPins(mounts, root = getProjectRoot()) {
   const pins = {};
   for (const mount of mounts) {
     if (!mount.projectPath || mount.id.includes("::")) continue;
-    const child = readLockRecordAt(path22.resolve(root, mount.projectPath));
+    const child = readLockRecordAt(path26.resolve(root, mount.projectPath));
     if (child) pins[mount.id] = pinOf(child.stateId);
   }
   return pins;
@@ -23003,12 +23267,12 @@ function movedChildren(mounts, root = getProjectRoot()) {
   }
   return moved;
 }
-var crypto3, path22;
+var crypto3, path26;
 var init_approval = __esm({
   "src/core/approval.ts"() {
     "use strict";
     crypto3 = __toESM(require("crypto"));
-    path22 = __toESM(require("path"));
+    path26 = __toESM(require("path"));
     init_fs();
     init_specs2();
     init_lockfile();
@@ -23089,6 +23353,7 @@ var init_core = __esm({
     init_treetransfer();
     init_extensions();
     init_agent_resolver();
+    init_generate();
     init_treetransfer();
     init_provision();
     init_stereotype_migration();
@@ -23465,13 +23730,13 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
 function resolveThroughParent(boundRoot, treatAllAsComplete, childRules) {
   const reach = getRequestParentReach();
   if (reach && !reach.parentReach) return null;
-  const ceiling = reach?.topRoot ? path23.resolve(reach.topRoot) : void 0;
+  const ceiling = reach?.topRoot ? path27.resolve(reach.topRoot) : void 0;
   const chain = [];
-  let top = path23.resolve(boundRoot);
+  let top = path27.resolve(boundRoot);
   while (top !== ceiling) {
     const hop = findChainingParent(top, ceiling);
     if (!hop) break;
-    const next = path23.resolve(hop.parentRoot);
+    const next = path27.resolve(hop.parentRoot);
     if (ceiling && !isWithinOrEqual(ceiling, next)) break;
     chain.unshift(hop.subsystemId);
     top = next;
@@ -23518,8 +23783,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 = path23.relative(dir, target);
-  return rel2 === "" || !rel2.startsWith("..") && !path23.isAbsolute(rel2);
+  const rel2 = path27.relative(dir, target);
+  return rel2 === "" || !rel2.startsWith("..") && !path27.isAbsolute(rel2);
 }
 function dedupeIssues(list2) {
   const seen = /* @__PURE__ */ new Set();
@@ -23540,7 +23805,7 @@ function settledStatusBearing(loaded) {
   if (!settled || settled.size === 0) return [];
   const root = getProjectRoot();
   const index = scanAllSpecs();
-  const rel2 = (abs) => path23.relative(root, abs).split(path23.sep).join("/");
+  const rel2 = (abs) => path27.relative(root, abs).split(path27.sep).join("/");
   const out = [];
   const take = (specs, paths) => {
     for (const spec of specs) {
@@ -23570,7 +23835,7 @@ function computeGateStateId() {
   registerBuiltinRules();
   return computeGateIdentity(content, extensions, ruleSequence(), inputs, gate);
 }
-var path23, RESOLUTION_FAILURE_CODES, SEVERITY_RANK;
+var path27, RESOLUTION_FAILURE_CODES, SEVERITY_RANK;
 var init_validation = __esm({
   "src/core/validation.ts"() {
     "use strict";
@@ -23586,7 +23851,7 @@ var init_validation = __esm({
     init_source_analysis();
     init_specs2();
     init_fs();
-    path23 = __toESM(require("path"));
+    path27 = __toESM(require("path"));
     init_core();
     RESOLUTION_FAILURE_CODES = /* @__PURE__ */ new Set([
       "UNDEFINED_TYPE_REFERENCE",
@@ -24306,42 +24571,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 = path24.resolve(dir);
-  const f = path24.resolve(file);
-  return f === d || f.startsWith(d + path24.sep);
+  const d = path28.resolve(dir);
+  const f = path28.resolve(file);
+  return f === d || f.startsWith(d + path28.sep);
 }
 function canonicalPath(target) {
-  let existing = path24.resolve(target);
+  let existing = path28.resolve(target);
   const rest = [];
   for (; ; ) {
     try {
       fs18.lstatSync(existing);
       break;
     } catch {
-      const up = path24.dirname(existing);
-      if (up === existing) return path24.resolve(target);
-      rest.unshift(path24.basename(existing));
+      const up = path28.dirname(existing);
+      if (up === existing) return path28.resolve(target);
+      rest.unshift(path28.basename(existing));
       existing = up;
     }
   }
   try {
-    return path24.join(fs18.realpathSync.native(existing), ...rest);
+    return path28.join(fs18.realpathSync.native(existing), ...rest);
   } catch {
     return null;
   }
 }
 function chainDirKey(dir) {
-  return canonicalPath(dir) ?? path24.resolve(dir);
+  return canonicalPath(dir) ?? path28.resolve(dir);
 }
 function projectPathEscapesRoot(projectRoot2, projectPath, resolvedChildDir) {
-  if (path24.isAbsolute(projectPath) || !isWithin(projectRoot2, resolvedChildDir)) return true;
+  if (path28.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 = path24.resolve(projectRoot2);
-  const resolved = path24.resolve(root, projectPath);
+  const root = path28.resolve(projectRoot2);
+  const resolved = path28.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.`
@@ -24352,12 +24617,12 @@ function assertContainedProjectPath(projectRoot2, projectPath) {
 function findChainingParent(childRoot, ceiling) {
   let childResolved;
   try {
-    childResolved = path24.resolve(childRoot);
+    childResolved = path28.resolve(childRoot);
   } catch {
     return null;
   }
-  const bound2 = ceiling ? path24.resolve(ceiling) : void 0;
-  let dir = path24.dirname(childResolved);
+  const bound2 = ceiling ? path28.resolve(ceiling) : void 0;
+  let dir = path28.dirname(childResolved);
   for (let hops = 0; hops < 32; hops++) {
     if (bound2 && !isWithin(bound2, dir)) break;
     const specsDir = aiPathsAt(dir).specsDir();
@@ -24373,7 +24638,7 @@ function findChainingParent(childRoot, ceiling) {
           const projectPath = raw.projectPath;
           if (typeof projectPath === "string" && projectPath.trim() !== "") {
             try {
-              const mountDir = path24.resolve(dir, projectPath);
+              const mountDir = path28.resolve(dir, projectPath);
               if (mountDir === childResolved && !projectPathEscapesRoot(dir, projectPath, mountDir)) {
                 const id = raw.id;
                 return { parentRoot: dir, subsystemId: typeof id === "string" ? id : "?" };
@@ -24384,14 +24649,14 @@ function findChainingParent(childRoot, ceiling) {
         }
       }
     }
-    const up = path24.dirname(dir);
+    const up = path28.dirname(dir);
     if (up === dir) break;
     dir = up;
   }
   return null;
 }
 function inspectChainedRoots(rootDir = getProjectRoot()) {
-  const root = path24.resolve(rootDir);
+  const root = path28.resolve(rootDir);
   const inspection = { roots: [], skipped: [] };
   const listed = /* @__PURE__ */ new Set();
   const walk2 = (projectDir, prefix, ancestors, depth) => {
@@ -24410,7 +24675,7 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
       const localId = typeof id === "string" ? id : "?";
       let childDir;
       try {
-        childDir = path24.resolve(projectDir, projectPath);
+        childDir = path28.resolve(projectDir, projectPath);
       } catch {
         continue;
       }
@@ -24427,7 +24692,7 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
       const key = chainDirKey(childDir);
       if (listed.has(key)) continue;
       listed.add(key);
-      inspection.roots.push(path24.relative(root, childDir).split(path24.sep).join("/"));
+      inspection.roots.push(path28.relative(root, childDir).split(path28.sep).join("/"));
       walk2(childDir, prefix ? `${prefix}::${localId}` : localId, /* @__PURE__ */ new Set([...ancestors, key]), depth + 1);
     }
   };
@@ -24513,9 +24778,9 @@ function stripNamespaceFromImplementation(spec, prefix) {
 }
 function childRelativeFilePaths(spec, authoringRoot, childRoot) {
   const reexpress = (p) => {
-    if (path24.isAbsolute(p)) return p;
-    const rel2 = path24.relative(childRoot, path24.resolve(authoringRoot, p));
-    const inside = rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path24.sep}`) && !path24.isAbsolute(rel2);
+    if (path28.isAbsolute(p)) return p;
+    const rel2 = path28.relative(childRoot, path28.resolve(authoringRoot, p));
+    const inside = rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path28.sep}`) && !path28.isAbsolute(rel2);
     return inside ? rel2.replace(/\\/g, "/") : p;
   };
   return {
@@ -24550,9 +24815,9 @@ function findOwner(id, components) {
   }) ?? null;
 }
 function moveComponentFolder(fromDir, toDir) {
-  if (path24.normalize(fromDir) === path24.normalize(toDir)) return false;
+  if (path28.normalize(fromDir) === path28.normalize(toDir)) return false;
   if (!fs18.existsSync(fromDir) || fs18.existsSync(toDir)) return false;
-  ensureDir(path24.dirname(toDir));
+  ensureDir(path28.dirname(toDir));
   fs18.renameSync(fromDir, toDir);
   return true;
 }
@@ -24968,7 +25233,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 = path24.resolve(rootDir);
+  const key = path28.resolve(rootDir);
   let ws = workspaces.get(key);
   if (!ws) {
     ws = new SpecWorkspace(key);
@@ -25098,13 +25363,13 @@ function snapshotInputKey(snapshot) {
   return canonicalize(content);
 }
 function consumedSurfaceInputsAt(rootDir) {
-  const dir = path24.join(rootDir, ".wai", "surfaces");
+  const dir = path28.join(rootDir, ".wai", "surfaces");
   if (!pathExists(dir)) return [];
   const keys = [];
   for (const file of fs18.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      keys.push(snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path24.join(dir, file)))));
+      keys.push(snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path28.join(dir, file)))));
     } catch {
     }
   }
@@ -25112,7 +25377,7 @@ function consumedSurfaceInputsAt(rootDir) {
 }
 function consumedContractInputs() {
   const root = getProjectRoot();
-  const roots = [root, ...listChainedRoots(root).map((rel2) => path24.join(root, rel2))];
+  const roots = [root, ...listChainedRoots(root).map((rel2) => path28.join(root, rel2))];
   return roots.flatMap(consumedSurfaceInputsAt);
 }
 function readLockState(current2) {
@@ -25148,7 +25413,7 @@ function markSelectionsBundled(bundled) {
   projectConfigRepository.markSelectionsBundled(bundled);
 }
 function computeStateIdAt(root) {
-  const resolved = path24.resolve(root);
+  const resolved = path28.resolve(root);
   return runWithProjectRoot(resolved, () => {
     workspaceFor(resolved).invalidate();
     const system = loadSystemSpec();
@@ -25198,12 +25463,12 @@ function updateSpec(kind, id, delta, hooks, dryRun) {
 function moveMethods(from, to, methods, hooks, dryRun) {
   return current().moveMethods(from, to, methods, hooks, dryRun);
 }
-var fs18, path24, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, COMPONENT_AUTH_SOURCE, DELTA_VERBS, JUMP_LABEL_TWINS, LABEL_TWIN_CONTAINERS, SpecWorkspace, DEFAULT_DEPENDENCY_LIMIT, PROSE_FIELDS2, workspaces;
+var fs18, path28, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, COMPONENT_AUTH_SOURCE, DELTA_VERBS, JUMP_LABEL_TWINS, LABEL_TWIN_CONTAINERS, SpecWorkspace, DEFAULT_DEPENDENCY_LIMIT, PROSE_FIELDS2, workspaces;
 var init_specs2 = __esm({
   "src/core/specs.ts"() {
     "use strict";
     fs18 = __toESM(require("fs"));
-    path24 = __toESM(require("path"));
+    path28 = __toESM(require("path"));
     init_loader();
     init_project_config();
     init_fs();
@@ -25238,7 +25503,7 @@ var init_specs2 = __esm({
         this.rootSubsystems = /* @__PURE__ */ new Set();
         this.scanVisitedSpecDirs = [];
         this.loaderIssues = [];
-        this.rootDir = path24.resolve(rootDir);
+        this.rootDir = path28.resolve(rootDir);
         this.paths = aiPathsAt(this.rootDir);
       }
       invalidate() {
@@ -25281,8 +25546,8 @@ var init_specs2 = __esm({
        * qualifies the spec itself — so scoping a validate to a mount keeps it.
        */
       loaderIssueSpecId(file, rawId, namespacePrefix) {
-        const stem2 = path24.basename(file, ".yaml");
-        const local = rawId ?? (stem2.startsWith(".") ? path24.basename(path24.dirname(file)) : stem2);
+        const stem2 = path28.basename(file, ".yaml");
+        const local = rawId ?? (stem2.startsWith(".") ? path28.basename(path28.dirname(file)) : stem2);
         return namespacePrefix ? qualifyId(local, namespacePrefix, this.rootSubsystems) : local;
       }
       scanSpecsForProject(projectDir, namespacePrefix, visitedDirs, maxDepth, currentDepth) {
@@ -25292,10 +25557,10 @@ var init_specs2 = __esm({
         this.scanVisitedSpecDirs.push(specsDir);
         if (!pathExists(specsDir)) return index;
         const files = listSpecFiles(specsDir);
-        const systemYaml = path24.normalize(projectPaths.specsSystem());
+        const systemYaml = path28.normalize(projectPaths.specsSystem());
         const localSubprojects = [];
         for (const file of files) {
-          const normFile = path24.normalize(file);
+          const normFile = path28.normalize(file);
           if (normFile === systemYaml) continue;
           let detectedType = "spec";
           let rawId;
@@ -25339,7 +25604,7 @@ var init_specs2 = __esm({
             } else if ("contract" in raw) {
               detectedType = "implementation";
               const parsed = ImplementationSpecSchema.parse(raw);
-              const normalizeSourcePath = (p) => path24.relative(projectDir, path24.resolve(projectDir, p)).replace(/\\/g, "/");
+              const normalizeSourcePath = (p) => path28.relative(projectDir, path28.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);
@@ -25465,7 +25730,7 @@ var init_specs2 = __esm({
         }
         if (currentDepth < maxDepth) {
           for (const subproj of localSubprojects) {
-            const childDir = path24.resolve(projectDir, subproj.projectPath);
+            const childDir = path28.resolve(projectDir, subproj.projectPath);
             const mountId = namespacePrefix ? qualifyDeclaredId(subproj.subsystemId, namespacePrefix, true) : subproj.subsystemId;
             if (projectPathEscapesRoot(projectDir, subproj.projectPath, childDir)) {
               this.loaderIssues.push({
@@ -25528,7 +25793,7 @@ var init_specs2 = __esm({
           const index = this.scanAll();
           const sub = index.subsystems.find((s) => s.id === currentPrefix);
           if (sub && sub.projectPath) {
-            const nextDir = path24.resolve(currentDir, sub.projectPath);
+            const nextDir = path28.resolve(currentDir, sub.projectPath);
             if (projectPathEscapesRoot(currentDir, sub.projectPath, nextDir)) {
               this.loaderIssues.push({
                 severity: "error",
@@ -25580,9 +25845,9 @@ var init_specs2 = __esm({
           return index.paths.subsystem[matches[0]];
         }
         if (pathExists(this.paths.specsSubsystemsDir()) && listFiles(this.paths.specsSubsystemsDir(), ".yaml").length > 0) {
-          return path24.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
+          return path28.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
         }
-        return path24.join(this.paths.specsDir(), id, ".index.yaml");
+        return path28.join(this.paths.specsDir(), id, ".index.yaml");
       }
       getComponentPath(id, subsystemId) {
         const index = this.scanAll();
@@ -25602,21 +25867,21 @@ var init_specs2 = __esm({
         if (owner) {
           const ownerPath = index.paths.component[owner.id];
           if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-            return path24.join(path24.dirname(ownerPath), id, ".index.yaml");
+            return path28.join(path28.dirname(ownerPath), id, ".index.yaml");
           }
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path24.dirname(subPath);
+          const subDir = path28.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path24.join(subDir, id, ".index.yaml");
+            return path28.join(subDir, id, ".index.yaml");
           }
         }
         if (pathExists(this.paths.specsComponentsDir()) && listFiles(this.paths.specsComponentsDir(), ".yaml").length > 0) {
-          return path24.join(this.paths.specsComponentsDir(), `${id}.yaml`);
+          return path28.join(this.paths.specsComponentsDir(), `${id}.yaml`);
         }
         const targetSubsystem = subsystemId || "default";
-        return path24.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
+        return path28.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
       }
       getInterfacePath(id, componentId) {
         const index = this.scanAll();
@@ -25642,16 +25907,16 @@ var init_specs2 = __esm({
         }
         if (componentId) {
           const compPath = this.getComponentPath(componentId);
-          const compDir = path24.dirname(compPath);
+          const compDir = path28.dirname(compPath);
           if (compPath.endsWith(".index.yaml")) {
-            return path24.join(compDir, ".interface.yaml");
+            return path28.join(compDir, ".interface.yaml");
           }
         }
         if (pathExists(this.paths.specsInterfacesDir()) && listFiles(this.paths.specsInterfacesDir(), ".yaml").length > 0) {
-          return path24.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
+          return path28.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
         }
         const targetComponent = componentId || "default";
-        return path24.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
+        return path28.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
       }
       getImplementationPath(id, contractId) {
         const index = this.scanAll();
@@ -25677,16 +25942,16 @@ var init_specs2 = __esm({
         }
         if (contractId) {
           const intfPath = this.getInterfacePath(contractId);
-          const intfDir = path24.dirname(intfPath);
+          const intfDir = path28.dirname(intfPath);
           if (intfPath.endsWith(".interface.yaml")) {
-            return path24.join(intfDir, ".implementation.yaml");
+            return path28.join(intfDir, ".implementation.yaml");
           }
         }
         if (pathExists(this.paths.specsImplementationsDir()) && listFiles(this.paths.specsImplementationsDir(), ".yaml").length > 0) {
-          return path24.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
+          return path28.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
         }
         const targetContract = contractId ? contractId.replace(/^i/, "") : "default";
-        return path24.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
+        return path28.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
       }
       getTypePath(id, subsystemId, group) {
         const index = this.scanAll();
@@ -25717,7 +25982,7 @@ var init_specs2 = __esm({
           const groupPath = index.paths.group[targetGroup] || index.paths.group[plainGroup];
           if (groupPath) {
             const localId2 = id.split("::").pop();
-            return path24.join(path24.dirname(groupPath), `${localId2}.yaml`);
+            return path28.join(path28.dirname(groupPath), `${localId2}.yaml`);
           }
         }
         let localId = id;
@@ -25730,12 +25995,12 @@ var init_specs2 = __esm({
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path24.dirname(subPath);
+          const subDir = path28.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path24.join(subDir, "types", `${localId}.yaml`);
+            return path28.join(subDir, "types", `${localId}.yaml`);
           }
         }
-        return path24.join(this.paths.specsTypesDir(), `${localId}.yaml`);
+        return path28.join(this.paths.specsTypesDir(), `${localId}.yaml`);
       }
       getGroupPath(id, subsystemId) {
         const index = this.scanAll();
@@ -25769,12 +26034,12 @@ var init_specs2 = __esm({
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path24.dirname(subPath);
+          const subDir = path28.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path24.join(subDir, "types", localId, ".index.yaml");
+            return path28.join(subDir, "types", localId, ".index.yaml");
           }
         }
-        return path24.join(this.paths.specsTypesDir(), localId, ".index.yaml");
+        return path28.join(this.paths.specsTypesDir(), localId, ".index.yaml");
       }
       // -------------------------------------------------------------------------
       // Level 0: System
@@ -25797,7 +26062,7 @@ var init_specs2 = __esm({
       }
       saveSystemSpec(spec) {
         const p = this.paths.specsSystem();
-        ensureDir(path24.dirname(p));
+        ensureDir(path28.dirname(p));
         writeSpecFile(p, parseOrThrow(SystemSpecSchema, spec, "system", spec.name));
         invalidateSpecCache();
       }
@@ -25919,7 +26184,7 @@ var init_specs2 = __esm({
       }
       saveSubsystemSpec(spec, opts) {
         const p = this.getSubsystemPath(spec.id);
-        ensureDir(path24.dirname(p));
+        ensureDir(path28.dirname(p));
         const { prefix } = splitNamespace(spec.id);
         if (!prefix && spec.projectPath && spec.projectPath.trim() !== "") {
           assertContainedProjectPath(this.rootDir, spec.projectPath);
@@ -25986,7 +26251,7 @@ var init_specs2 = __esm({
       saveComponentSpec(spec, opts) {
         const notices = [];
         const p = this.getComponentPath(spec.id, spec.subsystem);
-        ensureDir(path24.dirname(p));
+        ensureDir(path28.dirname(p));
         const specToWrite = this.prepareComponentForWrite(spec);
         const existing = this.loadComponentSpec(spec.id);
         if (existing) {
@@ -26003,7 +26268,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 ${path24.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 ${path28.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();
@@ -26027,12 +26292,12 @@ var init_specs2 = __esm({
         if (owner) {
           const ownerPath = index.paths.component[owner.id];
           if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-            const ownerSubDir = path24.dirname(this.getSubsystemPath(owner.subsystem));
-            return path24.join(ownerSubDir, owner.id, comp.id);
+            const ownerSubDir = path28.dirname(this.getSubsystemPath(owner.subsystem));
+            return path28.join(ownerSubDir, owner.id, comp.id);
           }
         }
-        const subDir = path24.dirname(this.getSubsystemPath(comp.subsystem));
-        return path24.join(subDir, comp.id);
+        const subDir = path28.dirname(this.getSubsystemPath(comp.subsystem));
+        return path28.join(subDir, comp.id);
       }
       /**
        * Move component folders so the physical tree mirrors ownership: each owned
@@ -26048,7 +26313,7 @@ var init_specs2 = __esm({
           if (!currentPath) continue;
           const desiredDir = this.desiredComponentDir(comp, index);
           if (!desiredDir) continue;
-          if (moveComponentFolder(path24.dirname(currentPath), desiredDir)) moved.push(comp.id);
+          if (moveComponentFolder(path28.dirname(currentPath), desiredDir)) moved.push(comp.id);
         }
         if (moved.length) invalidateSpecCache();
         return moved;
@@ -26104,7 +26369,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 ${path24.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 ${path28.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. */
@@ -26112,12 +26377,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(path24.dirname(p));
+        ensureDir(path28.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 ${path24.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 ${path28.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) {
@@ -26174,12 +26439,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(path24.dirname(p));
+        ensureDir(path28.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 ${path24.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 ${path28.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) {
@@ -26220,11 +26485,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(path24.dirname(p));
+        ensureDir(path28.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 ${path24.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 ${path28.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")) {
@@ -26262,7 +26527,7 @@ var init_specs2 = __esm({
       }
       saveGroupSpec(spec, opts) {
         const p = this.getGroupPath(spec.id);
-        ensureDir(path24.dirname(p));
+        ensureDir(path28.dirname(p));
         const specToWrite = this.prepareGroupForWrite(spec);
         const existing = this.loadGroupSpec(spec.id);
         if (existing) {
@@ -26340,7 +26605,7 @@ var init_specs2 = __esm({
         };
         const out = /* @__PURE__ */ new Set();
         const add = (p) => {
-          if (p) out.add(path24.resolve(p));
+          if (p) out.add(path28.resolve(p));
         };
         for (const s of this.loadSubsystemSpecs()) {
           if (!scopeSubsystem || s.id === scopeSubsystem || s.id.startsWith(`${scopeSubsystem}::`)) {
@@ -26411,11 +26676,11 @@ var init_specs2 = __esm({
         const files = /* @__PURE__ */ new Set();
         const sysPath = this.paths.specsSystem();
         if (pathExists(sysPath)) {
-          files.add(path24.resolve(sysPath));
+          files.add(path28.resolve(sysPath));
         }
         for (const group of Object.values(index.paths)) {
           for (const file of Object.values(group)) {
-            files.add(path24.resolve(file));
+            files.add(path28.resolve(file));
           }
         }
         for (const file of files) {
@@ -26434,20 +26699,20 @@ var init_specs2 = __esm({
         const files = listSpecFiles(specsDir);
         const legacy = [];
         for (const f of files) {
-          const base = path24.basename(f);
-          const dir = path24.dirname(f);
+          const base = path28.basename(f);
+          const dir = path28.dirname(f);
           if (base === "system.yaml") {
-            legacy.push({ path: f, expected: path24.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path28.join(dir, ".index.yaml") });
           } else if (base === "subsystem.yaml") {
-            legacy.push({ path: f, expected: path24.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path28.join(dir, ".index.yaml") });
           } else if (base === "component.yaml") {
-            legacy.push({ path: f, expected: path24.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path28.join(dir, ".index.yaml") });
           } else if (base === "group.yaml") {
-            legacy.push({ path: f, expected: path24.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path28.join(dir, ".index.yaml") });
           } else if (base === "interface.yaml") {
-            legacy.push({ path: f, expected: path24.join(dir, ".interface.yaml") });
+            legacy.push({ path: f, expected: path28.join(dir, ".interface.yaml") });
           } else if (base === "implementation.yaml") {
-            legacy.push({ path: f, expected: path24.join(dir, ".implementation.yaml") });
+            legacy.push({ path: f, expected: path28.join(dir, ".implementation.yaml") });
           }
         }
         return legacy;
@@ -27459,7 +27724,7 @@ __export(agent_resolver_exports, {
 });
 function listFilesRecursiveSafe(dirPath, ext) {
   if (!fs19.existsSync(dirPath)) return [];
-  const nameLower = path25.basename(dirPath).toLowerCase();
+  const nameLower = path29.basename(dirPath).toLowerCase();
   const IGNORED_DIRS = /* @__PURE__ */ new Set([
     "node_modules",
     "target",
@@ -27477,7 +27742,7 @@ function listFilesRecursiveSafe(dirPath, ext) {
   const entries = fs19.readdirSync(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path25.join(dirPath, entry.name);
+    const fullPath = path29.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...listFilesRecursiveSafe(fullPath, ext));
     } else if (entry.isFile() && entry.name.endsWith(ext)) {
@@ -27490,8 +27755,8 @@ function getProjectFiles(projectDir) {
   let files = projectFilesCache.get(projectDir);
   if (!files) {
     files = [];
-    const srcDir = path25.join(projectDir, "src");
-    const legacySrcDir = path25.join(projectDir, "legacy-src");
+    const srcDir = path29.join(projectDir, "src");
+    const legacySrcDir = path29.join(projectDir, "legacy-src");
     let searchDir = projectDir;
     if (pathExists(srcDir)) {
       searchDir = srcDir;
@@ -27506,7 +27771,7 @@ function getProjectFiles(projectDir) {
       files.push(...listFilesRecursiveSafe(searchDir, ext));
     }
     const rootDir = getProjectRoot();
-    files = files.map((f) => path25.relative(rootDir, f).replace(/\\/g, "/"));
+    files = files.map((f) => path29.relative(rootDir, f).replace(/\\/g, "/"));
     projectFilesCache.set(projectDir, files);
   }
   return files;
@@ -27531,8 +27796,8 @@ function inferSourcePathForComponent(comp, subsystems) {
     let bestFile = null;
     let bestScore = -1;
     for (const f of files) {
-      const ext = path25.extname(f);
-      const base = path25.basename(f, ext).toLowerCase();
+      const ext = path29.extname(f);
+      const base = path29.basename(f, ext).toLowerCase();
       if (candidates.has(base)) {
         let score = 0;
         const normalizedPath = f.toLowerCase();
@@ -27629,7 +27894,7 @@ function resolveAgentTopology() {
   });
   for (const sub of subsystems) {
     if (sub.projectPath) {
-      const mountSpecPath = path25.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/");
+      const mountSpecPath = path29.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/");
       agents.push({
         id: `${sub.id}-owner`,
         name: `${sub.name} (chained subproject)`,
@@ -27651,9 +27916,9 @@ function resolveAgentTopology() {
     }
     const subComponents = components.filter((c) => c.subsystem === sub.id);
     const ownedPaths = [];
-    ownedPaths.push(path25.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/"));
+    ownedPaths.push(path29.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/"));
     for (const c of subComponents) {
-      ownedPaths.push(path25.relative(getProjectRoot(), getComponentPath(c.id, sub.id)).replace(/\\/g, "/"));
+      ownedPaths.push(path29.relative(getProjectRoot(), getComponentPath(c.id, sub.id)).replace(/\\/g, "/"));
     }
     if (!config.rules.generateComponentImplementers) {
       for (const comp of subComponents) {
@@ -27729,10 +27994,10 @@ function resolveAgentTopology() {
       }
       const dependencies = comp.dependsOn.map((depId) => `${depId}-implementer`);
       const readPaths = [
-        path25.relative(getProjectRoot(), AI_PATHS.specsSystem()).replace(/\\/g, "/"),
-        path25.relative(getProjectRoot(), getComponentPath(comp.id, comp.subsystem)).replace(/\\/g, "/"),
-        ...compInterfaces.map((i) => path25.relative(getProjectRoot(), getInterfacePath(i.id, comp.id)).replace(/\\/g, "/")),
-        ...compImpls.map((impl) => path25.relative(getProjectRoot(), getImplementationPath(impl.id, impl.contract)).replace(/\\/g, "/"))
+        path29.relative(getProjectRoot(), AI_PATHS.specsSystem()).replace(/\\/g, "/"),
+        path29.relative(getProjectRoot(), getComponentPath(comp.id, comp.subsystem)).replace(/\\/g, "/"),
+        ...compInterfaces.map((i) => path29.relative(getProjectRoot(), getInterfacePath(i.id, comp.id)).replace(/\\/g, "/")),
+        ...compImpls.map((impl) => path29.relative(getProjectRoot(), getImplementationPath(impl.id, impl.contract)).replace(/\\/g, "/"))
       ];
       agents.push({
         id: `${comp.id}-implementer`,
@@ -27821,11 +28086,11 @@ ${guidance.trim()}
     budget
   };
 }
-var path25, fs19, projectFilesCache, UnknownAgentError;
+var path29, fs19, projectFilesCache, UnknownAgentError;
 var init_agent_resolver = __esm({
   "src/core/agent_resolver.ts"() {
     "use strict";
-    path25 = __toESM(require("path"));
+    path29 = __toESM(require("path"));
     fs19 = __toESM(require("fs"));
     init_loader();
     init_project_config();
@@ -27859,12 +28124,12 @@ __export(loader_exports, {
   saveTopologyConfig: () => saveTopologyConfig
 });
 function aiPathsAt(rootDir) {
-  const resolvedRoot = path26.resolve(rootDir);
+  const resolvedRoot = path30.resolve(rootDir);
   const aiDirAt2 = (...segments) => {
-    const waiPath = path26.join(resolvedRoot, ".wai");
-    const waironPath = path26.join(resolvedRoot, ".wairon");
+    const waiPath = path30.join(resolvedRoot, ".wai");
+    const waironPath = path30.join(resolvedRoot, ".wairon");
     const base = !fs20.existsSync(waiPath) && fs20.existsSync(waironPath) ? waironPath : waiPath;
-    return path26.join(base, ...segments);
+    return path30.join(base, ...segments);
   };
   const specsDir = () => projectConfigRepositoryAt(resolvedRoot).specsDir();
   return {
@@ -27881,12 +28146,12 @@ function aiPathsAt(rootDir) {
     contextDomainsMd: () => aiDirAt2("context", "domains.md"),
     contextWaironGuideMd: () => aiDirAt2("context", "wairon-guide.md"),
     specsDir,
-    specsSystem: () => path26.join(specsDir(), ".index.yaml"),
-    specsSubsystemsDir: () => path26.join(specsDir(), "subsystems"),
-    specsComponentsDir: () => path26.join(specsDir(), "components"),
-    specsInterfacesDir: () => path26.join(specsDir(), "interfaces"),
-    specsImplementationsDir: () => path26.join(specsDir(), "implementations"),
-    specsTypesDir: () => path26.join(specsDir(), "types")
+    specsSystem: () => path30.join(specsDir(), ".index.yaml"),
+    specsSubsystemsDir: () => path30.join(specsDir(), "subsystems"),
+    specsComponentsDir: () => path30.join(specsDir(), "components"),
+    specsInterfacesDir: () => path30.join(specsDir(), "interfaces"),
+    specsImplementationsDir: () => path30.join(specsDir(), "implementations"),
+    specsTypesDir: () => path30.join(specsDir(), "types")
   };
 }
 function isProjectInitialized() {
@@ -27917,12 +28182,12 @@ function loadTopologyConfig() {
 function saveTopologyConfig(config) {
   writeYamlFile(AI_PATHS.topologyConfig(), config);
 }
-var fs20, path26, AI_PATHS;
+var fs20, path30, AI_PATHS;
 var init_loader = __esm({
   "src/config/loader.ts"() {
     "use strict";
     fs20 = __toESM(require("fs"));
-    path26 = __toESM(require("path"));
+    path30 = __toESM(require("path"));
     init_fs();
     init_yaml();
     init_errors();
@@ -29990,7 +30255,7 @@ async function scopeToClientWorkspace(server) {
     } catch {
       dir = null;
     }
-    if (dir && (fs21.existsSync(path28.join(dir, ".wai")) || fs21.existsSync(path28.join(dir, ".wairon")))) {
+    if (dir && (fs21.existsSync(path32.join(dir, ".wai")) || fs21.existsSync(path32.join(dir, ".wairon")))) {
       setProjectRoot(dir);
       process.stderr.write(`[wairon mcp] scoped to client workspace root: ${dir}
 `);
@@ -30014,7 +30279,7 @@ async function startMcpServer() {
   } catch {
   }
 }
-var import_mcp, import_stdio, import_zod11, import_types3, fs21, path28, import_url, TYPE_REF_GRAMMAR, staleServerOutput, SPEC_KINDS, STATUS_ORDER, specWriteReceiptOutput, specChangeOutput, specChangeReportOutput, validationIssueOutput, validateTreeOutput, getSpecOutput, SERVER_BUILD_STAMP, STALE_SERVER_WARNING, SPEC_WRITE_TOOLS, listChangedEmitters, STORE_MANAGED_FIELDS, statusInput, ALWAYS_CARRIED_FIELDS, SKILL_RESOURCE_MIME, AGENT_BRIEF_SCHEME;
+var import_mcp, import_stdio, import_zod11, import_types3, fs21, path32, import_url, TYPE_REF_GRAMMAR, staleServerOutput, SPEC_KINDS, STATUS_ORDER, specWriteReceiptOutput, specChangeOutput, specChangeReportOutput, validationIssueOutput, validateTreeOutput, getSpecOutput, SERVER_BUILD_STAMP, STALE_SERVER_WARNING, SPEC_WRITE_TOOLS, listChangedEmitters, STORE_MANAGED_FIELDS, statusInput, ALWAYS_CARRIED_FIELDS, SKILL_RESOURCE_MIME, AGENT_BRIEF_SCHEME;
 var init_server = __esm({
   "src/mcp/server.ts"() {
     "use strict";
@@ -30023,7 +30288,7 @@ var init_server = __esm({
     import_zod11 = require("zod");
     import_types3 = require("@modelcontextprotocol/sdk/types.js");
     fs21 = __toESM(require("fs"));
-    path28 = __toESM(require("path"));
+    path32 = __toESM(require("path"));
     import_url = require("url");
     init_fs();
     init_yaml();
@@ -30197,18 +30462,18 @@ __export(mcp_exports, {
   validateConfigDir: () => validateConfigDir
 });
 function geminiGlobalDir(override) {
-  return override || process.env["GEMINI_CONFIG_DIR"] || path29.join(os7.homedir(), ".gemini");
+  return override || process.env["GEMINI_CONFIG_DIR"] || path33.join(os7.homedir(), ".gemini");
 }
 function claudeMcpConfigPath(useGlobal, override) {
-  if (!useGlobal) return path29.join(process.cwd(), ".mcp.json");
+  if (!useGlobal) return path33.join(process.cwd(), ".mcp.json");
   const dir = override || process.env["CLAUDE_CONFIG_DIR"];
-  return dir ? path29.join(dir, ".claude.json") : path29.join(os7.homedir(), ".claude.json");
+  return dir ? path33.join(dir, ".claude.json") : path33.join(os7.homedir(), ".claude.json");
 }
 function validateConfigDir(dir, backend) {
-  const resolved = path29.resolve(dir);
+  const resolved = path33.resolve(dir);
   const agent = backend === "claude" ? "Claude" : "Gemini/Antigravity";
   if (!fs22.existsSync(resolved)) {
-    const parent = path29.dirname(resolved);
+    const parent = path33.dirname(resolved);
     if (!fs22.existsSync(parent)) {
       throw new WaironError(`--config-dir "${dir}" does not exist and its parent is missing \u2014 check the path.`);
     }
@@ -30224,7 +30489,7 @@ function validateConfigDir(dir, backend) {
     logger.warn(`Config dir "${resolved}" is empty; proceeding (treating it as a fresh ${agent} config dir).`);
     return;
   }
-  if (!markers.some((m) => fs22.existsSync(path29.join(resolved, m)))) {
+  if (!markers.some((m) => fs22.existsSync(path33.join(resolved, m)))) {
     throw new WaironError(
       `"${dir}" does not look like a ${agent} config directory (none of ${markers.slice(0, 4).join(", ")} found). Point --config-dir at the agent's config directory.`
     );
@@ -30232,12 +30497,12 @@ function validateConfigDir(dir, backend) {
 }
 async function runMcpServe() {
   const { setProjectRoot: setProjectRoot2, getProjectRoot: getProjectRoot2, findProjectRoot: findProjectRoot2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-  const cwd = path29.resolve(process.cwd());
+  const cwd = path33.resolve(process.cwd());
   const envDir = process.env["WAIRON_PROJECT_DIR"];
   let resolved;
   let how;
-  if (envDir && fs22.existsSync(path29.join(envDir, ".wai"))) {
-    resolved = path29.resolve(envDir);
+  if (envDir && fs22.existsSync(path33.join(envDir, ".wai"))) {
+    resolved = path33.resolve(envDir);
     how = "WAIRON_PROJECT_DIR (pinned at install)";
   } else {
     const found = findProjectRoot2(cwd);
@@ -30263,10 +30528,10 @@ async function runMcpServe() {
 }
 function mcpConfigCandidates(cwd) {
   return [
-    path29.join(cwd, ".mcp.json"),
+    path33.join(cwd, ".mcp.json"),
     claudeMcpConfigPath(true),
-    path29.join(cwd, ".gemini", "settings.json"),
-    path29.join(geminiGlobalDir(), "antigravity-cli", "mcp_config.json")
+    path33.join(cwd, ".gemini", "settings.json"),
+    path33.join(geminiGlobalDir(), "antigravity-cli", "mcp_config.json")
   ];
 }
 function detectHostedMcpSource(cwd = process.cwd()) {
@@ -30353,15 +30618,15 @@ async function runMcpInstall(options = {}) {
     let settingsPath;
     if (backend === "gemini") {
       if (useGlobal) {
-        configBase = path29.join(geminiGlobalDir(options.configDir), "antigravity-cli");
-        settingsPath = path29.join(configBase, "mcp_config.json");
+        configBase = path33.join(geminiGlobalDir(options.configDir), "antigravity-cli");
+        settingsPath = path33.join(configBase, "mcp_config.json");
       } else {
-        configBase = path29.join(process.cwd(), ".gemini");
-        settingsPath = path29.join(configBase, "settings.json");
+        configBase = path33.join(process.cwd(), ".gemini");
+        settingsPath = path33.join(configBase, "settings.json");
       }
     } else {
       settingsPath = claudeMcpConfigPath(useGlobal, options.configDir);
-      configBase = path29.dirname(settingsPath);
+      configBase = path33.dirname(settingsPath);
     }
     let settings = {};
     if (fs22.existsSync(settingsPath)) {
@@ -30374,7 +30639,7 @@ async function runMcpInstall(options = {}) {
     const mcpServers = settings["mcpServers"] ?? {};
     const agentLabel = backend === "gemini" ? "Antigravity" : "Claude";
     const isPackaged = typeof process.pkg !== "undefined";
-    const scriptPath = process.argv[1] ? path29.resolve(process.argv[1]).replace(/\\/g, "/") : null;
+    const scriptPath = process.argv[1] ? path33.resolve(process.argv[1]).replace(/\\/g, "/") : null;
     const useDirectNode = !isPackaged && scriptPath && (scriptPath.endsWith(".js") || scriptPath.endsWith(".ts"));
     const env = useGlobal ? {} : { WAIRON_PROJECT_DIR: process.cwd().replace(/\\/g, "/") };
     const desiredEntry = options.hostedUrl ? hostedMcpEntry(options) : useDirectNode ? { command: "node", args: [scriptPath, "mcp", "serve"], env } : { command: "wairon", args: ["mcp", "serve"], env };
@@ -30413,8 +30678,8 @@ async function runMcpStatus() {
   if (!projectConfig) throw new ProjectNotInitializedError();
   const claudeProject = claudeMcpConfigPath(false);
   const claudeGlobal = claudeMcpConfigPath(true);
-  const geminiProject = path29.join(process.cwd(), ".gemini", "settings.json");
-  const geminiGlobal = path29.join(geminiGlobalDir(), "antigravity-cli", "mcp_config.json");
+  const geminiProject = path33.join(process.cwd(), ".gemini", "settings.json");
+  const geminiGlobal = path33.join(geminiGlobalDir(), "antigravity-cli", "mcp_config.json");
   logger.blank();
   logger.info(`${import_chalk5.default.bold("wairon MCP Server")}`);
   logger.blank();
@@ -30464,7 +30729,7 @@ function hostedMcpEntry(options) {
 }
 function removeLegacyGlobalPlugin() {
   const home = process.env["USERPROFILE"] ?? process.env["HOME"] ?? os7.homedir();
-  const pluginDir = path29.join(home, ".gemini", "config", "plugins", "wairon");
+  const pluginDir = path33.join(home, ".gemini", "config", "plugins", "wairon");
   try {
     if (fs22.existsSync(pluginDir)) {
       fs22.rmSync(pluginDir, { recursive: true, force: true });
@@ -30476,13 +30741,13 @@ function removeLegacyGlobalPlugin() {
   }
   return false;
 }
-var fs22, os7, path29, import_chalk5;
+var fs22, os7, path33, import_chalk5;
 var init_mcp = __esm({
   "src/commands/mcp.ts"() {
     "use strict";
     fs22 = __toESM(require("fs"));
     os7 = __toESM(require("os"));
-    path29 = __toESM(require("path"));
+    path33 = __toESM(require("path"));
     import_chalk5 = __toESM(require("chalk"));
     init_logger();
     init_loader();
@@ -30726,7 +30991,7 @@ function isSupportedAlias(name) {
 }
 
 // src/commands/init.ts
-var path30 = __toESM(require("path"));
+var path34 = __toESM(require("path"));
 var import_chalk6 = __toESM(require("chalk"));
 var import_inquirer = __toESM(require("inquirer"));
 init_logger();
@@ -30737,12 +31002,13 @@ init_yaml();
 init_loader();
 
 // src/commands/subsystem.ts
-var path27 = __toESM(require("path"));
+var path31 = __toESM(require("path"));
 init_logger();
 init_errors();
 init_fs();
 init_core();
 init_core();
+init_core();
 function composeAgentBrief2(agentId) {
   return composeAgentBrief(agentId);
 }
@@ -30791,6 +31057,15 @@ function defaultPackSelections2() {
 function readLockState2(current2) {
   return readLockState(current2);
 }
+function renderDiagram2(format) {
+  return renderDiagram(format);
+}
+function generateAll2(agents, config, options) {
+  return generateAll(agents, config, options);
+}
+function resolveExpectedOutputPaths2(agents, config) {
+  return resolveExpectedOutputPaths(agents, config);
+}
 async function runSubsystemAdd(id, options = {}) {
   logger.header("wairon subsystem add");
   if (!projectConfigExists2()) {
@@ -30820,9 +31095,9 @@ async function runSubsystemAdd(id, options = {}) {
     updatedAt: now
   };
   createChainedSubsystem2(subsystem, displayName);
-  const childDir = path27.resolve(getProjectRoot(), options.projectPath);
+  const childDir = path31.resolve(getProjectRoot(), options.projectPath);
   logger.success(`Added external subsystem "${id}" \u2192 ${options.projectPath}`);
-  logger.info(`Scaffolded child project at ${path27.relative(process.cwd(), childDir) || "."}`);
+  logger.info(`Scaffolded child project at ${path31.relative(process.cwd(), childDir) || "."}`);
   logger.info(`Design its spec tree from this parent using namespaced ids (e.g. ${id}::<component>).`);
 }
 async function runSubsystemMove(id, options = {}) {
@@ -30845,9 +31120,9 @@ async function runSubsystemExternalize(id, options = {}) {
     throw new WaironError("--project-path (the subproject destination) is required.");
   }
   externalizeSubsystem(id, options.projectPath);
-  const childDir = path27.resolve(getProjectRoot(), options.projectPath);
+  const childDir = path31.resolve(getProjectRoot(), options.projectPath);
   logger.success(`Externalized subsystem "${id}" \u2192 ${options.projectPath}`);
-  logger.info(`Moved its specs into ${path27.relative(process.cwd(), childDir) || "."} (now a standalone subproject).`);
+  logger.info(`Moved its specs into ${path31.relative(process.cwd(), childDir) || "."} (now a standalone subproject).`);
   logger.info("Move the source code there yourself, then run `wairon validate` to confirm the tree.");
 }
 async function runSubsystemInternalize(id) {
@@ -30904,7 +31179,7 @@ async function runInit(options = {}) {
   logger.header("wairon init");
   const cwd = process.cwd();
   const ancestorRoot = findSystemRoot(cwd);
-  if (ancestorRoot && path30.resolve(ancestorRoot) === path30.resolve(cwd)) {
+  if (ancestorRoot && path34.resolve(ancestorRoot) === path34.resolve(cwd)) {
     logger.info("Project already initialized.");
     logger.info("Design your spec tree with the SDD architect skill, then run `wairon generate`.");
     return;
@@ -30920,8 +31195,8 @@ async function runInit(options = {}) {
   await runInitInteractive();
 }
 async function runInitAsExternalSubsystem(parentRoot, cwd, options) {
-  const relPath = path30.relative(parentRoot, cwd) || ".";
-  const defaultId = path30.basename(cwd);
+  const relPath = path34.relative(parentRoot, cwd) || ".";
+  const defaultId = path34.basename(cwd);
   logger.info(`Detected a parent wairon project at ${parentRoot}`);
   logger.info(`This directory ("${relPath}") is not yet a wairon project.`);
   if (!options.yes) {
@@ -30981,7 +31256,7 @@ async function runInitAsExternalSubsystem(parentRoot, cwd, options) {
 }
 async function runInitNonInteractive() {
   const cwd = process.cwd();
-  const projectName = path30.basename(cwd);
+  const projectName = path34.basename(cwd);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const targets = [defaultTargetConfig("claude"), defaultTargetConfig("agy")];
   const projectConfig = buildProjectConfig(projectName, targets, now, "backend");
@@ -31001,7 +31276,7 @@ async function runInitNonInteractive() {
 }
 async function runInitInteractive() {
   const cwd = process.cwd();
-  const defaultProjectName = path30.basename(cwd);
+  const defaultProjectName = path34.basename(cwd);
   const { projectName } = await import_inquirer.default.prompt([
     {
       type: "input",
@@ -31146,7 +31421,7 @@ async function executeInit(projectName, projectConfig, guidePlan) {
   if (guidePlan.claudeLocal) {
     const p = localGuideFilePath(projectRoot2, "claude");
     injectGuide(p, "local");
-    logger.success(`Injected wairon guide into ${path30.relative(cwd, p)}`);
+    logger.success(`Injected wairon guide into ${path34.relative(cwd, p)}`);
     writeRootGuideDelegator(projectRoot2, "claude");
     logger.success(`Created root CLAUDE.md delegator pointing to .claude/CLAUDE.md`);
   }
@@ -31158,7 +31433,7 @@ async function executeInit(projectName, projectConfig, guidePlan) {
   if (guidePlan.geminiLocal) {
     const p = localGuideFilePath(projectRoot2, "gemini");
     injectGuide(p, "local");
-    logger.success(`Injected wairon guide into ${path30.relative(cwd, p)}`);
+    logger.success(`Injected wairon guide into ${path34.relative(cwd, p)}`);
     writeRootGuideDelegator(projectRoot2, "gemini");
     logger.success(`Created root GEMINI.md delegator pointing to .gemini/GEMINI.md`);
   }
@@ -31378,232 +31653,7 @@ var path35 = __toESM(require("path"));
 init_logger();
 init_loader();
 init_errors();
-
-// src/exporters/generate.ts
-var path34 = __toESM(require("path"));
-init_core();
-init_execution_profile();
-init_budget_policy();
-init_fs();
-
-// src/exporters/claude.ts
-var path31 = __toESM(require("path"));
-init_fs();
-var MODEL_BY_TIER = {
-  small: "haiku",
-  standard: "sonnet",
-  large: "opus",
-  frontier: "fable"
-};
-var TOOLS_BY_CLASS = {
-  "read-only": ["Read", "Grep", "Glob"],
-  implement: ["Read", "Grep", "Glob", "Edit", "Write", "Bash"],
-  orchestrate: ["Agent", "SendMessage", "TodoWrite"],
-  // `full` means "inherit everything" — expressed by omitting the field.
-  full: void 0
-};
-function toolsFor(budget) {
-  const base = TOOLS_BY_CLASS[budget.toolClass];
-  if (!base) return void 0;
-  if (budget.allowNestedDelegation && !base.includes("Agent")) {
-    return [...base, "Agent"];
-  }
-  if (!budget.allowNestedDelegation) {
-    return base.filter((t) => t !== "Agent");
-  }
-  return base;
-}
-function mcpServersFor(access) {
-  return access === "none" ? "[]" : void 0;
-}
-function yamlScalar(value) {
-  return /[:#\n]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
-}
-var ClaudeExporter = class {
-  constructor(options = {}) {
-    this.options = options;
-    this.targetType = "claude";
-  }
-  outputPath(ctx) {
-    const { agent, target, projectRoot: projectRoot2 } = ctx;
-    const outputDir = "outputDir" in target ? target.outputDir : ".claude/agents";
-    return path31.resolve(projectRoot2, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
-  }
-  export(ctx) {
-    const { agent, renderedInstructions, budget } = ctx;
-    const filePath = this.outputPath(ctx);
-    const frontmatter = [
-      `name: ${agent.name}`,
-      `description: ${yamlScalar(agent.description)}`
-    ];
-    if (budget && this.options.emitBudget) {
-      if (budget.modelTier) frontmatter.push(`model: ${MODEL_BY_TIER[budget.modelTier]}`);
-      if (budget.effort) frontmatter.push(`effort: ${budget.effort}`);
-      if (budget.maxTurns !== void 0) frontmatter.push(`maxTurns: ${budget.maxTurns}`);
-      const tools = toolsFor(budget);
-      if (tools) frontmatter.push(`tools: ${tools.join(", ")}`);
-      const servers = mcpServersFor(budget.mcp);
-      if (servers) frontmatter.push(`mcpServers: ${servers}`);
-    }
-    const content = ["---", ...frontmatter, "---", "", renderedInstructions, ""].join("\n");
-    const changed = writeFileIfChanged(filePath, content);
-    return { outputPath: filePath, content, unchanged: !changed };
-  }
-};
-
-// src/exporters/custom.ts
-var path32 = __toESM(require("path"));
-init_fs();
-var CustomExporter = class {
-  constructor() {
-    this.targetType = "custom";
-  }
-  outputPath(ctx) {
-    const { agent, target, projectRoot: projectRoot2 } = ctx;
-    if (!("outputDir" in target)) {
-      throw new Error("CustomExporter requires target.outputDir");
-    }
-    return path32.resolve(projectRoot2, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
-  }
-  export(ctx) {
-    const { agent, target, renderedInstructions } = ctx;
-    const label = "label" in target ? target.label : "Custom";
-    const filePath = this.outputPath(ctx);
-    const content = [
-      "---",
-      `name: ${agent.name}`,
-      `description: ${agent.description}`,
-      `id: ${agent.id}`,
-      `target: ${label}`,
-      "---",
-      "",
-      renderedInstructions,
-      ""
-    ].join("\n");
-    const changed = writeFileIfChanged(filePath, content);
-    return { outputPath: filePath, content, unchanged: !changed };
-  }
-};
-
-// src/exporters/gemini.ts
-var path33 = __toESM(require("path"));
-init_fs();
-var GeminiExporter = class {
-  constructor() {
-    this.targetType = "gemini";
-  }
-  outputPath(ctx) {
-    const { agent, target, projectRoot: projectRoot2 } = ctx;
-    const outputDir = "outputDir" in target ? target.outputDir : ".gemini/agents";
-    return path33.resolve(projectRoot2, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
-  }
-  export(ctx) {
-    const { agent, renderedInstructions } = ctx;
-    const filePath = this.outputPath(ctx);
-    const indentedInstructions = renderedInstructions.split("\n").map((line2) => line2.length > 0 ? `  ${line2}` : "").join("\n");
-    const content = [
-      `name: ${yamlString(agent.name)}`,
-      `description: ${yamlString(agent.description)}`,
-      `system_prompt: |`,
-      indentedInstructions,
-      ""
-    ].join("\n");
-    const changed = writeFileIfChanged(filePath, content);
-    return { outputPath: filePath, content, unchanged: !changed };
-  }
-};
-function yamlString(value) {
-  if (/[:#\[\]{},&*!|>'"%@`]/.test(value) || value.startsWith(" ") || value.endsWith(" ")) {
-    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-  }
-  return value;
-}
-
-// src/exporters/registry.ts
-init_errors();
-var EXPORTERS = /* @__PURE__ */ new Map([
-  ["claude", new ClaudeExporter({ emitBudget: true })],
-  ["gemini", new GeminiExporter()],
-  ["agy", new GeminiExporter()],
-  ["cursor", new ClaudeExporter()],
-  ["copilot", new ClaudeExporter()],
-  ["codex", new ClaudeExporter()],
-  ["custom", new CustomExporter()]
-]);
-function getExporter(target) {
-  const type = typeof target === "string" ? target : target.type;
-  const exporter = EXPORTERS.get(type);
-  if (!exporter) {
-    throw new WaironError(`No exporter registered for target type: "${type}"`);
-  }
-  return exporter;
-}
-
-// src/exporters/base.ts
-var WAIRON_MANAGED_MARKER = "wairon:managed";
-var WAIRON_MANAGED_BANNER = `<!-- ${WAIRON_MANAGED_MARKER} \u2014 generated by \`wairon generate\`; do not edit, changes are overwritten -->`;
-
-// src/exporters/generate.ts
-function generateAgent(agent, projectConfig, options = {}) {
-  const projectRoot2 = options.projectRoot ?? getProjectRoot();
-  const template = loadTemplate(agent.template, projectConfig.globalTemplatesDir);
-  const rendered = `${WAIRON_MANAGED_BANNER}
-${composeAgentBrief(agent.id).instructions}`;
-  const results = [];
-  const budget = resolveBudget(
-    deriveExecutionProfile(agent),
-    projectConfig.execution,
-    agent.id
-  );
-  for (const agentTarget of agent.targets) {
-    const targetConfig = resolveTargetConfig(agentTarget, projectConfig);
-    if (!targetConfig) continue;
-    if (options.filterTargets) {
-      const type = "type" in targetConfig ? targetConfig.type : targetConfig;
-      if (!options.filterTargets.includes(type)) continue;
-    }
-    if (!options.dryRun) {
-      results.push(getExporter(targetConfig).export({
-        agent,
-        template,
-        renderedInstructions: rendered,
-        projectRoot: projectRoot2,
-        target: targetConfig,
-        budget
-      }));
-    }
-  }
-  return { agent, results };
-}
-function generateAll(agents, projectConfig, options = {}) {
-  let pool = agents;
-  if (options.filterDomainIds && options.filterDomainIds.length > 0) {
-    const ids = new Set(options.filterDomainIds);
-    pool = agents.filter((a) => ids.has(a.domainRoot ?? "root"));
-  }
-  return pool.map((agent) => generateAgent(agent, projectConfig, options));
-}
-function resolveExpectedOutputPaths(agents, projectConfig, projectRoot2 = getProjectRoot()) {
-  const expected = /* @__PURE__ */ new Set();
-  for (const agent of agents) {
-    for (const agentTarget of agent.targets) {
-      const targetConfig = resolveTargetConfig(agentTarget, projectConfig);
-      if (!targetConfig) continue;
-      const ctx = { agent, projectRoot: projectRoot2, target: targetConfig };
-      expected.add(path34.resolve(getExporter(targetConfig).outputPath(ctx)));
-    }
-  }
-  return expected;
-}
-function resolveTargetConfig(agentTarget, projectConfig) {
-  const targetType = typeof agentTarget === "string" ? agentTarget : agentTarget.type;
-  return projectConfig.targets.find((t) => {
-    if (typeof t === "string") return t === targetType;
-    return t.type === targetType;
-  });
-}
-
-// src/commands/generate.ts
+init_base();
 init_context();
 init_fs();
 init_project();
@@ -31666,7 +31716,7 @@ async function generateLayer(options = {}) {
   } else if (options.dryRun) {
     logger.info("Dry run \u2014 rules.materializeAgentFiles is off: no agent files are written; leftover managed files would be removed.");
   } else if (options.prune !== false) {
-    const candidateDirs = [...resolveExpectedOutputPaths(agents, projectConfig)].map((p) => path35.dirname(p));
+    const candidateDirs = [...resolveExpectedOutputPaths2(agents, projectConfig)].map((p) => path35.dirname(p));
     const removed = pruneStaleAgents(/* @__PURE__ */ new Set(), candidateDirs);
     if (removed > 0) {
       logger.info(`Removed ${removed} previously materialized agent file(s) \u2014 agents are served as live briefs (sdd_get_agent_brief); opt back in with rules.materializeAgentFiles: true.`);
@@ -31710,7 +31760,7 @@ function materializeAgentLayer(agents, projectConfig, options) {
   }
   logger.info(`Generating ${agentPool.length} agent(s)...`);
   logger.blank();
-  const summaries = generateAll(agents, projectConfig, {
+  const summaries = generateAll2(agents, projectConfig, {
     filterTargets,
     filterDomainIds,
     dryRun: options.dryRun
@@ -31734,7 +31784,7 @@ function materializeAgentLayer(agents, projectConfig, options) {
   }
   let prunedCount = 0;
   if (!options.dryRun && options.prune !== false) {
-    prunedCount = pruneStaleAgents(resolveExpectedOutputPaths(agents, projectConfig));
+    prunedCount = pruneStaleAgents(resolveExpectedOutputPaths2(agents, projectConfig));
   }
   logger.blank();
   if (options.dryRun) {
@@ -33240,10 +33290,6 @@ var path39 = __toESM(require("path"));
 init_logger();
 init_loader();
 init_fs();
-init_diagram();
-init_canvas();
-init_diagram_export();
-init_validation();
 init_errors();
 var FORMATS = ["mermaid", "canvas", "drawio", "excalidraw"];
 function applyFormat(options) {
@@ -33260,18 +33306,9 @@ function applyFormat(options) {
     // mermaid is the default path — no flag needed
   };
 }
-function collectIssues() {
-  try {
-    const config = loadProjectConfig4();
-    if (config) return validateSddTree({ rules: config.rules, projectType: config.projectType }).issues;
-  } catch {
-  }
-  return validateSddTree().issues;
-}
-function writeCanvas(dest) {
-  const model = buildCanvasModel(collectIssues());
+function writeArtifact(dest, content) {
   ensureDir(path39.dirname(path39.resolve(dest)));
-  fs27.writeFileSync(dest, renderCanvasHtml(model), "utf-8");
+  fs27.writeFileSync(dest, content, "utf-8");
 }
 function parseSequenceRef(ref) {
   const sep9 = ref.includes(":") ? ref.lastIndexOf(":") : ref.lastIndexOf(".");
@@ -33287,23 +33324,21 @@ async function runDiagram(rawOptions = {}) {
   const options = applyFormat(rawOptions);
   if (options.canvas && !options.all) {
     const dest2 = options.out ?? path39.join(AI_PATHS.docsDir(), "diagrams", "canvas.html");
-    writeCanvas(dest2);
+    writeArtifact(dest2, renderDiagram2("canvas"));
     logger.success(`Interactive canvas written to ${dest2}`);
     logger.info("Open it in a browser \u2014 fully self-contained (works offline).");
     return;
   }
   if (options.drawio && !options.all) {
     const dest2 = options.out ?? path39.join(AI_PATHS.docsDir(), "diagrams", "architecture.drawio");
-    ensureDir(path39.dirname(path39.resolve(dest2)));
-    fs27.writeFileSync(dest2, generateDrawioXml(buildCanvasModel()), "utf-8");
+    writeArtifact(dest2, renderDiagram2("drawio"));
     logger.success(`draw.io diagram written to ${dest2}`);
     logger.info("Open with draw.io / diagrams.net (or import into tools that accept the format).");
     return;
   }
   if (options.excalidraw && !options.all) {
     const dest2 = options.out ?? path39.join(AI_PATHS.docsDir(), "diagrams", "architecture.excalidraw");
-    ensureDir(path39.dirname(path39.resolve(dest2)));
-    fs27.writeFileSync(dest2, generateExcalidrawScene(buildCanvasModel()), "utf-8");
+    writeArtifact(dest2, renderDiagram2("excalidraw"));
     logger.success(`Excalidraw scene written to ${dest2}`);
     logger.info("Open with excalidraw.com or the VS Code extension.");
     return;
@@ -33311,7 +33346,7 @@ async function runDiagram(rawOptions = {}) {
   const wantsMermaid = options.format?.toLowerCase().startsWith("mermaid") || !!options.subsystem || !!options.sequence;
   if (!options.all && !options.sequence && !wantsMermaid) {
     const dest2 = options.out ?? path39.join(AI_PATHS.docsDir(), "diagrams", "canvas.html");
-    writeCanvas(dest2);
+    writeArtifact(dest2, renderDiagram2("canvas"));
     logger.success(`Interactive canvas written to ${dest2}`);
     logger.info("Open it in a browser \u2014 fully self-contained (works offline). Other formats: --format mermaid|drawio|excalidraw.");
     return;
@@ -33324,17 +33359,14 @@ async function runDiagram(rawOptions = {}) {
       return;
     }
     for (const file of files) {
-      const dest2 = path39.join(outDir, file.relPath);
-      ensureDir(path39.dirname(dest2));
-      fs27.writeFileSync(dest2, toMarkdown(file), "utf-8");
-    }
-    writeCanvas(path39.join(outDir, "canvas.html"));
-    const exportModel = buildCanvasModel();
-    fs27.writeFileSync(path39.join(outDir, "architecture.drawio"), generateDrawioXml(exportModel), "utf-8");
-    fs27.writeFileSync(path39.join(outDir, "architecture.excalidraw"), generateExcalidrawScene(exportModel), "utf-8");
+      writeArtifact(path39.join(outDir, file.relPath), toMarkdown(file));
+    }
+    writeArtifact(path39.join(outDir, "canvas.html"), renderDiagram2("canvas"));
+    writeArtifact(path39.join(outDir, "architecture.drawio"), renderDiagram2("drawio"));
+    writeArtifact(path39.join(outDir, "architecture.excalidraw"), renderDiagram2("excalidraw"));
     const graph = loadSpecGraph();
     const indexPath = path39.join(outDir, "README.md");
-    fs27.writeFileSync(indexPath, diagramSetIndex(files, graph.systemName), "utf-8");
+    writeArtifact(indexPath, diagramSetIndex(files, graph.systemName));
     logger.success(`Generated ${files.length} diagram(s) + interactive canvas.html + index into ${outDir}`);
     for (const file of files.slice(0, 12)) {
       logger.info(`  ${file.relPath}`);
@@ -33356,15 +33388,14 @@ async function runDiagram(rawOptions = {}) {
     title = `${options.subsystem} \u2014 components`;
     defaultDest = path39.join(diagramsDir, "subsystems", `${options.subsystem.replace(/::/g, "--")}.md`);
   } else {
-    mermaid = generateComponentDiagram();
+    mermaid = renderDiagram2("mermaid");
     title = "Component architecture";
     defaultDest = path39.join(diagramsDir, "system.md");
   }
   const dest = options.out ?? defaultDest;
-  ensureDir(path39.dirname(path39.resolve(dest)));
   const content = dest.endsWith(".mmd") ? `${mermaid}
 ` : toMarkdown({ relPath: dest, title, mermaid });
-  fs27.writeFileSync(dest, content, "utf-8");
+  writeArtifact(dest, content);
   logger.success(`Mermaid diagram written to ${dest}`);
   logger.info("Renders on GitHub/IDE previews; use a .mmd --out path for raw Mermaid.");
 }
@@ -46597,7 +46628,6 @@ function startHostServer(cfg) {
 
 // src/commands/host.ts
 init_fs();
-init_canvas();
 
 // src/core/demo-seed.ts
 init_specs2();
@@ -47292,7 +47322,7 @@ async function runHostDemo(options = {}) {
     const rec = createProject(cfg, cred, id, unitId);
     const summary = runWithProjectRoot(rec.rootPath, () => {
       seedDemoTree();
-      const model = buildCanvasModel();
+      const model = buildCanvasDataModel();
       return {
         subsystems: model.subsystems.length,
         components: model.components.length,