@wairon/cli 5.1.1-dev.61 → 5.1.1-dev.63

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.61";
+    WAIRON_VERSION = "5.1.1-dev.63";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -1464,10 +1464,6 @@ function normalizeApprover(value) {
   }
   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(fs6.readFileSync(lockPath(), "utf8")));
@@ -8642,6 +8638,7 @@ var init_extensions = __esm({
     init_canonical_json();
     init_project();
     init_packstore();
+    init_packstore();
     ProfileDefSchema = import_zod9.z.object({
       family: import_zod9.z.enum(["backend-like", "frontend-like", "neutral"]).default("neutral"),
       forbiddenStereotypes: import_zod9.z.array(import_zod9.z.object({ types: import_zod9.z.array(import_zod9.z.string()).min(1), reason: import_zod9.z.string().min(1) })).default([]),
@@ -22143,223 +22140,6 @@ var init_domain_curator = __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) });
-    }
-  }
-  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);
-}
-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 = fs15.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 = path19.join(projectRoot2, ".gitmodules");
-  if (!fs15.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 = fs15.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 = path19.join(currentDir, entry.name);
-    const relPath = normalizePath(path19.relative(projectRoot2, fullPath));
-    if (relPath === "" || relPath === ".") continue;
-    const gitPath = path19.join(fullPath, ".git");
-    if (fs15.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 = fs15.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 = path19.join(currentDir, entry.name);
-    const relPath = normalizePath(path19.relative(projectRoot2, fullPath));
-    if (relPath === "" || relPath === ".") continue;
-    const hasMarker = PACKAGE_MARKERS.some((m) => fs15.existsSync(path19.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 = path19.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 fs15, path19, PACKAGE_MARKERS, MAX_SCAN_DEPTH;
-var init_detection = __esm({
-  "src/core/detection.ts"() {
-    "use strict";
-    fs15 = __toESM(require("fs"));
-    path19 = __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;
-  }
-});
-
-// src/core/templates.ts
-function builtinTemplatesDir() {
-  return path20.resolve(__dirname, "..", "templates");
-}
-function loadTemplate(id, globalOverride) {
-  const dirs = templateSearchDirs(globalOverride);
-  for (const dir of dirs) {
-    const filePath = path20.join(dir, `${id}.yaml`);
-    if (pathExists(filePath)) {
-      const raw = readYamlFile(filePath);
-      return { ...TemplateSchema.parse(raw), templateName: id };
-    }
-  }
-  throw new TemplateNotFoundError(id);
-}
-function loadAgentOverride(agentId) {
-  const filePath = path20.join(AI_PATHS.root(), "agents", `${agentId}.md`);
-  return readFileOrNull(filePath);
-}
-function templateSearchDirs(globalOverride) {
-  return [
-    AI_PATHS.templatesDir(),
-    // 1. project-local
-    globalTemplatesDir(globalOverride),
-    // 2. global user/org
-    builtinTemplatesDir()
-    // 3. built-in fallback
-  ];
-}
-function renderTemplateInstructions(template, vars) {
-  return template.instructions.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
-    return key in vars ? vars[key] : `{{${key}}}`;
-  });
-}
-var path20;
-var init_templates = __esm({
-  "src/core/templates.ts"() {
-    "use strict";
-    path20 = __toESM(require("path"));
-    init_fs();
-    init_yaml();
-    init_errors();
-    init_template();
-    init_paths();
-    init_defaults();
-  }
-});
-
 // src/core/provision.ts
 var provision_exports = {};
 __export(provision_exports, {
@@ -22422,7 +22202,7 @@ function provisionProject(name) {
 function ensureProjectInitialized(fallbackName) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paths = aiPathsAt(getProjectRoot());
-  const hasSystem = fs16.existsSync(paths.specsSystem());
+  const hasSystem = fs15.existsSync(paths.specsSystem());
   let name = fallbackName;
   if (hasSystem) {
     const existing = loadSystemSpec();
@@ -22444,11 +22224,11 @@ function ensureProjectInitialized(fallbackName) {
 function walkChainedSubprojects(projectRoot2, onChild) {
   const visited = /* @__PURE__ */ new Set();
   const walk2 = (dir) => {
-    const resolved = path21.resolve(dir);
+    const resolved = path19.resolve(dir);
     if (visited.has(resolved)) return;
     visited.add(resolved);
     const specsDir = aiPathsAt(dir).specsDir();
-    if (!fs16.existsSync(specsDir)) return;
+    if (!fs15.existsSync(specsDir)) return;
     for (const file of listFilesRecursive(specsDir, ".yaml")) {
       let raw;
       try {
@@ -22466,7 +22246,7 @@ function walkChainedSubprojects(projectRoot2, onChild) {
         continue;
       }
       const id = raw.id;
-      onChild(childDir, typeof id === "string" ? id : path21.basename(childDir));
+      onChild(childDir, typeof id === "string" ? id : path19.basename(childDir));
       walk2(childDir);
     }
   };
@@ -22475,7 +22255,7 @@ function walkChainedSubprojects(projectRoot2, onChild) {
 function listDirectChainedSubprojects(projectRoot2) {
   const out = [];
   const specsDir = aiPathsAt(projectRoot2).specsDir();
-  if (!fs16.existsSync(specsDir)) return out;
+  if (!fs15.existsSync(specsDir)) return out;
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
     let raw;
     try {
@@ -22493,12 +22273,12 @@ function listDirectChainedSubprojects(projectRoot2) {
       continue;
     }
     const id = raw.id;
-    out.push({ dir, subsystemId: typeof id === "string" ? id : path21.basename(dir) });
+    out.push({ dir, subsystemId: typeof id === "string" ? id : path19.basename(dir) });
   }
   return out;
 }
 function childHasSpecsButNoConfig(childDir) {
-  return fs16.existsSync(aiPathsAt(childDir).specsDir()) && !projectConfigRepositoryAt(childDir).exists();
+  return fs15.existsSync(aiPathsAt(childDir).specsDir()) && !projectConfigRepositoryAt(childDir).exists();
 }
 function findChainingSubprojectsMissingConfig(projectRoot2) {
   const missing = [];
@@ -22547,14 +22327,14 @@ function moveSubsystemProject(subsystemId, newProjectPath) {
   const oldDir = assertContainedProjectPath(root, sub.projectPath);
   const newDir = assertContainedProjectPath(root, nextPath);
   if (oldDir !== newDir) {
-    if (!fs16.existsSync(oldDir)) {
+    if (!fs15.existsSync(oldDir)) {
       throw new WaironError(`Subproject directory not found at its current path: ${oldDir}`);
     }
-    if (fs16.existsSync(newDir)) {
+    if (fs15.existsSync(newDir)) {
       throw new WaironError(`Target directory already exists: ${newDir}`);
     }
-    ensureDir(path21.dirname(newDir));
-    fs16.renameSync(oldDir, newDir);
+    ensureDir(path19.dirname(newDir));
+    fs15.renameSync(oldDir, newDir);
   }
   saveSubsystemSpec({ ...sub, projectPath: nextPath, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
   invalidateSpecCache();
@@ -22563,9 +22343,9 @@ function toPosixPath(p) {
   return p.replace(/\\/g, "/");
 }
 function isWithinDir(dir, file) {
-  const d = path21.resolve(dir);
-  const f = path21.resolve(file);
-  return f === d || f.startsWith(d + path21.sep);
+  const d = path19.resolve(dir);
+  const f = path19.resolve(file);
+  return f === d || f.startsWith(d + path19.sep);
 }
 function externalizeSubsystem(subsystemId, projectPath) {
   if (subsystemId.includes("::")) {
@@ -22577,14 +22357,14 @@ function externalizeSubsystem(subsystemId, projectPath) {
   }
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
-  const fooDir = path21.join(parentSpecsDir, subsystemId);
-  if (!fs16.existsSync(fooDir)) {
+  const fooDir = path19.join(parentSpecsDir, subsystemId);
+  if (!fs15.existsSync(fooDir)) {
     throw new WaironError(`subsystem specs directory not found: ${fooDir}`);
   }
   const relPath = toPosixPath(projectPath);
   const childDir = assertContainedProjectPath(parentRoot, relPath);
-  const childFooDir = path21.join(childDir, ".wai", "specs", subsystemId);
-  if (fs16.existsSync(childFooDir)) {
+  const childFooDir = path19.join(childDir, ".wai", "specs", subsystemId);
+  if (fs15.existsSync(childFooDir)) {
     throw new WaironError(`target already contains a "${subsystemId}" subsystem: ${childFooDir}`);
   }
   const renameMap = buildRenameMap(
@@ -22596,18 +22376,18 @@ function externalizeSubsystem(subsystemId, projectPath) {
   runWithProjectRoot(childDir, () => {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     projectConfigRepository.create(defaultProjectConfig(childSystemName, now));
-    ensureDir(path21.join(childDir, ".wai", "specs"));
+    ensureDir(path19.join(childDir, ".wai", "specs"));
     saveSystemSpec(bootstrapSystemSpec(childSystemName, now));
   });
-  ensureDir(path21.dirname(childFooDir));
-  fs16.renameSync(fooDir, childFooDir);
+  ensureDir(path19.dirname(childFooDir));
+  fs15.renameSync(fooDir, childFooDir);
   rebaseImplementationPaths(childFooDir, parentRoot, childDir);
-  patchSubsystemIndex(path21.join(childFooDir, ".index.yaml"), (s) => {
+  patchSubsystemIndex(path19.join(childFooDir, ".index.yaml"), (s) => {
     s.parentSystem = childSystemName;
     delete s.projectPath;
   });
   ensureDir(fooDir);
-  writeYamlFile(path21.join(fooDir, ".index.yaml"), {
+  writeYamlFile(path19.join(fooDir, ".index.yaml"), {
     id: subsystemId,
     name: foo.name,
     description: foo.description,
@@ -22634,9 +22414,9 @@ function internalizeSubsystem(subsystemId) {
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
   const childDir = assertContainedProjectPath(parentRoot, foo.projectPath);
-  const childWai = path21.join(childDir, ".wai");
-  const childFooDir = path21.join(childDir, ".wai", "specs", subsystemId);
-  if (!fs16.existsSync(childFooDir)) {
+  const childWai = path19.join(childDir, ".wai");
+  const childFooDir = path19.join(childDir, ".wai", "specs", subsystemId);
+  if (!fs15.existsSync(childFooDir)) {
     throw new WaironError(`external subproject missing subsystem "${subsystemId}": ${childFooDir}`);
   }
   const childOwnSubs = runWithProjectRoot(childDir, () => loadSubsystemSpecs()).filter((s) => !s.id.includes("::"));
@@ -22649,16 +22429,16 @@ function internalizeSubsystem(subsystemId) {
     false
   );
   const parentSystemName = loadSystemSpec()?.name ?? foo.parentSystem;
-  const fooDir = path21.join(parentSpecsDir, subsystemId);
-  fs16.rmSync(fooDir, { recursive: true, force: true });
-  ensureDir(path21.dirname(fooDir));
-  fs16.renameSync(childFooDir, fooDir);
+  const fooDir = path19.join(parentSpecsDir, subsystemId);
+  fs15.rmSync(fooDir, { recursive: true, force: true });
+  ensureDir(path19.dirname(fooDir));
+  fs15.renameSync(childFooDir, fooDir);
   rebaseImplementationPaths(fooDir, childDir, parentRoot);
-  patchSubsystemIndex(path21.join(fooDir, ".index.yaml"), (s) => {
+  patchSubsystemIndex(path19.join(fooDir, ".index.yaml"), (s) => {
     s.parentSystem = parentSystemName;
     delete s.projectPath;
   });
-  fs16.rmSync(childWai, { recursive: true, force: true });
+  fs15.rmSync(childWai, { recursive: true, force: true });
   rewriteRefsInDir(parentSpecsDir, renameMap, fooDir);
   rebaseMovedRefs(fooDir, subsystemId, "outOf");
   invalidateSpecCache();
@@ -22736,8 +22516,8 @@ function rebaseImplementationPaths(specsDir, fromRoot, toRoot) {
     let changed = false;
     const rebase = (holder, key) => {
       const p = holder[key];
-      if (typeof p !== "string" || p === "" || path21.isAbsolute(p)) return;
-      const next = toPosixPath(path21.relative(toRoot, path21.resolve(fromRoot, p)));
+      if (typeof p !== "string" || p === "" || path19.isAbsolute(p)) return;
+      const next = toPosixPath(path19.relative(toRoot, path19.resolve(fromRoot, p)));
       if (next !== p) {
         holder[key] = next;
         changed = true;
@@ -22753,7 +22533,7 @@ function rebaseImplementationPaths(specsDir, fromRoot, toRoot) {
   }
 }
 function patchSubsystemIndex(indexPath, mutate) {
-  if (!fs16.existsSync(indexPath)) return;
+  if (!fs15.existsSync(indexPath)) return;
   const raw = readYamlFile(indexPath);
   mutate(raw);
   raw.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -22814,8 +22594,8 @@ function moveRenamedSpecs(componentId, newId, component, movingInterface, moving
   if (movedInterface) saveInterfaceSpec({ ...movedInterface, id: interfaceId, component: newId });
   if (movedImplementation) {
     const oldFile = getImplementationPath(movedImplementation.id);
-    if (path21.resolve(getImplementationPath(implementationId, movedImplementation.contract)) === path21.resolve(oldFile)) {
-      fs16.unlinkSync(oldFile);
+    if (path19.resolve(getImplementationPath(implementationId, movedImplementation.contract)) === path19.resolve(oldFile)) {
+      fs15.unlinkSync(oldFile);
     }
     saveImplementationSpec({ ...movedImplementation, id: implementationId });
   }
@@ -22825,17 +22605,17 @@ function moveRenamedSpecs(componentId, newId, component, movingInterface, moving
   invalidateSpecCache();
 }
 function removeSpecFile2(file, id) {
-  if (!fs16.existsSync(file)) return;
+  if (!fs15.existsSync(file)) return;
   try {
     if (readYamlFile(file)?.id !== id) return;
   } catch {
     return;
   }
-  fs16.unlinkSync(file);
-  const specsRoot = path21.resolve(aiPathsAt(getProjectRoot()).specsDir());
-  for (let dir = path21.dirname(path21.resolve(file)); dir !== specsRoot && isWithinDir(specsRoot, dir); dir = path21.dirname(dir)) {
-    if (fs16.readdirSync(dir).length > 0) break;
-    fs16.rmdirSync(dir);
+  fs15.unlinkSync(file);
+  const specsRoot = path19.resolve(aiPathsAt(getProjectRoot()).specsDir());
+  for (let dir = path19.dirname(path19.resolve(file)); dir !== specsRoot && isWithinDir(specsRoot, dir); dir = path19.dirname(dir)) {
+    if (fs15.readdirSync(dir).length > 0) break;
+    fs15.rmdirSync(dir);
   }
 }
 function renameMethod(componentId, methodName, newName, pinSymbol) {
@@ -22932,12 +22712,12 @@ function collectMentions(specsDir, methodName, moved) {
 function identifierPattern(methodName) {
   return new RegExp(`(?<![A-Za-z0-9_])${methodName}(?![A-Za-z0-9_])`);
 }
-var fs16, path21, METHOD_NAME, PROSE_FIELDS2;
+var fs15, path19, METHOD_NAME, PROSE_FIELDS2;
 var init_provision = __esm({
   "src/core/provision.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"));
-    path21 = __toESM(require("path"));
+    fs15 = __toESM(require("fs"));
+    path19 = __toESM(require("path"));
     init_specs2();
     init_paths();
     init_project_config();
@@ -22960,6 +22740,223 @@ var init_provision = __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) });
+    }
+  }
+  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);
+}
+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_defaults();
+    PACKAGE_MARKERS = [
+      "package.json",
+      "pyproject.toml",
+      "Cargo.toml",
+      "go.mod",
+      "build.gradle",
+      "build.gradle.kts",
+      "pom.xml"
+    ];
+    MAX_SCAN_DEPTH = 5;
+  }
+});
+
+// src/core/templates.ts
+function builtinTemplatesDir() {
+  return path21.resolve(__dirname, "..", "templates");
+}
+function loadTemplate(id, globalOverride) {
+  const dirs = templateSearchDirs(globalOverride);
+  for (const dir of dirs) {
+    const filePath = path21.join(dir, `${id}.yaml`);
+    if (pathExists(filePath)) {
+      const raw = readYamlFile(filePath);
+      return { ...TemplateSchema.parse(raw), templateName: id };
+    }
+  }
+  throw new TemplateNotFoundError(id);
+}
+function loadAgentOverride(agentId) {
+  const filePath = path21.join(AI_PATHS.root(), "agents", `${agentId}.md`);
+  return readFileOrNull(filePath);
+}
+function templateSearchDirs(globalOverride) {
+  return [
+    AI_PATHS.templatesDir(),
+    // 1. project-local
+    globalTemplatesDir(globalOverride),
+    // 2. global user/org
+    builtinTemplatesDir()
+    // 3. built-in fallback
+  ];
+}
+function renderTemplateInstructions(template, vars) {
+  return template.instructions.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    return key in vars ? vars[key] : `{{${key}}}`;
+  });
+}
+var path21;
+var init_templates = __esm({
+  "src/core/templates.ts"() {
+    "use strict";
+    path21 = __toESM(require("path"));
+    init_fs();
+    init_yaml();
+    init_errors();
+    init_template();
+    init_paths();
+    init_defaults();
+  }
+});
+
 // src/core/execution_profile.ts
 function isSweeping(p) {
   return p === "**" || p === "**/*" || p.startsWith("**/");
@@ -23503,326 +23500,267 @@ var init_agent_resolver = __esm({
   }
 });
 
-// src/core/instructions.ts
-function governingProfile() {
-  try {
-    return loadProjectConfig3()?.projectType ?? null;
-  } catch {
-    return null;
+// 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 blockApplies(block, profile) {
-  if (!block.profile || block.profile.length === 0) return true;
-  return profile !== null && block.profile.includes(profile);
+function mcpServersFor(access) {
+  return access === "none" ? "[]" : void 0;
 }
-function skillPointers(skills) {
-  if (skills.length === 0) return "(none published by this server)";
-  return skills.map((s) => `- \`${s.resourceUri}\` \u2014 ${s.description || s.name}`).join("\n");
+function yamlScalar(value) {
+  return /[:#\n]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
 }
-function waironInstructions(profile, packNames, skills, variants) {
-  return `# wairon \u2014 Spec-Driven Development (SDD)
-
-This server owns one system's **spec tree**: its architecture, specified top-down
-and machine-checked. Author it ONLY through this server's \`sdd_*\` tools \u2014 never by
-writing spec files directly, and never via the \`wairon\` CLI (that is the human
-developer's tool).
-
-## The tree: L0 \u2192 L5
-
-- **L0 System** \u2014 vision, boundaries, global requirements, target language.
-- **L1 Subsystem** \u2014 an isolated service, its \`publicInterfaces\`, its trusted links.
-- **L2 Component** \u2014 ONE building block (\`Portal\`, \`Orchestrator\`, \`Supervisor\`,
-  \`Actor\`, \`Store\`, \`Index\`, \`Query\`, \`Registry\`, \`Adapter\`, \`Observer\`, and
-  \`View\` for UIs) or pattern (\`Repository\`, and \`FeatureComponent\` or
-  \`RouterComponent\` for UIs), plus \`owns\` (a pattern's private members) and
-  \`dependsOn\` (collaborators). Logic is an \`Orchestrator\` whose \`dependencyClass\`
-  (\`pure\` or \`read\`; unset, a workflow) bounds what it may depend on; a gateway is
-  a \`Portal\` with the \`gateway\` variant. \`Specialist\` and \`Gateway\` are retired.
-- **L3 Interface** \u2014 the contract: method signatures with structured \`params\`,
-  plus wire \`endpoint\` bindings for a Portal's methods.
-- **L4 Implementation** \u2014 a concrete realization of one L3 contract: narrative
-  detail level, bound \`technologies\` (the vendor swap seam), optional \`sourcePath\`.
-- **L5 Narrative** \u2014 each method's logic as a FLAT numbered step list; \`call\` steps
-  resolve to real dependency methods, and flow steps jump by step number.
-
-These stereotypes are not labels \u2014 they carry enforced dependency rules (e.g. a
-Portal may not depend on a Store; state lives in a Store, never as fields inside
-an Orchestrator). \`sdd_validate_tree\` is the gate, and it is the authority on
-whether a design is legal.
-
-## Authoring order
-
-1. \`sdd_initialize_system\` (L0), then \`sdd_add_subsystem\` (L1).
-2. Then, **one subsystem at a time**: \`sdd_add_component\` (L2) \u2192 \`sdd_define_interface\`
-   (L3) \u2192 \`sdd_set_endpoints\` for Portals \u2192 \`sdd_write_narrative\` (L4+L5).
-3. Run \`sdd_validate_tree\` as you go \u2014 early and per subsystem, not once at the end.
-   \`sdd_get_status\` reports completeness; \`sdd_get_spec\` reads any spec back as JSON.
-4. Edit granularly with \`sdd_update_spec\` (it renumbers narrative steps and
-   relocates jump targets for you).
-
-## The tool schemas are the field reference
-
-Every \`sdd_*\` tool's input schema is self-describing and authoritative \u2014 read the
-schema rather than guessing field names, and prefer structured \`params\` over prose
-signatures. Specs are ${profile === null ? "validated against the project's configured profile" : `governed by the **\`${profile}\`** profile`}, which decides which stereotypes are legal
-here, which narrative flow constructs the target language supports, and which
-extra rules apply. A subsystem may override the profile for itself.
-
-## Loaded extension packs
-
-${packNames.length === 0 ? "None \u2014 only wairon's built-in doctrine applies." : `${packNames.map((n) => `\`${n}\``).join(", ")} \u2014 these inject profiles, language tables, patterns, and
-additional conformance rules. Their doctrine is enforced by the same gate.`}
-
-${variants.length === 0 ? "" : `## Component variants in play
-
-This project defines variants \u2014 named, base-anchored kinds carrying implementation
-guidance, so every component of the same kind is built alike: ${variants.map((v) => `\`${v.id}\` (a kind of ${v.base})`).join(", ")}.
-Tag a component with \`variant\` where it fits, and read a component's resolved
-guidance and its same-variant siblings from \`sdd_get_spec\` (kind: component).
-
-`}## Read the skills BEFORE authoring
-
-This server publishes its skills as MCP resources. **Read \`wairon-skill://sdd-architect\`
-before you design anything**, and the others when their turn comes \u2014 they carry the
-architecture standard, the narrative step reference, and the review checklist that
-this briefing only points at:
-
-${skillPointers(skills)}
-
-## Delegating implementation
+var path23, MODEL_BY_TIER, TOOLS_BY_CLASS, ClaudeExporter;
+var init_claude = __esm({
+  "src/exporters/claude.ts"() {
+    "use strict";
+    path23 = __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 path23.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 };
+      }
+    };
+  }
+});
 
-Delegate component work from a LIVE agent brief, never a generated file: discover
-agents via \`listAgents\` (or the \`wairon-agent://\` resources), fetch the target's
-brief with \`sdd_get_agent_brief\`, and spawn a scoped subagent from it \u2014 its
-\`instructions\` as prompt, its \`ownedPaths\` as write fence. Briefs are composed
-from the current spec tree on every call, so a re-lock never requires a session
-restart \u2014 fetch fresh per delegation. \`wairon-skill://sdd-delegate\` carries the
-full flow.`;
-}
-function buildServerInstructions() {
-  const profile = governingProfile();
-  let skills = [];
-  let blocks = [];
-  let packNames = [];
-  const variants = [];
-  try {
-    skills = listSkillResources();
-    const extensions = loadProjectExtensions2();
-    blocks = extensions.instructions;
-    packNames = extensions.packNames;
-  } catch {
+// src/exporters/custom.ts
+var path24, CustomExporter;
+var init_custom = __esm({
+  "src/exporters/custom.ts"() {
+    "use strict";
+    path24 = __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 path24.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 };
+      }
+    };
   }
-  const sections = [waironInstructions(profile, packNames, skills, variants)];
-  for (const block of blocks) {
-    if (!blockApplies(block, profile)) continue;
-    sections.push(`## From pack "${block.pack}"
+});
 
-${block.text.trim()}`);
+// src/exporters/gemini.ts
+function yamlString(value) {
+  if (/[:#\[\]{},&*!|>'"%@`]/.test(value) || value.startsWith(" ") || value.endsWith(" ")) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
   }
-  return sections.join("\n\n");
+  return value;
 }
-var init_instructions = __esm({
-  "src/core/instructions.ts"() {
+var path25, GeminiExporter;
+var init_gemini = __esm({
+  "src/exporters/gemini.ts"() {
     "use strict";
-    init_skills();
+    path25 = __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 path25.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/core/skills.ts
-function loadProjectExtensions2() {
-  return loadProjectExtensions();
-}
-function loadProjectConfig3() {
-  return loadProjectConfig();
-}
-function packSkillId(skill) {
-  return `${packNamespace(skill.pack)}-${skill.id}`;
-}
-function packNamespace(pack) {
-  return pack.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function extensionsFor(builtin, packSkills) {
-  return packSkills.filter((s) => s.extends === builtin && fs18.existsSync(s.sourcePath));
-}
-function composeBuiltinSkill(name, packSkills) {
-  const srcPath = skillTemplatePath(name);
-  const base = fs18.existsSync(srcPath) ? fs18.readFileSync(srcPath, "utf-8") : "";
-  const sections = extensionsFor(name, packSkills);
-  if (sections.length === 0) return base;
-  const parts = [base.trimEnd()];
-  for (const section of sections) {
-    const body = fs18.readFileSync(section.sourcePath, "utf-8").replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
-    parts.push(`## Platform: ${section.pack}`, body.trim());
+// 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 `${parts.join("\n\n")}
-`;
-}
-function readFrontmatter(raw, fallbackName) {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
-  const block = match ? match[1] : "";
-  const field = (key) => {
-    const m = new RegExp(`^${key}:\\s*(.*)$`, "m").exec(block);
-    return m ? m[1].trim() : "";
-  };
-  return { name: field("name") || fallbackName, description: field("description") };
-}
-function builtinSkillsDir() {
-  return path23.resolve(__dirname, "..", "templates", "skills");
-}
-function skillTemplatePath(name) {
-  return path23.join(builtinSkillsDir(), `${name}.md`);
+  return exporter;
 }
-function skillDestPath(type, destDir, name) {
-  if (type === "claude" || type === "codex" || type === "gemini" || type === "agy") {
-    return path23.join(destDir, name, "SKILL.md");
+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()]
+    ]);
   }
-  return path23.join(destDir, `${name}.md`);
-}
-function skillsDirForTarget(type) {
-  switch (type) {
-    case "claude":
-      return fromProjectRoot(".claude", "skills");
-    case "gemini":
-    // Gemini-based Antigravity
-    case "agy":
-    case "codex":
-      return fromProjectRoot(".agents", "skills");
-    case "cursor":
-      return fromProjectRoot(".cursor", "skills");
-    default:
-      return null;
+});
+
+// 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 -->`;
   }
-}
-function listSkillNames() {
-  return [...SKILL_NAMES];
-}
-function exportSddSkills(targetTypes) {
-  const types = targetTypes ?? activeTargetTypes2();
-  const destinations = [];
-  const skipped = [];
-  let fileCount = 0;
-  const packSkills = loadProjectExtensions2().skills;
-  for (const type of types) {
-    const destDir = skillsDirForTarget(type);
-    if (!destDir) {
-      skipped.push(type);
-      continue;
-    }
-    ensureDir(destDir);
-    destinations.push(destDir);
-    for (const name of SKILL_NAMES) {
-      if (!fs18.existsSync(skillTemplatePath(name))) continue;
-      const content = composeBuiltinSkill(name, packSkills.filter((s) => s.targets.includes(type)));
-      const destPath = skillDestPath(type, destDir, name);
-      ensureDir(path23.dirname(destPath));
-      fs18.writeFileSync(destPath, content, "utf-8");
-      fileCount++;
+});
+
+// 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;
     }
-    for (const skill of packSkills) {
-      if (skill.extends !== void 0) continue;
-      if (!skill.targets.includes(type)) continue;
-      if (!fs18.existsSync(skill.sourcePath)) continue;
-      const id = packSkillId(skill);
-      const content = fs18.readFileSync(skill.sourcePath, "utf-8");
-      const destPath = skillDestPath(type, destDir, id);
-      ensureDir(path23.dirname(destPath));
-      fs18.writeFileSync(destPath, content, "utf-8");
-      fileCount++;
+    if (!options.dryRun) {
+      results.push(getExporter(targetConfig).export({
+        agent,
+        template,
+        renderedInstructions: rendered,
+        projectRoot: projectRoot2,
+        target: targetConfig,
+        budget
+      }));
     }
   }
-  return { destinations, fileCount, skipped };
+  return { agent, results };
 }
-function checkSkillFreshness(type) {
-  const dir = skillsDirForTarget(type);
-  const result = { dir, missing: [], stale: [], ok: [] };
-  if (!dir) return result;
-  const packSkills = loadProjectExtensions2().skills.filter((s) => s.targets.includes(type));
-  for (const name of SKILL_NAMES) {
-    const destPath = skillDestPath(type, dir, name);
-    if (!fs18.existsSync(destPath)) {
-      result.missing.push(name);
-      continue;
-    }
-    const want = composeBuiltinSkill(name, packSkills);
-    const have = fs18.readFileSync(destPath, "utf-8");
-    if (have === want) result.ok.push(name);
-    else result.stale.push(name);
+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 result;
-}
-function activeTargetTypes2() {
-  const config = loadProjectConfig3();
-  if (!config) return [];
-  return activeTargetTypes(config);
+  return pool.map((agent) => generateAgent(agent, projectConfig, options));
 }
-function readSkillFrontmatter(name) {
-  return readFrontmatter(fs18.readFileSync(skillTemplatePath(name), "utf-8"), name);
+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(path26.resolve(getExporter(targetConfig).outputPath(ctx)));
+    }
+  }
+  return expected;
 }
-function listSkillResources() {
-  const builtin = RESOURCE_SKILL_IDS.map((id) => {
-    const fm = readSkillFrontmatter(id);
-    return {
-      id,
-      name: fm.name,
-      description: fm.description,
-      version: WAIRON_VERSION,
-      resourceUri: `${SKILL_RESOURCE_SCHEME}://${id}`,
-      defaultForHostedMcp: true
-    };
-  });
-  const pack = loadProjectExtensions2().skills.filter((s) => s.extends === void 0 && fs18.existsSync(s.sourcePath)).map((skill) => {
-    const id = packSkillId(skill);
-    const fm = readFrontmatter(fs18.readFileSync(skill.sourcePath, "utf-8"), id);
-    return {
-      id,
-      name: fm.name,
-      description: fm.description,
-      version: skill.packVersion ?? WAIRON_VERSION,
-      resourceUri: `${SKILL_RESOURCE_SCHEME}://${id}`,
-      defaultForHostedMcp: true
-    };
+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;
   });
-  return [...builtin, ...pack];
-}
-function readSkillResource(resourceId) {
-  const packSkills = loadProjectExtensions2().skills;
-  if (SKILL_NAMES.includes(resourceId)) return composeBuiltinSkill(resourceId, packSkills);
-  const packSkill = packSkills.find((s) => s.extends === void 0 && packSkillId(s) === resourceId);
-  if (packSkill) return fs18.readFileSync(packSkill.sourcePath, "utf-8");
-  return fs18.readFileSync(skillTemplatePath(resourceId), "utf-8");
 }
-function listResources() {
-  return listSkillResources();
-}
-function buildServerInstructions2() {
-  return buildServerInstructions();
-}
-function readResource(resourceId) {
-  const known = listSkillResources().some((d) => d.id === resourceId);
-  if (!known) throw new SkillResourceNotFoundError(resourceId);
-  return readSkillResource(resourceId);
-}
-var path23, fs18, SKILL_NAMES, SKILL_RESOURCE_SCHEME, RESOURCE_SKILL_IDS, SkillResourceNotFoundError;
-var init_skills = __esm({
-  "src/core/skills.ts"() {
+var path26;
+var init_generate = __esm({
+  "src/exporters/generate.ts"() {
     "use strict";
-    path23 = __toESM(require("path"));
-    fs18 = __toESM(require("fs"));
+    path26 = __toESM(require("path"));
+    init_templates();
+    init_agent_resolver();
+    init_execution_profile();
+    init_budget_policy();
     init_fs();
-    init_defaults();
-    init_project();
-    init_extensions();
-    init_instructions();
-    init_core();
-    SKILL_NAMES = ["sdd-architect", "sdd-narrative", "sdd-auditor", "sdd-implement", "sdd-delegate"];
-    SKILL_RESOURCE_SCHEME = "wairon-skill";
-    RESOURCE_SKILL_IDS = [...SKILL_NAMES].sort();
-    SkillResourceNotFoundError = class extends Error {
-      constructor(resourceId) {
-        super(`Unknown SDD skill resource id: "${resourceId}".`);
-        this.name = "SkillResourceNotFoundError";
-      }
-    };
+    init_registry2();
+    init_base();
   }
 });
 
@@ -27201,41 +27139,41 @@ function hasAuthoredSpecs(root) {
   if (!pathExists(specsDir)) {
     return false;
   }
-  const systemIndex = path24.resolve(paths.specsSystem());
+  const systemIndex = path27.resolve(paths.specsSystem());
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
-    if (path24.resolve(file) !== systemIndex) {
+    if (path27.resolve(file) !== systemIndex) {
       return true;
     }
   }
   return false;
 }
 function createStagingDir(destDir) {
-  const root = path24.resolve(destDir);
-  fs19.mkdirSync(root, { recursive: true });
-  const stagingDir = fs19.mkdtempSync(path24.join(root, STAGING_PREFIX));
+  const root = path27.resolve(destDir);
+  fs18.mkdirSync(root, { recursive: true });
+  const stagingDir = fs18.mkdtempSync(path27.join(root, STAGING_PREFIX));
   return stagingDir;
 }
 function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
-  const root = path24.resolve(destDir);
-  const backupDir = path24.join(root, BACKUP_DIR, timestampSlug());
+  const root = path27.resolve(destDir);
+  const backupDir = path27.join(root, BACKUP_DIR, timestampSlug());
   let backedUp = false;
   for (const rootRel of roots) {
     const relative15 = rootRel === "." ? "" : rootRel;
-    const stagedSpecDir = path24.join(stagingDir, relative15, ".wai");
-    if (!fs19.existsSync(stagedSpecDir)) continue;
-    const liveSpecDir = liveSpecDirFor(path24.join(root, relative15));
-    if (backupExisting && liveSpecDir && fs19.existsSync(liveSpecDir)) {
-      const backupTarget = path24.join(backupDir, relative15, path24.basename(liveSpecDir));
-      fs19.mkdirSync(path24.dirname(backupTarget), { recursive: true });
-      fs19.renameSync(liveSpecDir, backupTarget);
+    const stagedSpecDir = path27.join(stagingDir, relative15, ".wai");
+    if (!fs18.existsSync(stagedSpecDir)) continue;
+    const liveSpecDir = liveSpecDirFor(path27.join(root, relative15));
+    if (backupExisting && liveSpecDir && fs18.existsSync(liveSpecDir)) {
+      const backupTarget = path27.join(backupDir, relative15, path27.basename(liveSpecDir));
+      fs18.mkdirSync(path27.dirname(backupTarget), { recursive: true });
+      fs18.renameSync(liveSpecDir, backupTarget);
       backedUp = true;
-    } else if (liveSpecDir && fs19.existsSync(liveSpecDir)) {
-      fs19.rmSync(liveSpecDir, { recursive: true, force: true });
+    } else if (liveSpecDir && fs18.existsSync(liveSpecDir)) {
+      fs18.rmSync(liveSpecDir, { recursive: true, force: true });
     }
-    const target = path24.join(root, relative15, ".wai");
-    fs19.mkdirSync(path24.dirname(target), { recursive: true });
-    if (fs19.existsSync(target)) fs19.rmSync(target, { recursive: true, force: true });
-    fs19.renameSync(stagedSpecDir, target);
+    const target = path27.join(root, relative15, ".wai");
+    fs18.mkdirSync(path27.dirname(target), { recursive: true });
+    if (fs18.existsSync(target)) fs18.rmSync(target, { recursive: true, force: true });
+    fs18.renameSync(stagedSpecDir, target);
   }
   if (backedUp) {
     return backupDir;
@@ -27244,7 +27182,7 @@ function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
 }
 function discardStagingDir(stagingDir) {
   try {
-    fs19.rmSync(stagingDir, { recursive: true, force: true });
+    fs18.rmSync(stagingDir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -27258,7 +27196,7 @@ function exportSpecTree(includeDerived, allowPartial) {
   const skipped = [...inspection.skipped];
   const roots = [{ relativePath: ".", waiDir: aiPathsAt(root).root() }];
   for (const rel2 of inspection.roots) {
-    const waiDir = aiPathsAt(path24.resolve(root, rel2)).root();
+    const waiDir = aiPathsAt(path27.resolve(root, rel2)).root();
     if (pathExists(waiDir)) {
       roots.push({ relativePath: rel2, waiDir });
     } else {
@@ -27289,7 +27227,7 @@ function importSpecTree(archive, options) {
   if (!info.compatible) {
     throw new Error("incompatible .waitree archive (format or minimum wairon version)");
   }
-  const destDir = path24.resolve(options.destDir ?? getProjectRoot());
+  const destDir = path27.resolve(options.destDir ?? getProjectRoot());
   const occupied = hasSpecTree(destDir);
   const authored = hasAuthoredSpecs(destDir);
   if (authored && options.replaceExisting !== true) {
@@ -27320,21 +27258,21 @@ function importSpecTree(archive, options) {
   return result;
 }
 function liveSpecDirFor(rootDir) {
-  const modern = path24.join(rootDir, ".wai");
-  if (fs19.existsSync(modern)) return modern;
-  const legacy = path24.join(rootDir, ".wairon");
-  if (fs19.existsSync(legacy)) return legacy;
+  const modern = path27.join(rootDir, ".wai");
+  if (fs18.existsSync(modern)) return modern;
+  const legacy = path27.join(rootDir, ".wairon");
+  if (fs18.existsSync(legacy)) return legacy;
   return null;
 }
 function timestampSlug() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
-var fs19, path24, sdkPortal, STAGING_PREFIX, BACKUP_DIR;
+var fs18, path27, sdkPortal, STAGING_PREFIX, BACKUP_DIR;
 var init_treetransfer = __esm({
   "src/core/treetransfer.ts"() {
     "use strict";
-    fs19 = __toESM(require("fs"));
-    path24 = __toESM(require("path"));
+    fs18 = __toESM(require("fs"));
+    path27 = __toESM(require("path"));
     sdkPortal = __toESM(require_dist());
     init_paths();
     init_fs();
@@ -27345,270 +27283,6 @@ 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 path25, MODEL_BY_TIER, TOOLS_BY_CLASS, ClaudeExporter;
-var init_claude = __esm({
-  "src/exporters/claude.ts"() {
-    "use strict";
-    path25 = __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 path25.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 path26, CustomExporter;
-var init_custom = __esm({
-  "src/exporters/custom.ts"() {
-    "use strict";
-    path26 = __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 path26.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 path27, GeminiExporter;
-var init_gemini = __esm({
-  "src/exporters/gemini.ts"() {
-    "use strict";
-    path27 = __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 path27.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(path28.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 path28;
-var init_generate = __esm({
-  "src/exporters/generate.ts"() {
-    "use strict";
-    path28 = __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();
@@ -27756,6 +27430,17 @@ var init_narrative_repair = __esm({
   }
 });
 
+// src/models/lock.ts
+function describeApprover(who) {
+  const label = who.name ? `${who.name} (${who.id})` : who.id;
+  return who.source === "hosted" ? `${label} [authenticated]` : label;
+}
+var init_lock = __esm({
+  "src/models/lock.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/approval.ts
 function diffSize(d) {
   return d.added.length + d.changed.length + d.removed.length;
@@ -27765,12 +27450,12 @@ function digest(content) {
   return crypto4.createHash("sha256").update(normalized, "utf8").digest("hex");
 }
 function currentSpecDigests(root = getProjectRoot()) {
-  const mountDirs = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::")).map((s) => `${path29.resolve(root, s.projectPath).split(path29.sep).join("/")}/`);
+  const mountDirs = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::")).map((s) => `${path28.resolve(root, s.projectPath).split(path28.sep).join("/")}/`);
   const out = {};
   for (const [abs, content] of snapshotSpecFiles()) {
-    const normalized = path29.resolve(abs).split(path29.sep).join("/");
+    const normalized = path28.resolve(abs).split(path28.sep).join("/");
     if (mountDirs.some((dir) => normalized.startsWith(dir))) continue;
-    out[path29.relative(root, abs).split(path29.sep).join("/")] = digest(content);
+    out[path28.relative(root, abs).split(path28.sep).join("/")] = digest(content);
   }
   return out;
 }
@@ -27828,7 +27513,7 @@ function currentChildPins(mounts, root = getProjectRoot()) {
   const pins = {};
   for (const mount of mounts) {
     if (!mount.projectPath || mount.id.includes("::")) continue;
-    const child = readLockRecordAt(path29.resolve(root, mount.projectPath));
+    const child = readLockRecordAt(path28.resolve(root, mount.projectPath));
     if (child) pins[mount.id] = pinOf(child.stateId);
   }
   return pins;
@@ -27844,15 +27529,62 @@ function movedChildren(mounts, root = getProjectRoot()) {
   }
   return moved;
 }
-var crypto4, path29;
+function approvalVerdict() {
+  const quiet = { text: "", drifted: false };
+  try {
+    const approval = approvalRecord();
+    if (!approval) return quiet;
+    const by = describeApprover(approval.lockedBy);
+    const moved = movedChildren(loadSubsystemSpecs());
+    const childNote = moved.length ? `
+${moved.length} chained child project(s) moved since approval: ${moved.map((m) => m.id).join(", ")}.` : "";
+    const diff = diffAgainstApproval();
+    if (!diff) {
+      return {
+        text: `
+Approved: ${approval.lockedAt} by ${by} \u2014 this lock predates per-spec approval, so drift is only visible at whole-tree level. Re-lock to record it.${childNote}
+`,
+        drifted: moved.length > 0
+      };
+    }
+    if (diffSize(diff) === 0) {
+      return {
+        text: `
+Approved: ${approval.lockedAt} by ${by} \u2014 no spec has changed since.${childNote}
+`,
+        drifted: moved.length > 0
+      };
+    }
+    const parts = [];
+    if (diff.changed.length) parts.push(`${diff.changed.length} changed`);
+    if (diff.added.length) parts.push(`${diff.added.length} added`);
+    if (diff.removed.length) parts.push(`${diff.removed.length} removed`);
+    const named = [...diff.changed, ...diff.added, ...diff.removed].slice(0, 5);
+    const rest = diffSize(diff) - named.length;
+    const n = diffSize(diff);
+    const noun = `${n} spec${n === 1 ? "" : "s"}`;
+    const headline = parts.length === 1 ? `${noun} ${parts[0].slice(String(diffSize(diff)).length + 1)} since approval` : `${noun} changed since approval (${parts.join(", ")})`;
+    return {
+      text: `
+${headline} \u2014 approved ${approval.lockedAt} by ${by}:
+` + named.map((p) => `  ${p}`).join("\n") + (rest > 0 ? `
+  \u2026 and ${rest} more` : "") + childNote + "\n",
+      drifted: true
+    };
+  } catch {
+    return quiet;
+  }
+}
+var crypto4, path28;
 var init_approval = __esm({
   "src/core/approval.ts"() {
     "use strict";
     crypto4 = __toESM(require("crypto"));
-    path29 = __toESM(require("path"));
+    path28 = __toESM(require("path"));
     init_fs();
     init_specs2();
     init_lockfile();
+    init_lock();
   }
 });
 
@@ -27917,13 +27649,13 @@ var init_stamp = __esm({
 
 // src/utils/ai-guide.ts
 function globalGuideFilePath(targetType) {
-  if (targetType === "claude") return path30.join(process.env["CLAUDE_CONFIG_DIR"] || path30.join(os6.homedir(), ".claude"), "CLAUDE.md");
-  if (targetType === "gemini") return path30.join(process.env["GEMINI_CONFIG_DIR"] || path30.join(os6.homedir(), ".gemini"), "GEMINI.md");
+  if (targetType === "claude") return path29.join(process.env["CLAUDE_CONFIG_DIR"] || path29.join(os6.homedir(), ".claude"), "CLAUDE.md");
+  if (targetType === "gemini") return path29.join(process.env["GEMINI_CONFIG_DIR"] || path29.join(os6.homedir(), ".gemini"), "GEMINI.md");
   return null;
 }
 function localGuideFilePath(projectRoot2, targetType) {
-  if (targetType === "claude") return path30.join(projectRoot2, ".claude", "CLAUDE.md");
-  if (targetType === "gemini" || targetType === "agy") return path30.join(projectRoot2, ".gemini", "GEMINI.md");
+  if (targetType === "claude") return path29.join(projectRoot2, ".claude", "CLAUDE.md");
+  if (targetType === "gemini" || targetType === "agy") return path29.join(projectRoot2, ".gemini", "GEMINI.md");
   return null;
 }
 function injectGuide(filePath, scope) {
@@ -27935,11 +27667,11 @@ ${versionStamp()}
 ${body}
 ${GUIDE_MARKER_END}
 `;
-  const existing = fs20.existsSync(filePath) ? fs20.readFileSync(filePath, "utf-8") : "";
+  const existing = fs19.existsSync(filePath) ? fs19.readFileSync(filePath, "utf-8") : "";
   const stripped = stripGuideSection(existing);
   const newContent = stripped.trimEnd() + section;
-  fs20.mkdirSync(path30.dirname(filePath), { recursive: true });
-  fs20.writeFileSync(filePath, newContent, "utf-8");
+  fs19.mkdirSync(path29.dirname(filePath), { recursive: true });
+  fs19.writeFileSync(filePath, newContent, "utf-8");
 }
 function stripGuideSection(content) {
   const start2 = content.indexOf(GUIDE_MARKER_START);
@@ -27949,7 +27681,7 @@ function stripGuideSection(content) {
 }
 function writeRootGuideDelegator(projectRoot2, targetType) {
   if (targetType === "claude") {
-    const filePath = path30.join(projectRoot2, "CLAUDE.md");
+    const filePath = path29.join(projectRoot2, "CLAUDE.md");
     const content = `@.claude/CLAUDE.md
 
 # Wairon SDD Project
@@ -27962,42 +27694,42 @@ To design or modify the system, invoke the **\`sdd-architect\`** skill
 (in \`.claude/skills/\`). Author and validate specs with the \`sdd_*\` MCP tools;
 the \`wairon\` CLI is the human developer's tool, not yours.
 `;
-    fs20.writeFileSync(filePath, content, "utf-8");
+    fs19.writeFileSync(filePath, content, "utf-8");
   } else if (targetType === "gemini" || targetType === "agy") {
-    const filePath = path30.join(projectRoot2, "GEMINI.md");
+    const filePath = path29.join(projectRoot2, "GEMINI.md");
     const content = `# Wairon SDD Project
 ${GUIDE_MARKER_START}
 ${versionStamp()}
 ${LOCAL_GUIDE_BODY}
 ${GUIDE_MARKER_END}
 `;
-    fs20.writeFileSync(filePath, content, "utf-8");
+    fs19.writeFileSync(filePath, content, "utf-8");
   } else if (targetType === "cursor") {
-    const filePath = path30.join(projectRoot2, ".cursorrules");
+    const filePath = path29.join(projectRoot2, ".cursorrules");
     const content = `# Wairon SDD Project
 
 This project uses the Wairon Spec-Driven Development (SDD) framework.
 
 Refer to the rules in [.cursor/rules/](.cursor/rules/) for full instructions.
 `;
-    fs20.writeFileSync(filePath, content, "utf-8");
+    fs19.writeFileSync(filePath, content, "utf-8");
   } else if (targetType === "copilot") {
-    const filePath = path30.join(projectRoot2, ".github", "copilot-instructions.md");
-    fs20.mkdirSync(path30.dirname(filePath), { recursive: true });
+    const filePath = path29.join(projectRoot2, ".github", "copilot-instructions.md");
+    fs19.mkdirSync(path29.dirname(filePath), { recursive: true });
     const content = `# Wairon SDD Project
 
 This project uses the Wairon Spec-Driven Development (SDD) framework.
 
 Refer to the prompts in [.github/prompts/](.github/prompts/) for instructions.
 `;
-    fs20.writeFileSync(filePath, content, "utf-8");
+    fs19.writeFileSync(filePath, content, "utf-8");
   } else if (targetType === "codex") {
-    const filePath = path30.join(projectRoot2, ".codexrules");
+    const filePath = path29.join(projectRoot2, ".codexrules");
     const content = `# Wairon SDD Project
 
 Refer to [.codex/agents/](.codex/agents/) for full instructions.
 `;
-    fs20.writeFileSync(filePath, content, "utf-8");
+    fs19.writeFileSync(filePath, content, "utf-8");
   }
 }
 function reinjectLocalGuides(projectRoot2, targetTypes) {
@@ -28013,13 +27745,13 @@ function reinjectLocalGuides(projectRoot2, targetTypes) {
   }
   return written;
 }
-var fs20, os6, path30, GUIDE_MARKER_START, GUIDE_MARKER_END, GLOBAL_GUIDE_BODY, LOCAL_GUIDE_BODY, GUIDE_TARGETS;
+var fs19, os6, path29, GUIDE_MARKER_START, GUIDE_MARKER_END, GLOBAL_GUIDE_BODY, LOCAL_GUIDE_BODY, GUIDE_TARGETS;
 var init_ai_guide = __esm({
   "src/utils/ai-guide.ts"() {
     "use strict";
-    fs20 = __toESM(require("fs"));
+    fs19 = __toESM(require("fs"));
     os6 = __toESM(require("os"));
-    path30 = __toESM(require("path"));
+    path29 = __toESM(require("path"));
     init_stamp();
     GUIDE_MARKER_START = "<!-- wairon-guide-start -->";
     GUIDE_MARKER_END = "<!-- wairon-guide-end -->";
@@ -28214,263 +27946,34 @@ var init_context = __esm({
   }
 });
 
-// src/core/index.ts
-function resolveDomains2() {
-  return resolveDomains();
-}
-function addDomain(domain) {
-  registerDomain(domain);
-}
-function removeDomain(id) {
-  unregisterDomain(id);
-}
-function loadProjectConfig() {
-  return projectConfigRepository.load();
-}
-function projectConfigExists() {
-  return projectConfigRepository.exists();
-}
-var init_core = __esm({
-  "src/core/index.ts"() {
-    "use strict";
-    init_project_config();
-    init_domain_projector();
-    init_domain_curator();
-    init_detection();
-    init_templates();
-    init_validation();
-    init_extensions();
-    init_variants();
-    init_rules();
-    init_specs2();
-    init_provision();
-    init_diagram();
-    init_lockfile();
-    init_statehash();
-    init_agent_resolver();
-    init_skills();
-    init_surfaces();
-    init_openapi();
-    init_packstore();
-    init_treetransfer();
-    init_extensions();
-    init_agent_resolver();
-    init_generate();
-    init_treetransfer();
-    init_provision();
-    init_stereotype_migration();
-    init_narrative_repair();
-    init_approval();
-    init_approver();
-    init_specs2();
-    init_project_config();
-    init_execution_profile();
-    init_budget_policy();
-    init_ai_guide();
-    init_stamp();
-    init_context();
-  }
-});
-
-// src/commands/status.ts
-async function runStatus(options = {}) {
-  assertProjectInitialized();
-  scanAllSpecs({ recursive: options.recursive ?? true });
-  const system = loadSystemSpec();
-  const loaderErrors = getLoaderIssues();
-  if (loaderErrors.length > 0) {
-    logger.error("Failed to parse specification files:");
-    for (const issue2 of loaderErrors) {
-      const prefix = issue2.specId ? import_chalk4.default.gray(`[${issue2.specId}] `) : "";
-      logger.error(`${prefix}[${issue2.code}] ${issue2.message}`);
-    }
-    process.exit(1);
-  }
-  let subsystems = loadSubsystemSpecs();
-  let components = loadComponentSpecs();
-  let interfaces = loadInterfaceSpecs();
-  let implementations = loadImplementationSpecs();
-  if (options.subsystem) {
-    subsystems = subsystems.filter((s) => s.id === options.subsystem || s.id.startsWith(`${options.subsystem}::`));
-    components = components.filter((c) => c.subsystem === options.subsystem || c.subsystem.startsWith(`${options.subsystem}::`));
-    interfaces = interfaces.filter((i) => {
-      const c = components.find((comp) => comp.id === i.component);
-      return c !== void 0;
-    });
-    implementations = implementations.filter((im) => {
-      const inf = interfaces.find((i) => i.id === im.contract);
-      return inf !== void 0;
-    });
-  }
-  if (!system) {
-    logger.error("L0 System specification (system.yaml) is missing. Run `wairon init` first.");
-    process.exit(1);
-  }
-  logger.header("Architecture Status Dashboard");
-  logger.blank();
-  const componentScores = /* @__PURE__ */ new Map();
-  for (const comp of components) {
-    let score = 20;
-    const intf = interfaces.find((i) => i.component === comp.id);
-    if (intf) {
-      score += 30;
-    }
-    const impl = implementations.find((im) => intf && im.contract === intf.id);
-    if (impl) {
-      score += 30;
-      const sourceFiles = implementationSourceFiles(impl);
-      if (sourceFiles.length > 0 && sourceFiles.every((f) => pathExists(fromProjectRoot(f)))) {
-        score += 20;
-      }
-    }
-    const isDraft = comp.status === "draft" || comp.status === "design" || intf && (intf.status === "draft" || intf.status === "design") || impl && (impl.status === "draft" || impl.status === "design");
-    if (isDraft) {
-      score = Math.min(score, 50);
-    }
-    componentScores.set(comp.id, score);
-  }
-  const getSubsystemScore = (subId) => {
-    const sub = subsystems.find((s) => s.id === subId);
-    if (!sub) return 0;
-    const subComps = components.filter((c) => c.subsystem === subId);
-    if (subComps.length === 0) return 0;
-    const totalScore = subComps.reduce((acc, c) => acc + (componentScores.get(c.id) ?? 0), 0);
-    let avg = Math.round(totalScore / subComps.length);
-    if (sub.status === "draft" || sub.status === "design") {
-      avg = Math.min(avg, 50);
-    }
-    return avg;
+// src/core/status.ts
+function fillDecor(decor) {
+  return {
+    structure: decor?.structure ?? asWritten,
+    emphasis: decor?.emphasis ?? asWritten,
+    layer: decor?.layer ?? ((_kind, text2) => text2),
+    score: decor?.score ?? ((_pct, text2) => text2),
+    draft: decor?.draft ?? asWritten,
+    present: decor?.present ?? asWritten,
+    missing: decor?.missing ?? asWritten
   };
-  const totalSubsystemsScore = subsystems.reduce((acc, s) => acc + getSubsystemScore(s.id), 0);
-  const systemScore = subsystems.length > 0 ? Math.round(totalSubsystemsScore / subsystems.length) : 0;
-  const systemColor = systemScore === 100 ? import_chalk4.default.green : systemScore >= 50 ? import_chalk4.default.yellow : import_chalk4.default.red;
-  console.log(`${import_chalk4.default.bold.blue("\u25CF System:")} ${import_chalk4.default.bold(system.name)} ${systemColor(`(${systemScore}% Complete)`)}`);
-  for (let i = 0; i < subsystems.length; i++) {
-    const sub = subsystems[i];
-    const isLastSub = i === subsystems.length - 1;
-    const subPrefix = isLastSub ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-    const subIndent = isLastSub ? "    " : "\u2502   ";
-    const subScore = getSubsystemScore(sub.id);
-    const subStatusStr = sub.status !== "complete" ? import_chalk4.default.yellow(` [${sub.status}]`) : "";
-    const subScoreColor = subScore === 100 ? import_chalk4.default.green : subScore >= 50 ? import_chalk4.default.yellow : import_chalk4.default.red;
-    console.log(`${import_chalk4.default.gray(subPrefix)}${import_chalk4.default.bold.cyan(`[Subsystem] ${sub.id}`)}${subStatusStr} ${subScoreColor(`(${subScore}%)`)}`);
-    const subComps = components.filter((c) => c.subsystem === sub.id);
-    for (let j = 0; j < subComps.length; j++) {
-      const comp = subComps[j];
-      const isLastComp = j === subComps.length - 1;
-      const compPrefix = isLastComp ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-      const compIndent = isLastComp ? "    " : "\u2502   ";
-      const compScore = componentScores.get(comp.id) ?? 0;
-      const compStatusStr = comp.status !== "complete" ? import_chalk4.default.yellow(` [${comp.status}]`) : "";
-      const compScoreColor = compScore === 100 ? import_chalk4.default.green : compScore >= 50 ? import_chalk4.default.yellow : import_chalk4.default.red;
-      console.log(`${import_chalk4.default.gray(subIndent + compPrefix)}${import_chalk4.default.magenta(`[Component: ${comp.componentType}] ${comp.id}`)}${compStatusStr} ${compScoreColor(`(${compScore}%)`)}`);
-      const intf = interfaces.find((inf) => inf.component === comp.id);
-      const impl = implementations.find((im) => intf && im.contract === intf.id);
-      const intfPrefix = intf && impl ? "\u251C\u2500\u2500 " : "\u2514\u2500\u2500 ";
-      if (intf) {
-        const intfStatusStr = intf.status !== "complete" ? import_chalk4.default.yellow(` [${intf.status}]`) : "";
-        console.log(`${import_chalk4.default.gray(subIndent + compIndent + intfPrefix)}${import_chalk4.default.blue(`Interface: ${intf.id}`)}${intfStatusStr} (${intf.methods.length} methods)`);
-      } else {
-        console.log(`${import_chalk4.default.gray(subIndent + compIndent + intfPrefix)}${import_chalk4.default.red("Interface: Missing (-30%)")}`);
-      }
-      if (impl) {
-        const implStatusStr = impl.status !== "complete" ? import_chalk4.default.yellow(` [${impl.status}]`) : "";
-        const methodsWithOwnPath = impl.methods.filter((m) => m.sourcePath);
-        let pathStr;
-        if (impl.sourcePath) {
-          pathStr = pathExists(fromProjectRoot(impl.sourcePath)) ? import_chalk4.default.green(` -> ${impl.sourcePath}`) : import_chalk4.default.red(` -> ${impl.sourcePath} (File Missing!)`);
-        } else if (methodsWithOwnPath.length > 0) {
-          pathStr = "";
-        } else {
-          pathStr = import_chalk4.default.gray(" (No source path)");
-        }
-        console.log(`${import_chalk4.default.gray(subIndent + compIndent + "\u2514\u2500\u2500 ")}${import_chalk4.default.green(`Implementation: ${impl.id}`)}${implStatusStr}${pathStr}`);
-        const methodIndent = subIndent + compIndent + "    ";
-        for (let k = 0; k < methodsWithOwnPath.length; k++) {
-          const method2 = methodsWithOwnPath[k];
-          const isLastMethod = k === methodsWithOwnPath.length - 1;
-          const methodPrefix = isLastMethod ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-          const methodPath = method2.sourcePath;
-          const methodLine = pathExists(fromProjectRoot(methodPath)) ? import_chalk4.default.green(`method ${method2.name} -> ${methodPath}`) : import_chalk4.default.red(`method ${method2.name} -> ${methodPath} (File Missing!)`);
-          console.log(`${import_chalk4.default.gray(methodIndent + methodPrefix)}${methodLine}`);
-        }
-      } else {
-        console.log(`${import_chalk4.default.gray(subIndent + compIndent + "\u2514\u2500\u2500 ")}${import_chalk4.default.red("Implementation: Missing (-30%)")}`);
-      }
-    }
-  }
-  const lock = lockReport();
-  if (lock.text.trim()) {
-    logger.blank();
-    if (lock.drifted) logger.warn(lock.text.trim());
-    else logger.info(lock.text.trim());
-  }
-  logger.blank();
-}
-function lockLine() {
-  return lockReport().text;
-}
-function lockReport() {
-  const quiet = { text: "", drifted: false };
-  try {
-    const approval = approvalRecord();
-    if (!approval) return quiet;
-    const by = describeApprover(approval.lockedBy);
-    const moved = movedChildren(loadSubsystemSpecs());
-    const childNote = moved.length ? `
-${moved.length} chained child project(s) moved since approval: ${moved.map((m) => m.id).join(", ")}.` : "";
-    const diff = diffAgainstApproval();
-    if (!diff) {
-      return {
-        text: `
-Approved: ${approval.lockedAt} by ${by} \u2014 this lock predates per-spec approval, so drift is only visible at whole-tree level. Re-lock to record it.${childNote}
-`,
-        drifted: moved.length > 0
-      };
-    }
-    if (diffSize(diff) === 0) {
-      return {
-        text: `
-Approved: ${approval.lockedAt} by ${by} \u2014 no spec has changed since.${childNote}
-`,
-        drifted: moved.length > 0
-      };
-    }
-    const parts = [];
-    if (diff.changed.length) parts.push(`${diff.changed.length} changed`);
-    if (diff.added.length) parts.push(`${diff.added.length} added`);
-    if (diff.removed.length) parts.push(`${diff.removed.length} removed`);
-    const named = [...diff.changed, ...diff.added, ...diff.removed].slice(0, 5);
-    const rest = diffSize(diff) - named.length;
-    const n = diffSize(diff);
-    const noun = `${n} spec${n === 1 ? "" : "s"}`;
-    const headline = parts.length === 1 ? `${noun} ${parts[0].slice(String(diffSize(diff)).length + 1)} since approval` : `${noun} changed since approval (${parts.join(", ")})`;
-    return {
-      text: `
-${headline} \u2014 approved ${approval.lockedAt} by ${by}:
-` + named.map((p) => `  ${p}`).join("\n") + (rest > 0 ? `
-  \u2026 and ${rest} more` : "") + childNote + "\n",
-      drifted: true
-    };
-  } catch {
-    return quiet;
-  }
 }
-function getStatusReport(options = {}) {
+function getStatusReport(options = {}, decor) {
+  const mark = fillDecor(decor);
   scanAllSpecs({ recursive: options.recursive ?? true });
   const system = loadSystemSpec();
   const loaderErrors = getLoaderIssues();
   if (loaderErrors.length > 0) {
     let errText2 = "Failed to parse specification files:\n";
     for (const issue2 of loaderErrors) {
-      const prefix = issue2.specId ? `[${issue2.specId}] ` : "";
+      const prefix = issue2.specId ? mark.structure(`[${issue2.specId}] `) : "";
       errText2 += `${prefix}[${issue2.code}] ${issue2.message}
 `;
     }
-    return errText2;
+    return { text: errText2, failed: true };
   }
   if (!system) {
-    return "L0 System specification (system.yaml) is missing.";
+    return { text: "L0 System specification (system.yaml) is missing.", failed: true };
   }
   let subsystems = loadSubsystemSpecs();
   let components = loadComponentSpecs();
@@ -28524,7 +28027,7 @@ function getStatusReport(options = {}) {
   };
   const totalSubsystemsScore = subsystems.reduce((acc, s) => acc + getSubsystemScore(s.id), 0);
   const systemScore = subsystems.length > 0 ? Math.round(totalSubsystemsScore / subsystems.length) : 0;
-  output += `\u25CF System: ${system.name} (${systemScore}% Complete)
+  output += `${mark.layer("system", "\u25CF System:")} ${mark.emphasis(system.name)} ${mark.score(systemScore, `(${systemScore}% Complete)`)}
 `;
   for (let i = 0; i < subsystems.length; i++) {
     const sub = subsystems[i];
@@ -28532,8 +28035,8 @@ function getStatusReport(options = {}) {
     const subPrefix = isLastSub ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
     const subIndent = isLastSub ? "    " : "\u2502   ";
     const subScore = getSubsystemScore(sub.id);
-    const subStatusStr = sub.status !== "complete" ? ` [${sub.status}]` : "";
-    output += `${subPrefix}[Subsystem] ${sub.id}${subStatusStr} (${subScore}%)
+    const subStatusStr = sub.status !== "complete" ? mark.draft(` [${sub.status}]`) : "";
+    output += `${mark.structure(subPrefix)}${mark.layer("subsystem", `[Subsystem] ${sub.id}`)}${subStatusStr} ${mark.score(subScore, `(${subScore}%)`)}
 `;
     const subComps = components.filter((c) => c.subsystem === sub.id);
     for (let j = 0; j < subComps.length; j++) {
@@ -28542,32 +28045,32 @@ function getStatusReport(options = {}) {
       const compPrefix = isLastComp ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
       const compIndent = isLastComp ? "    " : "\u2502   ";
       const compScore = componentScores.get(comp.id) ?? 0;
-      const compStatusStr = comp.status !== "complete" ? ` [${comp.status}]` : "";
-      output += `${subIndent}${compPrefix}[Component: ${comp.componentType}] ${comp.id}${compStatusStr} (${compScore}%)
+      const compStatusStr = comp.status !== "complete" ? mark.draft(` [${comp.status}]`) : "";
+      output += `${mark.structure(subIndent + compPrefix)}${mark.layer("component", `[Component: ${comp.componentType}] ${comp.id}`)}${compStatusStr} ${mark.score(compScore, `(${compScore}%)`)}
 `;
       const intf = interfaces.find((inf) => inf.component === comp.id);
       const impl = implementations.find((im) => intf && im.contract === intf.id);
       const intfPrefix = intf && impl ? "\u251C\u2500\u2500 " : "\u2514\u2500\u2500 ";
       if (intf) {
-        const intfStatusStr = intf.status !== "complete" ? ` [${intf.status}]` : "";
-        output += `${subIndent}${compIndent}${intfPrefix}Interface: ${intf.id}${intfStatusStr} (${intf.methods.length} methods)
+        const intfStatusStr = intf.status !== "complete" ? mark.draft(` [${intf.status}]`) : "";
+        output += `${mark.structure(subIndent + compIndent + intfPrefix)}${mark.layer("interface", `Interface: ${intf.id}`)}${intfStatusStr} (${intf.methods.length} methods)
 `;
       } else {
-        output += `${subIndent}${compIndent}${intfPrefix}Interface: Missing (-30%)
+        output += `${mark.structure(subIndent + compIndent + intfPrefix)}${mark.missing("Interface: Missing (-30%)")}
 `;
       }
       if (impl) {
-        const implStatusStr = impl.status !== "complete" ? ` [${impl.status}]` : "";
+        const implStatusStr = impl.status !== "complete" ? mark.draft(` [${impl.status}]`) : "";
         const methodsWithOwnPath = impl.methods.filter((m) => m.sourcePath);
         let pathStr;
         if (impl.sourcePath) {
-          pathStr = pathExists(fromProjectRoot(impl.sourcePath)) ? ` -> ${impl.sourcePath}` : ` -> ${impl.sourcePath} (File Missing!)`;
+          pathStr = pathExists(fromProjectRoot(impl.sourcePath)) ? mark.present(` -> ${impl.sourcePath}`) : mark.missing(` -> ${impl.sourcePath} (File Missing!)`);
         } else if (methodsWithOwnPath.length > 0) {
           pathStr = "";
         } else {
-          pathStr = " (No source path)";
+          pathStr = mark.structure(" (No source path)");
         }
-        output += `${subIndent}${compIndent}\u2514\u2500\u2500 Implementation: ${impl.id}${implStatusStr}${pathStr}
+        output += `${mark.structure(subIndent + compIndent + "\u2514\u2500\u2500 ")}${mark.layer("implementation", `Implementation: ${impl.id}`)}${implStatusStr}${pathStr}
 `;
         const methodIndent = `${subIndent}${compIndent}    `;
         for (let k = 0; k < methodsWithOwnPath.length; k++) {
@@ -28575,31 +28078,400 @@ function getStatusReport(options = {}) {
           const isLastMethod = k === methodsWithOwnPath.length - 1;
           const methodPrefix = isLastMethod ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
           const methodPath = method2.sourcePath;
-          const fileMissing = !pathExists(fromProjectRoot(methodPath));
-          output += `${methodIndent}${methodPrefix}method ${method2.name} -> ${methodPath}${fileMissing ? " (File Missing!)" : ""}
+          const methodLine = pathExists(fromProjectRoot(methodPath)) ? mark.present(`method ${method2.name} -> ${methodPath}`) : mark.missing(`method ${method2.name} -> ${methodPath} (File Missing!)`);
+          output += `${mark.structure(methodIndent + methodPrefix)}${methodLine}
 `;
         }
       } else {
-        output += `${subIndent}${compIndent}\u2514\u2500\u2500 Implementation: Missing (-30%)
+        output += `${mark.structure(subIndent + compIndent + "\u2514\u2500\u2500 ")}${mark.missing("Implementation: Missing (-30%)")}
 `;
       }
     }
   }
-  output += lockLine();
-  return output;
+  return { text: output, failed: false };
 }
-var import_chalk4;
+var asWritten;
 var init_status = __esm({
-  "src/commands/status.ts"() {
+  "src/core/status.ts"() {
     "use strict";
-    import_chalk4 = __toESM(require("chalk"));
-    init_logger();
-    init_paths();
+    init_specs2();
+    init_specs();
     init_fs();
+    asWritten = (text2) => text2;
+  }
+});
+
+// src/core/index.ts
+function resolveDomains2() {
+  return resolveDomains();
+}
+function addDomain(domain) {
+  registerDomain(domain);
+}
+function removeDomain(id) {
+  unregisterDomain(id);
+}
+function loadProjectConfig() {
+  return projectConfigRepository.load();
+}
+function projectConfigExists() {
+  return projectConfigRepository.exists();
+}
+var init_core = __esm({
+  "src/core/index.ts"() {
+    "use strict";
+    init_project_config();
+    init_domain_projector();
+    init_domain_curator();
+    init_rules();
     init_specs2();
-    init_core();
+    init_provision();
+    init_statehash();
     init_lockfile();
-    init_specs();
+    init_diagram();
+    init_diagram();
+    init_detection();
+    init_extensions();
+    init_packstore();
+    init_agent_resolver();
+    init_generate();
+    init_treetransfer();
+    init_provision();
+    init_stereotype_migration();
+    init_narrative_repair();
+    init_approval();
+    init_approver();
+    init_specs2();
+    init_project_config();
+    init_execution_profile();
+    init_budget_policy();
+    init_ai_guide();
+    init_stamp();
+    init_context();
+    init_status();
+  }
+});
+
+// src/core/instructions.ts
+function governingProfile() {
+  try {
+    return loadProjectConfig4()?.projectType ?? null;
+  } catch {
+    return null;
+  }
+}
+function blockApplies(block, profile) {
+  if (!block.profile || block.profile.length === 0) return true;
+  return profile !== null && block.profile.includes(profile);
+}
+function skillPointers(skills) {
+  if (skills.length === 0) return "(none published by this server)";
+  return skills.map((s) => `- \`${s.resourceUri}\` \u2014 ${s.description || s.name}`).join("\n");
+}
+function waironInstructions(profile, packNames, skills, variants) {
+  return `# wairon \u2014 Spec-Driven Development (SDD)
+
+This server owns one system's **spec tree**: its architecture, specified top-down
+and machine-checked. Author it ONLY through this server's \`sdd_*\` tools \u2014 never by
+writing spec files directly, and never via the \`wairon\` CLI (that is the human
+developer's tool).
+
+## The tree: L0 \u2192 L5
+
+- **L0 System** \u2014 vision, boundaries, global requirements, target language.
+- **L1 Subsystem** \u2014 an isolated service, its \`publicInterfaces\`, its trusted links.
+- **L2 Component** \u2014 ONE building block (\`Portal\`, \`Orchestrator\`, \`Supervisor\`,
+  \`Actor\`, \`Store\`, \`Index\`, \`Query\`, \`Registry\`, \`Adapter\`, \`Observer\`, and
+  \`View\` for UIs) or pattern (\`Repository\`, and \`FeatureComponent\` or
+  \`RouterComponent\` for UIs), plus \`owns\` (a pattern's private members) and
+  \`dependsOn\` (collaborators). Logic is an \`Orchestrator\` whose \`dependencyClass\`
+  (\`pure\` or \`read\`; unset, a workflow) bounds what it may depend on; a gateway is
+  a \`Portal\` with the \`gateway\` variant. \`Specialist\` and \`Gateway\` are retired.
+- **L3 Interface** \u2014 the contract: method signatures with structured \`params\`,
+  plus wire \`endpoint\` bindings for a Portal's methods.
+- **L4 Implementation** \u2014 a concrete realization of one L3 contract: narrative
+  detail level, bound \`technologies\` (the vendor swap seam), optional \`sourcePath\`.
+- **L5 Narrative** \u2014 each method's logic as a FLAT numbered step list; \`call\` steps
+  resolve to real dependency methods, and flow steps jump by step number.
+
+These stereotypes are not labels \u2014 they carry enforced dependency rules (e.g. a
+Portal may not depend on a Store; state lives in a Store, never as fields inside
+an Orchestrator). \`sdd_validate_tree\` is the gate, and it is the authority on
+whether a design is legal.
+
+## Authoring order
+
+1. \`sdd_initialize_system\` (L0), then \`sdd_add_subsystem\` (L1).
+2. Then, **one subsystem at a time**: \`sdd_add_component\` (L2) \u2192 \`sdd_define_interface\`
+   (L3) \u2192 \`sdd_set_endpoints\` for Portals \u2192 \`sdd_write_narrative\` (L4+L5).
+3. Run \`sdd_validate_tree\` as you go \u2014 early and per subsystem, not once at the end.
+   \`sdd_get_status\` reports completeness; \`sdd_get_spec\` reads any spec back as JSON.
+4. Edit granularly with \`sdd_update_spec\` (it renumbers narrative steps and
+   relocates jump targets for you).
+
+## The tool schemas are the field reference
+
+Every \`sdd_*\` tool's input schema is self-describing and authoritative \u2014 read the
+schema rather than guessing field names, and prefer structured \`params\` over prose
+signatures. Specs are ${profile === null ? "validated against the project's configured profile" : `governed by the **\`${profile}\`** profile`}, which decides which stereotypes are legal
+here, which narrative flow constructs the target language supports, and which
+extra rules apply. A subsystem may override the profile for itself.
+
+## Loaded extension packs
+
+${packNames.length === 0 ? "None \u2014 only wairon's built-in doctrine applies." : `${packNames.map((n) => `\`${n}\``).join(", ")} \u2014 these inject profiles, language tables, patterns, and
+additional conformance rules. Their doctrine is enforced by the same gate.`}
+
+${variants.length === 0 ? "" : `## Component variants in play
+
+This project defines variants \u2014 named, base-anchored kinds carrying implementation
+guidance, so every component of the same kind is built alike: ${variants.map((v) => `\`${v.id}\` (a kind of ${v.base})`).join(", ")}.
+Tag a component with \`variant\` where it fits, and read a component's resolved
+guidance and its same-variant siblings from \`sdd_get_spec\` (kind: component).
+
+`}## Read the skills BEFORE authoring
+
+This server publishes its skills as MCP resources. **Read \`wairon-skill://sdd-architect\`
+before you design anything**, and the others when their turn comes \u2014 they carry the
+architecture standard, the narrative step reference, and the review checklist that
+this briefing only points at:
+
+${skillPointers(skills)}
+
+## Delegating implementation
+
+Delegate component work from a LIVE agent brief, never a generated file: discover
+agents via \`listAgents\` (or the \`wairon-agent://\` resources), fetch the target's
+brief with \`sdd_get_agent_brief\`, and spawn a scoped subagent from it \u2014 its
+\`instructions\` as prompt, its \`ownedPaths\` as write fence. Briefs are composed
+from the current spec tree on every call, so a re-lock never requires a session
+restart \u2014 fetch fresh per delegation. \`wairon-skill://sdd-delegate\` carries the
+full flow.`;
+}
+function buildServerInstructions() {
+  const profile = governingProfile();
+  let skills = [];
+  let blocks = [];
+  let packNames = [];
+  const variants = [];
+  try {
+    skills = listSkillResources();
+    const extensions = loadProjectExtensions2();
+    blocks = extensions.instructions;
+    packNames = extensions.packNames;
+  } catch {
+  }
+  const sections = [waironInstructions(profile, packNames, skills, variants)];
+  for (const block of blocks) {
+    if (!blockApplies(block, profile)) continue;
+    sections.push(`## From pack "${block.pack}"
+
+${block.text.trim()}`);
+  }
+  return sections.join("\n\n");
+}
+var init_instructions = __esm({
+  "src/core/instructions.ts"() {
+    "use strict";
+    init_skills();
+  }
+});
+
+// src/core/skills.ts
+function loadProjectExtensions2() {
+  return loadProjectExtensions();
+}
+function loadProjectConfig4() {
+  return loadProjectConfig();
+}
+function packSkillId(skill) {
+  return `${packNamespace(skill.pack)}-${skill.id}`;
+}
+function packNamespace(pack) {
+  return pack.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function extensionsFor(builtin, packSkills) {
+  return packSkills.filter((s) => s.extends === builtin && fs20.existsSync(s.sourcePath));
+}
+function composeBuiltinSkill(name, packSkills) {
+  const srcPath = skillTemplatePath(name);
+  const base = fs20.existsSync(srcPath) ? fs20.readFileSync(srcPath, "utf-8") : "";
+  const sections = extensionsFor(name, packSkills);
+  if (sections.length === 0) return base;
+  const parts = [base.trimEnd()];
+  for (const section of sections) {
+    const body = fs20.readFileSync(section.sourcePath, "utf-8").replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+    parts.push(`## Platform: ${section.pack}`, body.trim());
+  }
+  return `${parts.join("\n\n")}
+`;
+}
+function readFrontmatter(raw, fallbackName) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
+  const block = match ? match[1] : "";
+  const field = (key) => {
+    const m = new RegExp(`^${key}:\\s*(.*)$`, "m").exec(block);
+    return m ? m[1].trim() : "";
+  };
+  return { name: field("name") || fallbackName, description: field("description") };
+}
+function builtinSkillsDir() {
+  return path31.resolve(__dirname, "..", "templates", "skills");
+}
+function skillTemplatePath(name) {
+  return path31.join(builtinSkillsDir(), `${name}.md`);
+}
+function skillDestPath(type, destDir, name) {
+  if (type === "claude" || type === "codex" || type === "gemini" || type === "agy") {
+    return path31.join(destDir, name, "SKILL.md");
+  }
+  return path31.join(destDir, `${name}.md`);
+}
+function skillsDirForTarget(type) {
+  switch (type) {
+    case "claude":
+      return fromProjectRoot(".claude", "skills");
+    case "gemini":
+    // Gemini-based Antigravity
+    case "agy":
+    case "codex":
+      return fromProjectRoot(".agents", "skills");
+    case "cursor":
+      return fromProjectRoot(".cursor", "skills");
+    default:
+      return null;
+  }
+}
+function listSkillNames() {
+  return [...SKILL_NAMES];
+}
+function exportSddSkills(targetTypes) {
+  const types = targetTypes ?? activeTargetTypes2();
+  const destinations = [];
+  const skipped = [];
+  let fileCount = 0;
+  const packSkills = loadProjectExtensions2().skills;
+  for (const type of types) {
+    const destDir = skillsDirForTarget(type);
+    if (!destDir) {
+      skipped.push(type);
+      continue;
+    }
+    ensureDir(destDir);
+    destinations.push(destDir);
+    for (const name of SKILL_NAMES) {
+      if (!fs20.existsSync(skillTemplatePath(name))) continue;
+      const content = composeBuiltinSkill(name, packSkills.filter((s) => s.targets.includes(type)));
+      const destPath = skillDestPath(type, destDir, name);
+      ensureDir(path31.dirname(destPath));
+      fs20.writeFileSync(destPath, content, "utf-8");
+      fileCount++;
+    }
+    for (const skill of packSkills) {
+      if (skill.extends !== void 0) continue;
+      if (!skill.targets.includes(type)) continue;
+      if (!fs20.existsSync(skill.sourcePath)) continue;
+      const id = packSkillId(skill);
+      const content = fs20.readFileSync(skill.sourcePath, "utf-8");
+      const destPath = skillDestPath(type, destDir, id);
+      ensureDir(path31.dirname(destPath));
+      fs20.writeFileSync(destPath, content, "utf-8");
+      fileCount++;
+    }
+  }
+  return { destinations, fileCount, skipped };
+}
+function checkSkillFreshness(type) {
+  const dir = skillsDirForTarget(type);
+  const result = { dir, missing: [], stale: [], ok: [] };
+  if (!dir) return result;
+  const packSkills = loadProjectExtensions2().skills.filter((s) => s.targets.includes(type));
+  for (const name of SKILL_NAMES) {
+    const destPath = skillDestPath(type, dir, name);
+    if (!fs20.existsSync(destPath)) {
+      result.missing.push(name);
+      continue;
+    }
+    const want = composeBuiltinSkill(name, packSkills);
+    const have = fs20.readFileSync(destPath, "utf-8");
+    if (have === want) result.ok.push(name);
+    else result.stale.push(name);
+  }
+  return result;
+}
+function activeTargetTypes2() {
+  const config = loadProjectConfig4();
+  if (!config) return [];
+  return activeTargetTypes(config);
+}
+function readSkillFrontmatter(name) {
+  return readFrontmatter(fs20.readFileSync(skillTemplatePath(name), "utf-8"), name);
+}
+function listSkillResources() {
+  const builtin = RESOURCE_SKILL_IDS.map((id) => {
+    const fm = readSkillFrontmatter(id);
+    return {
+      id,
+      name: fm.name,
+      description: fm.description,
+      version: WAIRON_VERSION,
+      resourceUri: `${SKILL_RESOURCE_SCHEME}://${id}`,
+      defaultForHostedMcp: true
+    };
+  });
+  const pack = loadProjectExtensions2().skills.filter((s) => s.extends === void 0 && fs20.existsSync(s.sourcePath)).map((skill) => {
+    const id = packSkillId(skill);
+    const fm = readFrontmatter(fs20.readFileSync(skill.sourcePath, "utf-8"), id);
+    return {
+      id,
+      name: fm.name,
+      description: fm.description,
+      version: skill.packVersion ?? WAIRON_VERSION,
+      resourceUri: `${SKILL_RESOURCE_SCHEME}://${id}`,
+      defaultForHostedMcp: true
+    };
+  });
+  return [...builtin, ...pack];
+}
+function readSkillResource(resourceId) {
+  const packSkills = loadProjectExtensions2().skills;
+  if (SKILL_NAMES.includes(resourceId)) return composeBuiltinSkill(resourceId, packSkills);
+  const packSkill = packSkills.find((s) => s.extends === void 0 && packSkillId(s) === resourceId);
+  if (packSkill) return fs20.readFileSync(packSkill.sourcePath, "utf-8");
+  return fs20.readFileSync(skillTemplatePath(resourceId), "utf-8");
+}
+function listResources() {
+  return listSkillResources();
+}
+function buildServerInstructions2() {
+  return buildServerInstructions();
+}
+function readResource(resourceId) {
+  const known = listSkillResources().some((d) => d.id === resourceId);
+  if (!known) throw new SkillResourceNotFoundError(resourceId);
+  return readSkillResource(resourceId);
+}
+var path31, fs20, SKILL_NAMES, SKILL_RESOURCE_SCHEME, RESOURCE_SKILL_IDS, SkillResourceNotFoundError;
+var init_skills = __esm({
+  "src/core/skills.ts"() {
+    "use strict";
+    path31 = __toESM(require("path"));
+    fs20 = __toESM(require("fs"));
+    init_fs();
+    init_defaults();
+    init_project();
+    init_extensions();
+    init_instructions();
+    init_core();
+    SKILL_NAMES = ["sdd-architect", "sdd-narrative", "sdd-auditor", "sdd-implement", "sdd-delegate"];
+    SKILL_RESOURCE_SCHEME = "wairon-skill";
+    RESOURCE_SKILL_IDS = [...SKILL_NAMES].sort();
+    SkillResourceNotFoundError = class extends Error {
+      constructor(resourceId) {
+        super(`Unknown SDD skill resource id: "${resourceId}".`);
+        this.name = "SkillResourceNotFoundError";
+      }
+    };
   }
 });
 
@@ -30143,7 +30015,9 @@ function createMcpServer(options = {}) {
           subsystem,
           recursive: recursive ?? true
         });
-        return text(`${statusFamilyContext()}${report2}`);
+        const family = statusFamilyContext();
+        const verdict = approvalVerdict();
+        return text(`${family}${report2.text}${verdict.text}`);
       } catch (e) {
         return errText(String(e));
       }
@@ -30342,7 +30216,7 @@ var init_server = __esm({
     init_fs();
     init_yaml();
     init_errors();
-    init_status();
+    init_core();
     init_core();
     init_defaults();
     init_narrative_labels();
@@ -30695,7 +30569,7 @@ async function runMcpInstall(options = {}) {
     const desiredEntry = options.hostedUrl ? hostedMcpEntry(options) : useDirectNode ? { command: "node", args: [scriptPath, "mcp", "serve"], env } : { command: "wairon", args: ["mcp", "serve"], env };
     const existingEntry = mcpServers["wairon"];
     if (existingEntry && JSON.stringify(existingEntry) === JSON.stringify(desiredEntry)) {
-      logger.info(`wairon MCP server already registered (up to date) for ${agentLabel} in ${import_chalk5.default.gray(settingsPath)}.`);
+      logger.info(`wairon MCP server already registered (up to date) for ${agentLabel} in ${import_chalk4.default.gray(settingsPath)}.`);
       continue;
     }
     const wasStale = !!existingEntry;
@@ -30703,7 +30577,7 @@ async function runMcpInstall(options = {}) {
     settings["mcpServers"] = mcpServers;
     if (!fs22.existsSync(configBase)) fs22.mkdirSync(configBase, { recursive: true });
     fs22.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-    logger.success(`wairon MCP server ${wasStale ? "updated (was stale)" : "registered"} for ${agentLabel} in ${import_chalk5.default.cyan(settingsPath)}.`);
+    logger.success(`wairon MCP server ${wasStale ? "updated (was stale)" : "registered"} for ${agentLabel} in ${import_chalk4.default.cyan(settingsPath)}.`);
     logger.blank();
     logger.info("AI tools using this config will have access to these wairon tools:");
     logger.info("  listAgents \xB7 getAgent \xB7 listDomains \xB7 validateTopology \xB7 getProjectConfig");
@@ -30711,13 +30585,13 @@ async function runMcpInstall(options = {}) {
     logger.info("  sdd_write_narrative \xB7 sdd_validate_tree \xB7 sdd_get_status");
     logger.blank();
     const restartApp = backend === "gemini" ? "Antigravity CLI (agy)" : "claude";
-    logger.info(`Restart ${import_chalk5.default.bold(restartApp)} (or reload MCP servers) to activate.`);
+    logger.info(`Restart ${import_chalk4.default.bold(restartApp)} (or reload MCP servers) to activate.`);
     if (backend === "claude" && !useGlobal) {
       logger.warn('Claude shows project .mcp.json servers as "\u23F8 Pending approval" \u2014 approve wairon once on next launch (or run `claude` and accept the trust prompt).');
     }
     if (backend === "gemini" && !useGlobal) {
       logger.warn("Note: Antigravity (agy) reads MCP servers from its global ~/.gemini/antigravity-cli/mcp_config.json, not this project file.");
-      logger.warn("If the agent cannot see the sdd_* tools, run: " + import_chalk5.default.bold("wairon mcp install --backend gemini --global"));
+      logger.warn("If the agent cannot see the sdd_* tools, run: " + import_chalk4.default.bold("wairon mcp install --backend gemini --global"));
     }
     logger.blank();
   }
@@ -30731,7 +30605,7 @@ async function runMcpStatus() {
   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.info(`${import_chalk4.default.bold("wairon MCP Server")}`);
   logger.blank();
   const checks = [
     { label: "Claude (project)", filePath: claudeProject, fallbackName: ".mcp.json" },
@@ -30741,28 +30615,28 @@ async function runMcpStatus() {
   ];
   for (const { label, filePath, fallbackName } of checks) {
     if (!fs22.existsSync(filePath)) {
-      console.log(`  ${label}: ${import_chalk5.default.gray(`${fallbackName} not found`)}`);
+      console.log(`  ${label}: ${import_chalk4.default.gray(`${fallbackName} not found`)}`);
       continue;
     }
     try {
       const s = JSON.parse(fs22.readFileSync(filePath, "utf8"));
       const registered = !!s["mcpServers"]?.["wairon"];
-      const mark = registered ? import_chalk5.default.green("\u2713 registered") : import_chalk5.default.gray("not registered");
-      console.log(`  ${label}: ${mark}  ${import_chalk5.default.gray(filePath)}`);
+      const mark = registered ? import_chalk4.default.green("\u2713 registered") : import_chalk4.default.gray("not registered");
+      console.log(`  ${label}: ${mark}  ${import_chalk4.default.gray(filePath)}`);
     } catch {
-      console.log(`  ${label}: ${import_chalk5.default.red("parse error")}  ${import_chalk5.default.gray(filePath)}`);
+      console.log(`  ${label}: ${import_chalk4.default.red("parse error")}  ${import_chalk4.default.gray(filePath)}`);
     }
   }
   logger.blank();
-  logger.info(`Project: ${import_chalk5.default.bold(projectConfig.name)}`);
+  logger.info(`Project: ${import_chalk4.default.bold(projectConfig.name)}`);
   logger.blank();
-  logger.info(`To register for Claude: ${import_chalk5.default.bold("wairon mcp install --backend claude")}`);
-  logger.info(`To register for Antigravity (agy): ${import_chalk5.default.bold("wairon mcp install --backend gemini")}`);
-  logger.info(`To start manually: ${import_chalk5.default.bold("wairon mcp serve")}`);
+  logger.info(`To register for Claude: ${import_chalk4.default.bold("wairon mcp install --backend claude")}`);
+  logger.info(`To register for Antigravity (agy): ${import_chalk4.default.bold("wairon mcp install --backend gemini")}`);
+  logger.info(`To start manually: ${import_chalk4.default.bold("wairon mcp serve")}`);
   logger.blank();
   const mcpDir = aiDir("mcp");
   if (fs22.existsSync(mcpDir)) {
-    logger.info(`MCP state dir: ${import_chalk5.default.gray(mcpDir)}`);
+    logger.info(`MCP state dir: ${import_chalk4.default.gray(mcpDir)}`);
   }
 }
 function hostedMcpEntry(options) {
@@ -30783,7 +30657,7 @@ function removeLegacyGlobalPlugin() {
   try {
     if (fs22.existsSync(pluginDir)) {
       fs22.rmSync(pluginDir, { recursive: true, force: true });
-      logger.info(`Removed legacy global Antigravity plugin at ${import_chalk5.default.gray(pluginDir)} (it collides with the wairon MCP server).`);
+      logger.info(`Removed legacy global Antigravity plugin at ${import_chalk4.default.gray(pluginDir)} (it collides with the wairon MCP server).`);
       return true;
     }
   } catch (e) {
@@ -30791,14 +30665,14 @@ function removeLegacyGlobalPlugin() {
   }
   return false;
 }
-var fs22, os7, path33, import_chalk5;
+var fs22, os7, path33, import_chalk4;
 var init_mcp = __esm({
   "src/commands/mcp.ts"() {
     "use strict";
     fs22 = __toESM(require("fs"));
     os7 = __toESM(require("os"));
     path33 = __toESM(require("path"));
-    import_chalk5 = __toESM(require("chalk"));
+    import_chalk4 = __toESM(require("chalk"));
     init_logger();
     init_paths();
     init_core();
@@ -31032,7 +30906,7 @@ function isSupportedAlias(name) {
 
 // src/commands/init.ts
 var path34 = __toESM(require("path"));
-var import_chalk6 = __toESM(require("chalk"));
+var import_chalk5 = __toESM(require("chalk"));
 var import_inquirer = __toESM(require("inquirer"));
 init_logger();
 init_errors();
@@ -31041,7 +30915,7 @@ init_yaml();
 init_paths();
 
 // src/commands/subsystem.ts
-var path31 = __toESM(require("path"));
+var path30 = __toESM(require("path"));
 init_logger();
 init_errors();
 init_fs();
@@ -31057,7 +30931,7 @@ function exportSpecTree2(includeDerived, allowPartial) {
 function importSpecTree2(archive, options) {
   return importSpecTree(archive, options);
 }
-function loadProjectConfig4() {
+function loadProjectConfig3() {
   return loadProjectConfig();
 }
 function createProjectConfig2(config) {
@@ -31150,6 +31024,12 @@ function hasContext2() {
 function derivedDocPaths2() {
   return derivedDocPaths();
 }
+function getStatusReport2(options, decor) {
+  return getStatusReport(options, decor);
+}
+function approvalVerdict2() {
+  return approvalVerdict();
+}
 async function runSubsystemAdd(id, options = {}) {
   logger.header("wairon subsystem add");
   if (!projectConfigExists2()) {
@@ -31179,9 +31059,9 @@ async function runSubsystemAdd(id, options = {}) {
     updatedAt: now
   };
   createChainedSubsystem2(subsystem, displayName);
-  const childDir = path31.resolve(getProjectRoot(), options.projectPath);
+  const childDir = path30.resolve(getProjectRoot(), options.projectPath);
   logger.success(`Added external subsystem "${id}" \u2192 ${options.projectPath}`);
-  logger.info(`Scaffolded child project at ${path31.relative(process.cwd(), childDir) || "."}`);
+  logger.info(`Scaffolded child project at ${path30.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 = {}) {
@@ -31204,9 +31084,9 @@ async function runSubsystemExternalize(id, options = {}) {
     throw new WaironError("--project-path (the subproject destination) is required.");
   }
   externalizeSubsystem(id, options.projectPath);
-  const childDir = path31.resolve(getProjectRoot(), options.projectPath);
+  const childDir = path30.resolve(getProjectRoot(), options.projectPath);
   logger.success(`Externalized subsystem "${id}" \u2192 ${options.projectPath}`);
-  logger.info(`Moved its specs into ${path31.relative(process.cwd(), childDir) || "."} (now a standalone subproject).`);
+  logger.info(`Moved its specs into ${path30.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) {
@@ -31444,10 +31324,10 @@ async function runInitInteractive() {
   logger.blank();
   logger.header("Init summary");
   logger.blank();
-  console.log(`  ${import_chalk6.default.bold("Project:")}  ${projectName}`);
-  console.log(`  ${import_chalk6.default.bold("Profile:")}  ${projectType}`);
-  console.log(`  ${import_chalk6.default.bold("Targets:")}  ${targets.map((t) => t.type).join(", ")}`);
-  console.log(`  ${import_chalk6.default.bold("Guide:")}    Auto-inject local AI rules card (${selectedTypes.filter((t) => ["claude", "gemini", "agy"].includes(t)).join(", ") || "none"})`);
+  console.log(`  ${import_chalk5.default.bold("Project:")}  ${projectName}`);
+  console.log(`  ${import_chalk5.default.bold("Profile:")}  ${projectType}`);
+  console.log(`  ${import_chalk5.default.bold("Targets:")}  ${targets.map((t) => t.type).join(", ")}`);
+  console.log(`  ${import_chalk5.default.bold("Guide:")}    Auto-inject local AI rules card (${selectedTypes.filter((t) => ["claude", "gemini", "agy"].includes(t)).join(", ") || "none"})`);
   logger.blank();
   const { confirmed } = await import_inquirer.default.prompt([
     {
@@ -31786,7 +31666,7 @@ async function runGenerate(options = {}) {
 }
 async function generateLayer(options = {}) {
   assertProjectInitialized();
-  const projectConfig = loadProjectConfig4();
+  const projectConfig = loadProjectConfig3();
   if (!projectConfig) throw new ProjectNotInitializedError();
   const agents = resolveAgentTopology2();
   if (agents.length === 0) {
@@ -31885,6 +31765,7 @@ init_logger();
 init_defaults();
 var path36 = __toESM(require("path"));
 init_core();
+init_lock();
 init_fs();
 init_validation();
 function checkApproval(strict) {
@@ -31979,7 +31860,7 @@ async function runLock(options = {}, gate) {
 }
 
 // src/commands/validate.ts
-var import_chalk7 = __toESM(require("chalk"));
+var import_chalk6 = __toESM(require("chalk"));
 init_logger();
 init_agent_resolver();
 init_paths();
@@ -32049,7 +31930,7 @@ async function runValidate(options = {}) {
     logger.success("Registry is valid.");
   } else {
     for (const issue2 of regResult.issues) {
-      const prefix = issue2.agentId ? import_chalk7.default.gray(`[${issue2.agentId}] `) : "";
+      const prefix = issue2.agentId ? import_chalk6.default.gray(`[${issue2.agentId}] `) : "";
       if (issue2.severity === "error") {
         logger.error(`${prefix}[${issue2.code}] ${issue2.message}`);
         hasErrors = true;
@@ -32084,7 +31965,7 @@ async function runValidate(options = {}) {
       let skippedErrors = 0;
       let skippedWarnings = 0;
       for (const issue2 of sddResult.issues) {
-        const prefix = issue2.specId ? import_chalk7.default.gray(`[${issue2.specId}] `) : "";
+        const prefix = issue2.specId ? import_chalk6.default.gray(`[${issue2.specId}] `) : "";
         if (issue2.severity === "error") {
           hasErrors = true;
           if (errorCount < MAX_PRINT) {
@@ -32118,12 +31999,12 @@ async function runValidate(options = {}) {
   const summary = carriedDebtSummary(projectConfig.rules?.conformance?.carried);
   if (summary) {
     logger.blank();
-    logger.info(import_chalk7.default.yellow(summary.line));
-    for (const note of summary.revisits) logger.info(import_chalk7.default.gray(note));
+    logger.info(import_chalk6.default.yellow(summary.line));
+    for (const note of summary.revisits) logger.info(import_chalk6.default.gray(note));
   }
   logger.blank();
   if (options.ci && waivedWarnings > 0) {
-    logger.info(import_chalk7.default.gray(`${waivedWarnings} draft-related warning(s) (non-fatal in --ci): excluded from the failure decision because the referenced specs are in draft/design status.`));
+    logger.info(import_chalk6.default.gray(`${waivedWarnings} draft-related warning(s) (non-fatal in --ci): excluded from the failure decision because the referenced specs are in draft/design status.`));
   }
   const failOnWarnings = !!options.ci && hasFatalWarnings;
   if (hasErrors || failOnWarnings) {
@@ -32131,7 +32012,7 @@ async function runValidate(options = {}) {
       logger.error("Validation failed: warnings are treated as errors in --ci mode.");
     } else {
       logger.error("Validation failed. Fix the errors above.");
-      logger.info(import_chalk7.default.cyan("Tip: If you need to temporarily bypass an architectural rule, you can override its severity level in your `.wai/project.yaml` config (e.g. `rules.sddRuleSeverity.CIRCULAR_DEPENDENCY: warning`)."));
+      logger.info(import_chalk6.default.cyan("Tip: If you need to temporarily bypass an architectural rule, you can override its severity level in your `.wai/project.yaml` config (e.g. `rules.sddRuleSeverity.CIRCULAR_DEPENDENCY: warning`)."));
     }
     process.exit(1);
   } else {
@@ -32148,7 +32029,7 @@ init_paths();
 init_fs();
 
 // src/commands/list.ts
-var import_chalk8 = __toESM(require("chalk"));
+var import_chalk7 = __toESM(require("chalk"));
 init_logger();
 init_paths();
 async function runList() {
@@ -32166,26 +32047,26 @@ async function runList() {
   }
 }
 function printAgent(agent) {
-  const status2 = agent.status === "active" ? import_chalk8.default.green(agent.status) : agent.status === "draft" ? import_chalk8.default.yellow(agent.status) : import_chalk8.default.gray(agent.status);
-  console.log(`${import_chalk8.default.bold(agent.id)} ${import_chalk8.default.gray(`[${agent.template}]`)} ${status2}`);
+  const status2 = agent.status === "active" ? import_chalk7.default.green(agent.status) : agent.status === "draft" ? import_chalk7.default.yellow(agent.status) : import_chalk7.default.gray(agent.status);
+  console.log(`${import_chalk7.default.bold(agent.id)} ${import_chalk7.default.gray(`[${agent.template}]`)} ${status2}`);
   console.log(`  ${agent.description}`);
   if (agent.ownedPaths.length > 0) {
-    console.log(import_chalk8.default.gray(`  owns: ${agent.ownedPaths.join(", ")}`));
+    console.log(import_chalk7.default.gray(`  owns: ${agent.ownedPaths.join(", ")}`));
   }
   if (agent.tags.length > 0) {
-    console.log(import_chalk8.default.gray(`  tags: ${agent.tags.join(", ")}`));
+    console.log(import_chalk7.default.gray(`  tags: ${agent.tags.join(", ")}`));
   }
   const targetLabels = agent.targets.map((t) => {
     if (typeof t === "string") return t;
     const obj = t;
     return obj.label ? `${obj.type}(${obj.label})` : obj.type;
   });
-  console.log(import_chalk8.default.gray(`  targets: ${targetLabels.join(", ")}`));
+  console.log(import_chalk7.default.gray(`  targets: ${targetLabels.join(", ")}`));
   console.log();
 }
 
 // src/commands/show.ts
-var import_chalk9 = __toESM(require("chalk"));
+var import_chalk8 = __toESM(require("chalk"));
 init_logger();
 init_paths();
 init_errors();
@@ -32198,60 +32079,60 @@ async function runShow(agentId) {
   printAgentDetails(agent);
 }
 function printAgentDetails(agent) {
-  const statusColor = agent.status === "active" ? import_chalk9.default.green : agent.status === "draft" ? import_chalk9.default.yellow : import_chalk9.default.gray;
+  const statusColor = agent.status === "active" ? import_chalk8.default.green : agent.status === "draft" ? import_chalk8.default.yellow : import_chalk8.default.gray;
   logger.header(agent.name);
   console.log();
-  console.log(`${import_chalk9.default.bold("ID")}          ${agent.id}`);
-  console.log(`${import_chalk9.default.bold("Status")}      ${statusColor(agent.status)}`);
-  console.log(`${import_chalk9.default.bold("Template")}    ${agent.template}`);
+  console.log(`${import_chalk8.default.bold("ID")}          ${agent.id}`);
+  console.log(`${import_chalk8.default.bold("Status")}      ${statusColor(agent.status)}`);
+  console.log(`${import_chalk8.default.bold("Template")}    ${agent.template}`);
   if (agent.bundleOrigin) {
-    console.log(`${import_chalk9.default.bold("Bundle")}      ${agent.bundleOrigin}`);
+    console.log(`${import_chalk8.default.bold("Bundle")}      ${agent.bundleOrigin}`);
   }
   if (agent.domainRoot) {
-    console.log(`${import_chalk9.default.bold("Domain")}      ${agent.domainRoot}`);
+    console.log(`${import_chalk8.default.bold("Domain")}      ${agent.domainRoot}`);
   }
   console.log();
-  console.log(`${import_chalk9.default.bold("Description")}`);
+  console.log(`${import_chalk8.default.bold("Description")}`);
   console.log(`  ${agent.description}`);
   console.log();
-  console.log(`${import_chalk9.default.bold("Reason")}`);
+  console.log(`${import_chalk8.default.bold("Reason")}`);
   console.log(`  ${agent.creationReason}`);
   console.log();
   if (agent.ownedPaths.length > 0) {
-    console.log(`${import_chalk9.default.bold("Owned paths")}`);
+    console.log(`${import_chalk8.default.bold("Owned paths")}`);
     for (const p of agent.ownedPaths) {
-      console.log(`  ${import_chalk9.default.cyan(p)}`);
+      console.log(`  ${import_chalk8.default.cyan(p)}`);
     }
     console.log();
   }
   if (agent.readPaths.length > 0) {
-    console.log(`${import_chalk9.default.bold("Read paths")}`);
+    console.log(`${import_chalk8.default.bold("Read paths")}`);
     for (const p of agent.readPaths) {
-      console.log(`  ${import_chalk9.default.gray(p)}`);
+      console.log(`  ${import_chalk8.default.gray(p)}`);
     }
     console.log();
   }
   if (agent.writePaths.length > 0) {
-    console.log(`${import_chalk9.default.bold("Write paths")}`);
+    console.log(`${import_chalk8.default.bold("Write paths")}`);
     for (const p of agent.writePaths) {
-      console.log(`  ${import_chalk9.default.gray(p)}`);
+      console.log(`  ${import_chalk8.default.gray(p)}`);
     }
     console.log();
   }
   if (agent.tags.length > 0) {
-    console.log(`${import_chalk9.default.bold("Tags")}        ${agent.tags.map((t) => import_chalk9.default.magenta(t)).join(", ")}`);
+    console.log(`${import_chalk8.default.bold("Tags")}        ${agent.tags.map((t) => import_chalk8.default.magenta(t)).join(", ")}`);
   }
   if (agent.dependencies.length > 0) {
-    console.log(`${import_chalk9.default.bold("Depends on")}  ${agent.dependencies.join(", ")}`);
+    console.log(`${import_chalk8.default.bold("Depends on")}  ${agent.dependencies.join(", ")}`);
   }
   const targetLabels = agent.targets.map((t) => {
     if (typeof t === "string") return t;
     const obj = t;
     return obj.label ? `${obj.type}(${obj.label})` : obj.type;
   });
-  console.log(`${import_chalk9.default.bold("Targets")}     ${targetLabels.join(", ")}`);
+  console.log(`${import_chalk8.default.bold("Targets")}     ${targetLabels.join(", ")}`);
   console.log();
-  console.log(import_chalk9.default.gray(`Created: ${agent.createdAt}  Updated: ${agent.updatedAt}`));
+  console.log(import_chalk8.default.gray(`Created: ${agent.createdAt}  Updated: ${agent.updatedAt}`));
 }
 
 // src/cli/index.ts
@@ -32595,8 +32476,60 @@ function cleanStaleBinary(oldPath) {
 }
 var isNewer = isNewerVersion;
 
-// src/cli/index.ts
-init_status();
+// src/commands/status.ts
+var import_chalk9 = __toESM(require("chalk"));
+init_logger();
+init_paths();
+var LAYER_COLOUR = {
+  system: (text2) => import_chalk9.default.bold.blue(text2),
+  subsystem: (text2) => import_chalk9.default.bold.cyan(text2),
+  component: (text2) => import_chalk9.default.magenta(text2),
+  interface: (text2) => import_chalk9.default.blue(text2),
+  implementation: (text2) => import_chalk9.default.green(text2)
+};
+function scoreColour(pct) {
+  if (pct === 100) return (text2) => import_chalk9.default.green(text2);
+  if (pct >= 50) return (text2) => import_chalk9.default.yellow(text2);
+  return (text2) => import_chalk9.default.red(text2);
+}
+var TERMINAL_DECOR = {
+  structure: (text2) => import_chalk9.default.gray(text2),
+  emphasis: (text2) => import_chalk9.default.bold(text2),
+  layer: (kind, text2) => (LAYER_COLOUR[kind] ?? ((plain) => plain))(text2),
+  score: (pct, text2) => scoreColour(pct)(text2),
+  draft: (text2) => import_chalk9.default.yellow(text2),
+  present: (text2) => import_chalk9.default.green(text2),
+  missing: (text2) => import_chalk9.default.red(text2)
+};
+var NO_SYSTEM_SPEC = "L0 System specification (system.yaml) is missing.";
+var INIT_HINT = " Run `wairon init` first.";
+function refuseUnreadableTree(explanation) {
+  const lines = withoutTrailingNewline(explanation).split("\n");
+  const last = lines.length - 1;
+  if (lines[last] === NO_SYSTEM_SPEC) lines[last] += INIT_HINT;
+  for (const line2 of lines) logger.error(line2);
+  process.exit(1);
+}
+function withoutTrailingNewline(text2) {
+  return text2.endsWith("\n") ? text2.slice(0, -1) : text2;
+}
+async function runStatus(options = {}) {
+  assertProjectInitialized();
+  const report2 = getStatusReport2(options, TERMINAL_DECOR);
+  if (report2.failed) {
+    refuseUnreadableTree(report2.text);
+  }
+  logger.header("Architecture Status Dashboard");
+  logger.blank();
+  console.log(withoutTrailingNewline(report2.text));
+  const lock = approvalVerdict2();
+  if (lock.text.trim()) {
+    logger.blank();
+    if (lock.drifted) logger.warn(lock.text.trim());
+    else logger.info(lock.text.trim());
+  }
+  logger.blank();
+}
 
 // src/commands/domains.ts
 var import_chalk11 = __toESM(require("chalk"));
@@ -32982,7 +32915,7 @@ init_fs();
 init_provision();
 init_skills();
 init_specs2();
-init_lockfile();
+init_lock();
 init_extensions();
 init_mcp();
 function icon(mark) {
@@ -33038,7 +32971,7 @@ async function runDoctor(options = {}) {
   let targets = [];
   let configOk = false;
   try {
-    if (!loadProjectConfig4()) throw new ProjectNotInitializedError();
+    if (!loadProjectConfig3()) throw new ProjectNotInitializedError();
     configOk = true;
     line(tally, "ok", ".wai/project.yaml is valid");
   } catch (e) {
@@ -33074,7 +33007,7 @@ async function runDoctor(options = {}) {
   if (hasSystemSpec && configOk) {
     console.log(import_chalk12.default.bold("Spec tree"));
     try {
-      const cfg = loadProjectConfig4();
+      const cfg = loadProjectConfig3();
       if (!cfg) throw new ProjectNotInitializedError();
       const result = validateSddTree(cfg.rules, cfg.projectType);
       const errs = result.issues.filter((i) => i.severity === "error").length;
@@ -33256,7 +33189,7 @@ async function applyFixes() {
   if (!projectConfigExists2()) return;
   let targets;
   try {
-    if (!loadProjectConfig4()) throw new ProjectNotInitializedError();
+    if (!loadProjectConfig3()) throw new ProjectNotInitializedError();
     targets = activeTargetTypes2();
   } catch (e) {
     logger.warn(`--fix skipped: .wai/project.yaml is invalid (${e instanceof Error ? e.message : String(e)}). Fix it first.`);
@@ -48418,7 +48351,7 @@ var TIER_COLOR = {
 };
 async function showExecution() {
   assertInitialized();
-  const config = loadProjectConfig4();
+  const config = loadProjectConfig3();
   if (!config) throw new ProjectNotInitializedError();
   const tier = config.execution.tier;
   logger.header("Execution budgets");
@@ -48480,7 +48413,7 @@ async function setExecutionTier3(raw) {
     );
   }
   const tier = parsed.data;
-  const config = loadProjectConfig4();
+  const config = loadProjectConfig3();
   if (!config) throw new ProjectNotInitializedError();
   const previous = config.execution.tier;
   if (previous === tier) {
@@ -48533,7 +48466,7 @@ async function runLock2(options) {
     logger.error("No SDD spec tree found (.wai/specs). Nothing to lock.");
     process.exit(1);
   }
-  const projectConfig = loadProjectConfig4();
+  const projectConfig = loadProjectConfig3();
   if (!projectConfig) throw new ProjectNotInitializedError();
   logger.info("Analyzing and validating specifications in-memory...");
   const dry = validateAsComplete({