@wairon/cli 5.1.1-dev.5 → 5.1.1-dev.7

package/dist/index.js

@@ -1211,7 +1211,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.5";
+    WAIRON_VERSION = "5.1.1-dev.7";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -3361,9 +3361,9 @@ var init_surfaces = __esm({
 // src/core/rules/namespace.ts
 function isExternalNamespaceRef(ctx, ref) {
   if (ref.startsWith("::") || ref.startsWith("super::")) return true;
-  const sep4 = ref.indexOf("::");
-  if (sep4 === -1) return false;
-  return !ctx.subsystemIds.has(ref.slice(0, sep4));
+  const sep6 = ref.indexOf("::");
+  if (sep6 === -1) return false;
+  return !ctx.subsystemIds.has(ref.slice(0, sep6));
 }
 function resolveSurfaceRef(ctx, ref) {
   const local = ref.split("::").filter((seg) => seg && seg !== "super").pop();
@@ -3700,10 +3700,10 @@ function stepGraph(steps) {
     const s = byNum.get(n);
     if (s.type !== "parallel" || s.endStep === void 0 || !s.branches?.length) continue;
     const entries = s.branches.map((b) => b.step).sort((a, b) => a - b);
-    const join15 = fallNext(s.endStep);
+    const join16 = fallNext(s.endStep);
     for (let i = 0; i < entries.length; i++) {
       const armEnd = i + 1 < entries.length ? prevOf(entries[i + 1]) : s.endStep;
-      if (armEnd !== void 0 && armEnd >= entries[i]) armEndJoin.set(armEnd, join15);
+      if (armEnd !== void 0 && armEnd >= entries[i]) armEndJoin.set(armEnd, join16);
     }
   }
   const successorsOf = (n) => {
@@ -3777,7 +3777,8 @@ var init_narrative_flow = __esm({
         { code: "REGION_OVERLAP", defaultSeverity: "error", summary: "loop/try regions interleave \u2014 regions must nest or be disjoint to map onto structured code" },
         { code: "JUMP_INTO_REGION", defaultSeverity: "warning", summary: "Jump lands in the middle of a loop/try body from outside \u2014 regions are entered through their header" },
         { code: "FALLTHROUGH_INTO_HANDLER", defaultSeverity: "warning", summary: "try body falls through into its own catch/finally region on the success path" },
-        { code: "BACKWARD_JUMP", defaultSeverity: "warning", summary: "Backward jump that is not a continue to an enclosing loop header \u2014 model repetition with a loop step" }
+        { code: "BACKWARD_JUMP", defaultSeverity: "warning", summary: "Backward jump that is not a continue to an enclosing loop header \u2014 model repetition with a loop step" },
+        { code: "DUPLICATE_STEP_LABEL", defaultSeverity: "error", summary: "Two steps in one narrative share a label \u2014 the symbolic anchor later deltas address by" }
       ],
       check(ctx) {
         for (const impl of ctx.implementations) {
@@ -3786,6 +3787,23 @@ var init_narrative_flow = __esm({
             const steps = implMethod.narrative;
             if (!steps.length) continue;
             const where = `Method "${implMethod.name}" in implementation "${impl.id}": `;
+            const labelled = /* @__PURE__ */ new Map();
+            for (const step of steps) {
+              const label = step.label;
+              if (!label) continue;
+              const first = labelled.get(label);
+              if (first !== void 0) {
+                ctx.addIssue(
+                  "error",
+                  "DUPLICATE_STEP_LABEL",
+                  `${where}steps ${first} and ${step.stepNumber} share the label "${label}". A label anchors one step for later deltas to address; two steps holding it makes every symbolic reference ambiguous and blocks all further edits to this implementation. Rename one.`,
+                  impl.id,
+                  isDraftCtx
+                );
+              } else {
+                labelled.set(label, step.stepNumber);
+              }
+            }
             let sound = true;
             const malformed = (msg) => {
               sound = false;
@@ -7011,11 +7029,11 @@ var init_narrative_antipatterns = __esm({
           const memberEdges = keys.flatMap((k) => (adjacency.get(k) ?? []).filter((e) => inScc.has(e.toKey)));
           if (memberEdges.length === 0) continue;
           const anchor = [...memberEdges].sort((a, b) => a.fromKey.localeCompare(b.fromKey))[0];
-          const path24 = [...keys].sort().join(" \u2192 ");
+          const path26 = [...keys].sort().join(" \u2192 ");
           ctx.addIssue(
             "warning",
             "UNCONDITIONAL_CALL_CYCLE",
-            `Call cycle with no guard: ${path24} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
+            `Call cycle with no guard: ${path26} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
             anchor.impl.id,
             memberEdges.some((e) => ctx.isImplementationDraft(e.impl))
           );
@@ -13881,6 +13899,77 @@ var init_variants = __esm({
   }
 });
 
+// src/core/baseline.ts
+function baselineDir() {
+  return process.env["WAIRON_BASELINE_DIR"] || path13.join(os4.homedir(), ".wairon", "baselines");
+}
+function keyFor(root) {
+  const normalized = path13.resolve(root).replace(/\\/g, "/").toLowerCase();
+  return crypto3.createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function baselinePath(root) {
+  return path13.join(baselineDir(), `${keyFor(root)}.json`);
+}
+function readBaseline(root = getProjectRoot()) {
+  const p = baselinePath(root);
+  if (!pathExists(p)) return null;
+  try {
+    return JSON.parse(fs9.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function currentSpecs(root) {
+  const mountDirs = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::")).map((s) => `${path13.resolve(root, s.projectPath).split(path13.sep).join("/")}/`);
+  const out = {};
+  for (const [abs, content] of snapshotSpecFiles()) {
+    const normalized = path13.resolve(abs).split(path13.sep).join("/");
+    if (mountDirs.some((dir) => normalized.startsWith(dir))) continue;
+    out[path13.relative(root, abs).split(path13.sep).join("/")] = content;
+  }
+  return out;
+}
+function diffAgainstBaseline(root = getProjectRoot()) {
+  const baseline = readBaseline(root);
+  if (!baseline) return null;
+  const current2 = currentSpecs(root);
+  const added = [];
+  const changed = [];
+  const removed = [];
+  const unchangedPaths = [];
+  for (const [rel2, content] of Object.entries(current2)) {
+    const before = baseline.specs[rel2];
+    if (before === void 0) added.push(rel2);
+    else if (before !== content) changed.push(rel2);
+    else unchangedPaths.push(rel2);
+  }
+  for (const rel2 of Object.keys(baseline.specs)) {
+    if (current2[rel2] === void 0) removed.push(rel2);
+  }
+  return {
+    added: added.sort(),
+    changed: changed.sort(),
+    removed: removed.sort(),
+    unchangedPaths: unchangedPaths.sort()
+  };
+}
+function settledSpecPaths(root = getProjectRoot()) {
+  const diff = diffAgainstBaseline(root);
+  return diff ? new Set(diff.unchangedPaths) : null;
+}
+var fs9, os4, path13, crypto3;
+var init_baseline = __esm({
+  "src/core/baseline.ts"() {
+    "use strict";
+    fs9 = __toESM(require("fs"));
+    os4 = __toESM(require("os"));
+    path13 = __toESM(require("path"));
+    crypto3 = __toESM(require("crypto"));
+    init_fs();
+    init_specs2();
+  }
+});
+
 // src/core/validation.ts
 function projectPackSelections() {
   try {
@@ -14003,7 +14092,7 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
   const types = loadTypeSpecs();
   const surfaceSnapshots = loadSurfaceSnapshots();
   const codeModel = buildCodeModel(implementations, getProjectRoot());
-  const statusBearing = treatAllAsComplete ? [...subsystems, ...components, ...interfaces, ...implementations] : [];
+  const statusBearing = treatAllAsComplete ? [...subsystems, ...components, ...interfaces, ...implementations] : settledStatusBearing({ subsystems, components, interfaces, implementations });
   const statusSnapshot = statusBearing.map((s) => s.status);
   for (const s of statusBearing) s.status = "complete";
   try {
@@ -14125,10 +14214,34 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
     });
   }
 }
+function settledStatusBearing(loaded) {
+  let settled;
+  try {
+    settled = settledSpecPaths();
+  } catch {
+    return [];
+  }
+  if (!settled || settled.size === 0) return [];
+  const root = getProjectRoot();
+  const index = scanAllSpecs();
+  const rel2 = (abs) => path14.relative(root, abs).split(path14.sep).join("/");
+  const out = [];
+  const take = (specs, paths) => {
+    for (const spec of specs) {
+      const p = paths[spec.id];
+      if (p && settled.has(rel2(p))) out.push(spec);
+    }
+  };
+  take(loaded.subsystems, index.paths.subsystem);
+  take(loaded.components, index.paths.component);
+  take(loaded.interfaces, index.paths.interface);
+  take(loaded.implementations, index.paths.implementation);
+  return out;
+}
 function validateAsComplete(options) {
   return validateSddTree({ ...options ?? {}, treatAllAsComplete: true });
 }
-var SUBPROJECT_REFERENCE_CODES, SUBPROJECT_CONFORMANCE_CODES;
+var path14, SUBPROJECT_REFERENCE_CODES, SUBPROJECT_CONFORMANCE_CODES;
 var init_validation = __esm({
   "src/core/validation.ts"() {
     "use strict";
@@ -14142,6 +14255,8 @@ var init_validation = __esm({
     init_source_analysis();
     init_specs2();
     init_fs();
+    path14 = __toESM(require("path"));
+    init_baseline();
     SUBPROJECT_REFERENCE_CODES = /* @__PURE__ */ new Set([
       "UNDEFINED_TYPE_REFERENCE",
       "INVALID_DEPENDENCY_REFERENCE",
@@ -14471,8 +14586,8 @@ function generateSequenceDiagram(componentId, methodName, options) {
     const steps = [...methodImpl.narrative].sort((a, b) => a.stepNumber - b.stepNumber);
     for (const step of steps) {
       for (const par of parallelArms) {
-        const sep4 = par.sepByStep.get(step.stepNumber);
-        if (sep4 !== void 0) lines.push(`  and ${escapeLabel(sep4)}`);
+        const sep6 = par.sepByStep.get(step.stepNumber);
+        if (sep6 !== void 0) lines.push(`  and ${escapeLabel(sep6)}`);
       }
       switch (step.type) {
         case "local":
@@ -14766,16 +14881,16 @@ function relativizeId(id, prefix) {
   return `${"super::".repeat(prefixParts.length - common)}${idParts.slice(common).join("::")}`;
 }
 function isWithin(dir, file) {
-  const d = path13.resolve(dir);
-  const f = path13.resolve(file);
-  return f === d || f.startsWith(d + path13.sep);
+  const d = path15.resolve(dir);
+  const f = path15.resolve(file);
+  return f === d || f.startsWith(d + path15.sep);
 }
 function projectPathEscapesRoot(projectRoot, projectPath, resolvedChildDir) {
-  return path13.isAbsolute(projectPath) || !isWithin(projectRoot, resolvedChildDir);
+  return path15.isAbsolute(projectPath) || !isWithin(projectRoot, resolvedChildDir);
 }
 function assertContainedProjectPath(projectRoot, projectPath) {
-  const root = path13.resolve(projectRoot);
-  const resolved = path13.resolve(root, projectPath);
+  const root = path15.resolve(projectRoot);
+  const resolved = path15.resolve(root, projectPath);
   if (projectPathEscapesRoot(root, projectPath, resolved)) {
     throw new Error(
       `projectPath "${projectPath}" must resolve within the project root "${root}", but resolves to "${resolved}"; absolute paths and ../-escaping paths are rejected so a chained subproject is always contained by its parent.`
@@ -14786,11 +14901,11 @@ function assertContainedProjectPath(projectRoot, projectPath) {
 function findChainingParent(childRoot) {
   let childResolved;
   try {
-    childResolved = path13.resolve(childRoot);
+    childResolved = path15.resolve(childRoot);
   } catch {
     return null;
   }
-  let dir = path13.dirname(childResolved);
+  let dir = path15.dirname(childResolved);
   for (let hops = 0; hops < 32; hops++) {
     const specsDir = aiPathsAt(dir).specsDir();
     if (pathExists(specsDir)) {
@@ -14805,7 +14920,7 @@ function findChainingParent(childRoot) {
           const projectPath = raw.projectPath;
           if (typeof projectPath === "string" && projectPath.trim() !== "") {
             try {
-              if (path13.resolve(dir, projectPath) === childResolved) {
+              if (path15.resolve(dir, projectPath) === childResolved) {
                 const id = raw.id;
                 return { parentRoot: dir, subsystemId: typeof id === "string" ? id : "?" };
               }
@@ -14815,7 +14930,7 @@ function findChainingParent(childRoot) {
         }
       }
     }
-    const up = path13.dirname(dir);
+    const up = path15.dirname(dir);
     if (up === dir) break;
     dir = up;
   }
@@ -14920,18 +15035,18 @@ function findOwner(id, components) {
   }) ?? null;
 }
 function moveComponentFolder(fromDir, toDir) {
-  if (path13.normalize(fromDir) === path13.normalize(toDir)) return false;
-  if (!fs9.existsSync(fromDir) || fs9.existsSync(toDir)) return false;
-  ensureDir(path13.dirname(toDir));
-  fs9.renameSync(fromDir, toDir);
+  if (path15.normalize(fromDir) === path15.normalize(toDir)) return false;
+  if (!fs10.existsSync(fromDir) || fs10.existsSync(toDir)) return false;
+  ensureDir(path15.dirname(toDir));
+  fs10.renameSync(fromDir, toDir);
   return true;
 }
 function cleanEmptyDirs(filePath, specsRoot) {
-  let dir = path13.dirname(filePath);
+  let dir = path15.dirname(filePath);
   while (dir !== specsRoot && dir.startsWith(specsRoot)) {
-    if (fs9.existsSync(dir) && fs9.readdirSync(dir).length === 0) {
-      fs9.rmdirSync(dir);
-      dir = path13.dirname(dir);
+    if (fs10.existsSync(dir) && fs10.readdirSync(dir).length === 0) {
+      fs10.rmdirSync(dir);
+      dir = path15.dirname(dir);
     } else {
       break;
     }
@@ -14950,13 +15065,13 @@ function parseOrThrow(schema, value, kind, id) {
 function computeSpecTreeSignature(dirs) {
   const parts = [];
   for (const dir of dirs) {
-    if (!fs9.existsSync(dir)) {
+    if (!fs10.existsSync(dir)) {
       parts.push(`${dir}:missing`);
       continue;
     }
     for (const f of listFilesRecursive(dir, ".yaml")) {
       try {
-        const st = fs9.statSync(f);
+        const st = fs10.statSync(f);
         parts.push(`${f}:${st.mtimeMs}:${st.size}`);
       } catch {
         parts.push(`${f}:gone`);
@@ -14966,7 +15081,7 @@ function computeSpecTreeSignature(dirs) {
   return parts.join("|");
 }
 function workspaceFor(rootDir) {
-  const key = path13.resolve(rootDir);
+  const key = path15.resolve(rootDir);
   let ws = workspaces.get(key);
   if (!ws) {
     ws = new SpecWorkspace(key);
@@ -15105,7 +15220,7 @@ function readLockState() {
   return { state: stateIdEquals(record.stateId, current2) ? "locked" : "stale", record, current: current2 };
 }
 function computeStateIdAt(root) {
-  const resolved = path13.resolve(root);
+  const resolved = path15.resolve(root);
   return runWithProjectRoot(resolved, () => {
     workspaceFor(resolved).invalidate();
     const system = loadSystemSpec();
@@ -15135,12 +15250,15 @@ function collectPromotableSpecs(scopeSubsystem) {
 function applySpecStatus(kind, id, status) {
   current().applySpecStatus(kind, id, status);
 }
+function specPathsInScope(scopeSubsystem) {
+  return current().specPathsInScope(scopeSubsystem);
+}
 function snapshotSpecFiles() {
   return current().snapshotSpecFiles();
 }
 function restoreSpecFiles(snapshot) {
   for (const [file, content] of snapshot) {
-    fs9.writeFileSync(file, content);
+    fs10.writeFileSync(file, content);
   }
 }
 function findLegacySpecFiles() {
@@ -15149,12 +15267,12 @@ function findLegacySpecFiles() {
 function updateSpec(kind, id, delta, hooks) {
   return current().updateSpec(kind, id, delta, hooks);
 }
-var fs9, path13, SIGNATURE_TTL_MS, SpecWorkspace, workspaces;
+var fs10, path15, SIGNATURE_TTL_MS, SpecWorkspace, workspaces;
 var init_specs2 = __esm({
   "src/core/specs.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    fs10 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
     init_loader();
     init_fs();
     init_statehash();
@@ -15175,7 +15293,7 @@ var init_specs2 = __esm({
         this.rootSubsystems = /* @__PURE__ */ new Set();
         this.scanVisitedSpecDirs = [];
         this.loaderIssues = [];
-        this.rootDir = path13.resolve(rootDir);
+        this.rootDir = path15.resolve(rootDir);
         this.paths = aiPathsAt(this.rootDir);
       }
       invalidate() {
@@ -15202,7 +15320,7 @@ var init_specs2 = __esm({
         this.rootSubsystems.clear();
         this.cachedRecursive = recursive;
         this.scanVisitedSpecDirs = [];
-        const visited = /* @__PURE__ */ new Set([path13.resolve(this.rootDir)]);
+        const visited = /* @__PURE__ */ new Set([path15.resolve(this.rootDir)]);
         const maxDepth = typeof recursive === "number" ? recursive : recursive ? Infinity : 0;
         this.cachedIndex = this.scanSpecsForProject(this.rootDir, "", visited, maxDepth, 0);
         this.cachedSpecDirs = this.scanVisitedSpecDirs;
@@ -15217,10 +15335,10 @@ var init_specs2 = __esm({
         this.scanVisitedSpecDirs.push(specsDir);
         if (!pathExists(specsDir)) return index;
         const files = listFilesRecursive(specsDir, ".yaml");
-        const systemYaml = path13.normalize(projectPaths.specsSystem());
+        const systemYaml = path15.normalize(projectPaths.specsSystem());
         const localSubprojects = [];
         for (const file of files) {
-          const normFile = path13.normalize(file);
+          const normFile = path15.normalize(file);
           if (normFile === systemYaml) continue;
           let detectedType = "spec";
           try {
@@ -15230,7 +15348,7 @@ var init_specs2 = __esm({
                 severity: "error",
                 code: "INVALID_YAML",
                 message: `Spec file "${file}" is not a valid YAML object or is empty.`,
-                specId: path13.basename(file, ".yaml")
+                specId: path15.basename(file, ".yaml")
               });
               continue;
             }
@@ -15262,8 +15380,8 @@ var init_specs2 = __esm({
               detectedType = "implementation";
               const parsed = ImplementationSpecSchema.parse(raw);
               if (parsed.sourcePath) {
-                const absSourcePath = path13.resolve(projectDir, parsed.sourcePath);
-                parsed.sourcePath = path13.relative(projectDir, absSourcePath).replace(/\\/g, "/");
+                const absSourcePath = path15.resolve(projectDir, parsed.sourcePath);
+                parsed.sourcePath = path15.relative(projectDir, absSourcePath).replace(/\\/g, "/");
               }
               index.implementations.push(parsed);
               index.paths.implementation[parsed.id] = file;
@@ -15285,11 +15403,11 @@ var init_specs2 = __esm({
                 severity: "error",
                 code: "UNKNOWN_SPEC_TYPE",
                 message: `Spec file "${file}" does not match any recognized L1-L4 schema structure.`,
-                specId: path13.basename(file, ".yaml")
+                specId: path15.basename(file, ".yaml")
               });
             }
           } catch (e) {
-            const filename = path13.basename(file, ".yaml");
+            const filename = path15.basename(file, ".yaml");
             this.loaderIssues.push({
               severity: "error",
               code: "SCHEMA_VALIDATION_ERROR",
@@ -15387,7 +15505,7 @@ var init_specs2 = __esm({
         }
         if (currentDepth < maxDepth) {
           for (const subproj of localSubprojects) {
-            const childDir = path13.resolve(projectDir, subproj.projectPath);
+            const childDir = path15.resolve(projectDir, subproj.projectPath);
             if (projectPathEscapesRoot(this.rootDir, subproj.projectPath, childDir)) {
               this.loaderIssues.push({
                 severity: "error",
@@ -15406,7 +15524,7 @@ var init_specs2 = __esm({
               });
               continue;
             }
-            if (!fs9.existsSync(childDir)) {
+            if (!fs10.existsSync(childDir)) {
               this.loaderIssues.push({
                 severity: "error",
                 code: "SUBPROJECT_NOT_FOUND",
@@ -15449,7 +15567,7 @@ var init_specs2 = __esm({
           const index = this.scanAll();
           const sub = index.subsystems.find((s) => s.id === currentPrefix);
           if (sub && sub.projectPath) {
-            const nextDir = path13.resolve(currentDir, sub.projectPath);
+            const nextDir = path15.resolve(currentDir, sub.projectPath);
             if (projectPathEscapesRoot(this.rootDir, sub.projectPath, nextDir)) {
               this.loaderIssues.push({
                 severity: "error",
@@ -15501,9 +15619,9 @@ var init_specs2 = __esm({
           return index.paths.subsystem[matches2[0]];
         }
         if (pathExists(this.paths.specsSubsystemsDir()) && listFiles(this.paths.specsSubsystemsDir(), ".yaml").length > 0) {
-          return path13.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
+          return path15.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
         }
-        return path13.join(this.paths.specsDir(), id, ".index.yaml");
+        return path15.join(this.paths.specsDir(), id, ".index.yaml");
       }
       getComponentPath(id, subsystemId) {
         const index = this.scanAll();
@@ -15523,21 +15641,21 @@ var init_specs2 = __esm({
         if (owner) {
           const ownerPath = index.paths.component[owner.id];
           if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-            return path13.join(path13.dirname(ownerPath), id, ".index.yaml");
+            return path15.join(path15.dirname(ownerPath), id, ".index.yaml");
           }
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path13.dirname(subPath);
+          const subDir = path15.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path13.join(subDir, id, ".index.yaml");
+            return path15.join(subDir, id, ".index.yaml");
           }
         }
         if (pathExists(this.paths.specsComponentsDir()) && listFiles(this.paths.specsComponentsDir(), ".yaml").length > 0) {
-          return path13.join(this.paths.specsComponentsDir(), `${id}.yaml`);
+          return path15.join(this.paths.specsComponentsDir(), `${id}.yaml`);
         }
         const targetSubsystem = subsystemId || "default";
-        return path13.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
+        return path15.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
       }
       getInterfacePath(id, componentId) {
         const index = this.scanAll();
@@ -15563,16 +15681,16 @@ var init_specs2 = __esm({
         }
         if (componentId) {
           const compPath = this.getComponentPath(componentId);
-          const compDir = path13.dirname(compPath);
+          const compDir = path15.dirname(compPath);
           if (compPath.endsWith(".index.yaml")) {
-            return path13.join(compDir, ".interface.yaml");
+            return path15.join(compDir, ".interface.yaml");
           }
         }
         if (pathExists(this.paths.specsInterfacesDir()) && listFiles(this.paths.specsInterfacesDir(), ".yaml").length > 0) {
-          return path13.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
+          return path15.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
         }
         const targetComponent = componentId || "default";
-        return path13.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
+        return path15.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
       }
       getImplementationPath(id, contractId) {
         const index = this.scanAll();
@@ -15598,16 +15716,16 @@ var init_specs2 = __esm({
         }
         if (contractId) {
           const intfPath = this.getInterfacePath(contractId);
-          const intfDir = path13.dirname(intfPath);
+          const intfDir = path15.dirname(intfPath);
           if (intfPath.endsWith(".interface.yaml")) {
-            return path13.join(intfDir, ".implementation.yaml");
+            return path15.join(intfDir, ".implementation.yaml");
           }
         }
         if (pathExists(this.paths.specsImplementationsDir()) && listFiles(this.paths.specsImplementationsDir(), ".yaml").length > 0) {
-          return path13.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
+          return path15.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
         }
         const targetContract = contractId ? contractId.replace(/^i/, "") : "default";
-        return path13.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
+        return path15.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
       }
       getTypePath(id, subsystemId, group) {
         const index = this.scanAll();
@@ -15638,7 +15756,7 @@ var init_specs2 = __esm({
           const groupPath = index.paths.group[targetGroup] || index.paths.group[plainGroup];
           if (groupPath) {
             const localId2 = id.split("::").pop();
-            return path13.join(path13.dirname(groupPath), `${localId2}.yaml`);
+            return path15.join(path15.dirname(groupPath), `${localId2}.yaml`);
           }
         }
         let localId = id;
@@ -15651,12 +15769,12 @@ var init_specs2 = __esm({
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path13.dirname(subPath);
+          const subDir = path15.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path13.join(subDir, "types", `${localId}.yaml`);
+            return path15.join(subDir, "types", `${localId}.yaml`);
           }
         }
-        return path13.join(this.paths.specsTypesDir(), `${localId}.yaml`);
+        return path15.join(this.paths.specsTypesDir(), `${localId}.yaml`);
       }
       getGroupPath(id, subsystemId) {
         const index = this.scanAll();
@@ -15690,12 +15808,12 @@ var init_specs2 = __esm({
         }
         if (subsystemId) {
           const subPath = this.getSubsystemPath(subsystemId);
-          const subDir = path13.dirname(subPath);
+          const subDir = path15.dirname(subPath);
           if (subPath.endsWith(".index.yaml")) {
-            return path13.join(subDir, "types", localId, ".index.yaml");
+            return path15.join(subDir, "types", localId, ".index.yaml");
           }
         }
-        return path13.join(this.paths.specsTypesDir(), localId, ".index.yaml");
+        return path15.join(this.paths.specsTypesDir(), localId, ".index.yaml");
       }
       // -------------------------------------------------------------------------
       // Level 0: System
@@ -15718,7 +15836,7 @@ var init_specs2 = __esm({
       }
       saveSystemSpec(spec) {
         const p = this.paths.specsSystem();
-        ensureDir(path13.dirname(p));
+        ensureDir(path15.dirname(p));
         writeYamlFile(p, parseOrThrow(SystemSpecSchema, spec, "system", spec.name));
         invalidateSpecCache();
       }
@@ -15836,7 +15954,7 @@ var init_specs2 = __esm({
       }
       saveSubsystemSpec(spec) {
         const p = this.getSubsystemPath(spec.id);
-        ensureDir(path13.dirname(p));
+        ensureDir(path15.dirname(p));
         const { prefix } = splitNamespace(spec.id);
         if (!prefix && spec.projectPath && spec.projectPath.trim() !== "") {
           assertContainedProjectPath(this.rootDir, spec.projectPath);
@@ -15867,9 +15985,9 @@ var init_specs2 = __esm({
       }
       deleteSubsystemSpec(id) {
         const p = this.getSubsystemPath(id);
-        if (!fs9.existsSync(p)) return false;
-        fs9.unlinkSync(p);
-        cleanEmptyDirs(p, path13.resolve(this.paths.specsDir()));
+        if (!fs10.existsSync(p)) return false;
+        fs10.unlinkSync(p);
+        cleanEmptyDirs(p, path15.resolve(this.paths.specsDir()));
         invalidateSpecCache();
         return true;
       }
@@ -15902,7 +16020,7 @@ var init_specs2 = __esm({
       saveComponentSpec(spec, opts) {
         const notices = [];
         const p = this.getComponentPath(spec.id, spec.subsystem);
-        ensureDir(path13.dirname(p));
+        ensureDir(path15.dirname(p));
         const specToWrite = this.prepareComponentForWrite(spec);
         const existing = this.loadComponentSpec(spec.id);
         if (existing) {
@@ -15919,7 +16037,7 @@ var init_specs2 = __esm({
         const subsystemChanged = existing && existing.subsystem !== spec.subsystem && splitNamespace(existing.subsystem).localId !== splitNamespace(spec.subsystem).localId;
         if (subsystemChanged && !p.endsWith(".index.yaml")) {
           notices.push(
-            `component "${spec.id}" already exists at ${path13.relative(this.rootDir, p)} \u2014 the flat layout re-saves in place and never relocates the file. The subsystem field is now "${spec.subsystem}" (was "${existing.subsystem}").`
+            `component "${spec.id}" already exists at ${path15.relative(this.rootDir, p)} \u2014 the flat layout re-saves in place and never relocates the file. The subsystem field is now "${spec.subsystem}" (was "${existing.subsystem}").`
           );
         }
         specToWrite.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -15930,9 +16048,9 @@ var init_specs2 = __esm({
       }
       deleteComponentSpec(id) {
         const p = this.getComponentPath(id);
-        if (!fs9.existsSync(p)) return false;
-        fs9.unlinkSync(p);
-        cleanEmptyDirs(p, path13.resolve(this.paths.specsDir()));
+        if (!fs10.existsSync(p)) return false;
+        fs10.unlinkSync(p);
+        cleanEmptyDirs(p, path15.resolve(this.paths.specsDir()));
         invalidateSpecCache();
         return true;
       }
@@ -15945,12 +16063,12 @@ var init_specs2 = __esm({
         if (owner) {
           const ownerPath = index.paths.component[owner.id];
           if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-            const ownerSubDir = path13.dirname(this.getSubsystemPath(owner.subsystem));
-            return path13.join(ownerSubDir, owner.id, comp.id);
+            const ownerSubDir = path15.dirname(this.getSubsystemPath(owner.subsystem));
+            return path15.join(ownerSubDir, owner.id, comp.id);
           }
         }
-        const subDir = path13.dirname(this.getSubsystemPath(comp.subsystem));
-        return path13.join(subDir, comp.id);
+        const subDir = path15.dirname(this.getSubsystemPath(comp.subsystem));
+        return path15.join(subDir, comp.id);
       }
       /**
        * Move component folders so the physical tree mirrors ownership: each owned
@@ -15966,7 +16084,7 @@ var init_specs2 = __esm({
           if (!currentPath) continue;
           const desiredDir = this.desiredComponentDir(comp, index);
           if (!desiredDir) continue;
-          if (moveComponentFolder(path13.dirname(currentPath), desiredDir)) moved.push(comp.id);
+          if (moveComponentFolder(path15.dirname(currentPath), desiredDir)) moved.push(comp.id);
         }
         if (moved.length) invalidateSpecCache();
         return moved;
@@ -15996,16 +16114,46 @@ var init_specs2 = __esm({
           return null;
         }
       }
+      /**
+       * Refuse a write that would land on a file already holding a DIFFERENT spec.
+       *
+       * In the nested layout a spec's path is derived from its parent — a component
+       * for an interface, a contract for an implementation — and the spec's own id
+       * is not part of it (see getInterfacePath / getImplementationPath, which take
+       * the id but ignore it once the parent resolves). So a second id bound to the
+       * same parent resolves to the SAME file.
+       *
+       * Left unguarded that is silent data loss, and doubly invisible: the caller's
+       * `existing` lookup is by the NEW id, finds nothing, and every re-author
+       * notice ("REMOVED …", the carry-forward seam) stays quiet. An agent renaming
+       * an interface by defining a new one destroys the old contract, its
+       * narratives and its lint.allows, and is told "Successfully defined".
+       */
+      assertPathHoldsNoOtherSpec(p, id, kind, parentLabel) {
+        if (!pathExists(p)) return;
+        let occupantId;
+        try {
+          occupantId = readYamlFile(p)?.id;
+        } catch {
+          return;
+        }
+        if (!occupantId) return;
+        if (occupantId === id || splitNamespace(occupantId).localId === splitNamespace(id).localId) return;
+        throw new Error(
+          `Cannot write ${kind} "${id}": ${parentLabel} is already ${kind === "interface" ? "served by" : "implemented by"} "${occupantId}" at ${path15.relative(this.rootDir, p)}, and both ids resolve to that one file. Re-author "${occupantId}" instead, or delete it first if you meant to replace it.`
+        );
+      }
       /** Returns non-fatal placement notices (see saveTypeSpec) — empty when there is nothing to clarify. */
       saveInterfaceSpec(spec, opts) {
         const notices = [];
         const p = this.getInterfacePath(spec.id, spec.component);
-        ensureDir(path13.dirname(p));
+        this.assertPathHoldsNoOtherSpec(p, spec.id, "interface", `component "${spec.component}"`);
+        ensureDir(path15.dirname(p));
         const specToWrite = this.prepareInterfaceForWrite(spec);
         const existing = this.loadInterfaceSpec(spec.id);
         if (existing && existing.component !== spec.component && splitNamespace(existing.component).localId !== splitNamespace(spec.component).localId) {
           notices.push(
-            `interface "${spec.id}" already exists at ${path13.relative(this.rootDir, p)} \u2014 re-saving updates the component binding field in place (now "${spec.component}", was "${existing.component}") and never moves the file.`
+            `interface "${spec.id}" already exists at ${path15.relative(this.rootDir, p)} \u2014 re-saving updates the component binding field in place (now "${spec.component}", was "${existing.component}") and never moves the file.`
           );
         }
         if (existing) {
@@ -16028,9 +16176,9 @@ var init_specs2 = __esm({
       }
       deleteInterfaceSpec(id) {
         const p = this.getInterfacePath(id);
-        if (!fs9.existsSync(p)) return false;
-        fs9.unlinkSync(p);
-        cleanEmptyDirs(p, path13.resolve(this.paths.specsDir()));
+        if (!fs10.existsSync(p)) return false;
+        fs10.unlinkSync(p);
+        cleanEmptyDirs(p, path15.resolve(this.paths.specsDir()));
         invalidateSpecCache();
         return true;
       }
@@ -16063,12 +16211,13 @@ var init_specs2 = __esm({
       saveImplementationSpec(spec, opts) {
         const notices = [];
         const p = this.getImplementationPath(spec.id, spec.contract);
-        ensureDir(path13.dirname(p));
+        this.assertPathHoldsNoOtherSpec(p, spec.id, "implementation", `contract "${spec.contract}"`);
+        ensureDir(path15.dirname(p));
         const specToWrite = this.prepareImplementationForWrite(spec);
         const existing = this.loadImplementationSpec(spec.id);
         if (existing && existing.contract !== spec.contract && splitNamespace(existing.contract).localId !== splitNamespace(spec.contract).localId) {
           notices.push(
-            `implementation "${spec.id}" already exists at ${path13.relative(this.rootDir, p)} \u2014 re-saving updates the contract binding field in place (now "${spec.contract}", was "${existing.contract}") and never moves the file.`
+            `implementation "${spec.id}" already exists at ${path15.relative(this.rootDir, p)} \u2014 re-saving updates the contract binding field in place (now "${spec.contract}", was "${existing.contract}") and never moves the file.`
           );
         }
         if (existing) {
@@ -16084,9 +16233,9 @@ var init_specs2 = __esm({
       }
       deleteImplementationSpec(id) {
         const p = this.getImplementationPath(id);
-        if (!fs9.existsSync(p)) return false;
-        fs9.unlinkSync(p);
-        cleanEmptyDirs(p, path13.resolve(this.paths.specsDir()));
+        if (!fs10.existsSync(p)) return false;
+        fs10.unlinkSync(p);
+        cleanEmptyDirs(p, path15.resolve(this.paths.specsDir()));
         invalidateSpecCache();
         return true;
       }
@@ -16111,11 +16260,11 @@ var init_specs2 = __esm({
         const existing = this.loadTypeSpec(spec.id);
         const group = spec.group || (existing ? existing.group : void 0);
         const p = this.getTypePath(spec.id, spec.subsystem, group);
-        ensureDir(path13.dirname(p));
+        ensureDir(path15.dirname(p));
         const subsystemChanged = existing && (existing.subsystem ?? "") !== (spec.subsystem ?? "") && splitNamespace(existing.subsystem ?? "").localId !== splitNamespace(spec.subsystem ?? "").localId;
         if (subsystemChanged) {
           notices.push(
-            `type "${spec.id}" already exists at ${path13.relative(this.rootDir, p)} \u2014 re-saving updates fields in place and never relocates the file. The subsystem field is now "${spec.subsystem ?? "(none)"}" (was "${existing.subsystem ?? "(none)"}").`
+            `type "${spec.id}" already exists at ${path15.relative(this.rootDir, p)} \u2014 re-saving updates fields in place and never relocates the file. The subsystem field is now "${spec.subsystem ?? "(none)"}" (was "${existing.subsystem ?? "(none)"}").`
           );
         }
         if (spec.subsystem && (!existing || subsystemChanged) && !this.getSubsystemPath(spec.subsystem).endsWith(".index.yaml")) {
@@ -16138,9 +16287,9 @@ var init_specs2 = __esm({
       deleteTypeSpec(id) {
         const spec = this.loadTypeSpec(id);
         const p = this.getTypePath(id, spec?.subsystem, spec?.group);
-        if (!fs9.existsSync(p)) return false;
-        fs9.unlinkSync(p);
-        cleanEmptyDirs(p, path13.resolve(this.paths.specsDir()));
+        if (!fs10.existsSync(p)) return false;
+        fs10.unlinkSync(p);
+        cleanEmptyDirs(p, path15.resolve(this.paths.specsDir()));
         invalidateSpecCache();
         return true;
       }
@@ -16155,7 +16304,7 @@ var init_specs2 = __esm({
       }
       saveGroupSpec(spec) {
         const p = this.getGroupPath(spec.id);
-        ensureDir(path13.dirname(p));
+        ensureDir(path15.dirname(p));
         const specToWrite = this.prepareGroupForWrite(spec);
         const existing = this.loadGroupSpec(spec.id);
         if (existing) {
@@ -16167,9 +16316,9 @@ var init_specs2 = __esm({
       }
       deleteGroupSpec(id) {
         const p = this.getGroupPath(id);
-        if (!fs9.existsSync(p)) return false;
-        fs9.unlinkSync(p);
-        cleanEmptyDirs(p, path13.resolve(this.paths.specsDir()));
+        if (!fs10.existsSync(p)) return false;
+        fs10.unlinkSync(p);
+        cleanEmptyDirs(p, path15.resolve(this.paths.specsDir()));
         invalidateSpecCache();
         return true;
       }
@@ -16217,6 +16366,50 @@ var init_specs2 = __esm({
         }
         return out;
       }
+      /**
+       * Every spec FILE inside a subsystem scope (absolute paths), regardless of
+       * status. `collectPromotableSpecs` answers a different question — which specs
+       * are not yet complete — so it cannot stand in for this: a scoped approval
+       * must cover the specs it approves whether or not they were already settled.
+       */
+      specPathsInScope(scopeSubsystem) {
+        const index = this.scanAll();
+        const components = this.loadComponentSpecs();
+        const interfaces = this.loadInterfaceSpecs();
+        const implementations = this.loadImplementationSpecs();
+        const inScope = (specSubsystem) => {
+          if (!scopeSubsystem) return true;
+          if (!specSubsystem) return false;
+          return specSubsystem === scopeSubsystem || specSubsystem.startsWith(`${scopeSubsystem}::`);
+        };
+        const out = /* @__PURE__ */ new Set();
+        const add = (p) => {
+          if (p) out.add(path15.resolve(p));
+        };
+        for (const s of this.loadSubsystemSpecs()) {
+          if (!scopeSubsystem || s.id === scopeSubsystem || s.id.startsWith(`${scopeSubsystem}::`)) {
+            add(index.paths.subsystem[s.id]);
+          }
+        }
+        for (const c of components) {
+          if (inScope(c.subsystem)) add(index.paths.component[c.id]);
+        }
+        for (const i of interfaces) {
+          const comp = components.find((c) => c.id === i.component);
+          if (comp && inScope(comp.subsystem)) add(index.paths.interface[i.id]);
+        }
+        for (const m of implementations) {
+          const intf = interfaces.find((i) => i.id === m.contract);
+          const comp = intf ? components.find((c) => c.id === intf.component) : null;
+          if (comp && inScope(comp.subsystem)) add(index.paths.implementation[m.id]);
+        }
+        if (!scopeSubsystem) {
+          add(this.paths.specsSystem());
+          for (const p of Object.values(index.paths.type)) add(p);
+          for (const p of Object.values(index.paths.group)) add(p);
+        }
+        return [...out];
+      }
       /** Set a single spec's status (bumps updatedAt). Caller invalidates the cache. */
       applySpecStatus(kind, id, status) {
         switch (kind) {
@@ -16254,16 +16447,16 @@ var init_specs2 = __esm({
         const files = /* @__PURE__ */ new Set();
         const sysPath = this.paths.specsSystem();
         if (pathExists(sysPath)) {
-          files.add(path13.resolve(sysPath));
+          files.add(path15.resolve(sysPath));
         }
         for (const group of Object.values(index.paths)) {
           for (const file of Object.values(group)) {
-            files.add(path13.resolve(file));
+            files.add(path15.resolve(file));
           }
         }
         for (const file of files) {
-          if (fs9.existsSync(file)) {
-            snapshot.set(file, fs9.readFileSync(file, "utf8"));
+          if (fs10.existsSync(file)) {
+            snapshot.set(file, fs10.readFileSync(file, "utf8"));
           }
         }
         return snapshot;
@@ -16277,20 +16470,20 @@ var init_specs2 = __esm({
         const files = listFilesRecursive(specsDir, ".yaml");
         const legacy = [];
         for (const f of files) {
-          const base = path13.basename(f);
-          const dir = path13.dirname(f);
+          const base = path15.basename(f);
+          const dir = path15.dirname(f);
           if (base === "system.yaml") {
-            legacy.push({ path: f, expected: path13.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path15.join(dir, ".index.yaml") });
           } else if (base === "subsystem.yaml") {
-            legacy.push({ path: f, expected: path13.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path15.join(dir, ".index.yaml") });
           } else if (base === "component.yaml") {
-            legacy.push({ path: f, expected: path13.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path15.join(dir, ".index.yaml") });
           } else if (base === "group.yaml") {
-            legacy.push({ path: f, expected: path13.join(dir, ".index.yaml") });
+            legacy.push({ path: f, expected: path15.join(dir, ".index.yaml") });
           } else if (base === "interface.yaml") {
-            legacy.push({ path: f, expected: path13.join(dir, ".interface.yaml") });
+            legacy.push({ path: f, expected: path15.join(dir, ".interface.yaml") });
           } else if (base === "implementation.yaml") {
-            legacy.push({ path: f, expected: path13.join(dir, ".implementation.yaml") });
+            legacy.push({ path: f, expected: path15.join(dir, ".implementation.yaml") });
           }
         }
         return legacy;
@@ -16357,6 +16550,35 @@ var init_specs2 = __esm({
           }
           return refs;
         };
+        const normalizeIdentity = (k) => String(k ?? "").toLowerCase().replace(/[_\-\s]/g, "");
+        const assertDeltaMarkers = (item, label) => {
+          if (!item || typeof item !== "object") return;
+          if ("remove" in item && typeof item.remove !== "boolean") {
+            throw new Error(
+              `Refusing to update ${label}: "remove" must be the boolean true, got ${JSON.stringify(item.remove)}. A non-boolean is ignored, which would leave the element in place while reporting success.`
+            );
+          }
+          if ("action" in item && item.action !== "add" && item.action !== "delete") {
+            throw new Error(
+              `Refusing to update ${label}: unknown action ${JSON.stringify(item.action)} \u2014 expected "add" or "delete". An unknown verb is ignored, which would leave the element in place while reporting success.`
+            );
+          }
+        };
+        const assertUnmatchedIsAnAddition = (deltaItem, key, existingKeys, label) => {
+          if (deltaItem?.remove === true || deltaItem?.action === "delete") {
+            throw new Error(
+              `Refusing to delete ${label} "${String(key)}": nothing with that identity exists. ` + (existingKeys.length ? `Present: ${existingKeys.map(String).join(", ")}.` : "The collection is empty.")
+            );
+          }
+          const near = existingKeys.find(
+            (k) => String(k) !== String(key) && normalizeIdentity(k) === normalizeIdentity(key)
+          );
+          if (near !== void 0) {
+            throw new Error(
+              `Refusing to add ${label} "${String(key)}": "${String(near)}" already exists and differs only in case or separators. Use the existing identity to edit it, or pick a name that is not a near-duplicate.`
+            );
+          }
+        };
         const mergeNarrative = (existingSteps, deltaSteps) => {
           let steps = [...existingSteps];
           const sortedDeltas = [...deltaSteps].sort((a, b) => a.stepNumber - b.stepNumber);
@@ -16425,6 +16647,7 @@ var init_specs2 = __esm({
         const mergeMethods = (existingMethods, deltaMethods) => {
           const merged = [...existingMethods];
           for (const deltaMethod of deltaMethods) {
+            assertDeltaMarkers(deltaMethod, `method "${deltaMethod?.name}"`);
             const idx = merged.findIndex((m) => m.name === deltaMethod.name);
             if (idx !== -1) {
               if (deltaMethod.remove === true || deltaMethod.action === "delete") {
@@ -16444,9 +16667,8 @@ var init_specs2 = __esm({
                 };
               }
             } else {
-              if (deltaMethod.remove !== true && deltaMethod.action !== "delete") {
-                merged.push(deltaMethod);
-              }
+              assertUnmatchedIsAnAddition(deltaMethod, deltaMethod.name, merged.map((m) => m.name), "method");
+              merged.push(deltaMethod);
             }
           }
           return merged;
@@ -16454,6 +16676,7 @@ var init_specs2 = __esm({
         const mergeNamedArray = (existing, delta2) => {
           const merged = [...existing];
           for (const deltaItem of delta2) {
+            assertDeltaMarkers(deltaItem, `entry "${deltaItem?.name}"`);
             const idx = merged.findIndex((item) => item.name === deltaItem.name);
             if (idx !== -1) {
               if (deltaItem.remove === true || deltaItem.action === "delete") {
@@ -16466,9 +16689,8 @@ var init_specs2 = __esm({
                 };
               }
             } else {
-              if (deltaItem.remove !== true && deltaItem.action !== "delete") {
-                merged.push(deltaItem);
-              }
+              assertUnmatchedIsAnAddition(deltaItem, deltaItem.name, merged.map((i) => i.name), "entry");
+              merged.push(deltaItem);
             }
           }
           return merged;
@@ -16476,6 +16698,7 @@ var init_specs2 = __esm({
         const mergeKeyedArray = (existing, delta2, keyOf) => {
           const merged = [...existing];
           for (const deltaItem of delta2) {
+            assertDeltaMarkers(deltaItem, `entry "${keyOf(deltaItem)}"`);
             const idx = merged.findIndex((item) => keyOf(item) === keyOf(deltaItem));
             if (idx !== -1) {
               if (deltaItem.remove === true || deltaItem.action === "delete") {
@@ -16483,7 +16706,8 @@ var init_specs2 = __esm({
               } else {
                 merged[idx] = { ...merged[idx], ...deltaItem };
               }
-            } else if (deltaItem.remove !== true && deltaItem.action !== "delete") {
+            } else {
+              assertUnmatchedIsAnAddition(deltaItem, keyOf(deltaItem), merged.map(keyOf), "entry");
               merged.push(deltaItem);
             }
           }
@@ -16492,6 +16716,8 @@ var init_specs2 = __esm({
         const mergePublicInterfaces = (existing, delta2) => {
           const merged = [...existing];
           for (const deltaItem of delta2) {
+            const piKey = (i) => `${i?.component}.${i?.interface}`;
+            assertDeltaMarkers(deltaItem, `publicInterface "${piKey(deltaItem)}"`);
             const idx = merged.findIndex((item) => item.component === deltaItem.component && item.interface === deltaItem.interface);
             if (idx !== -1) {
               if (deltaItem.remove === true || deltaItem.action === "delete") {
@@ -16503,9 +16729,8 @@ var init_specs2 = __esm({
                 };
               }
             } else {
-              if (deltaItem.remove !== true && deltaItem.action !== "delete") {
-                merged.push(deltaItem);
-              }
+              assertUnmatchedIsAnAddition(deltaItem, piKey(deltaItem), merged.map(piKey), "publicInterface");
+              merged.push(deltaItem);
             }
           }
           return merged;
@@ -16546,11 +16771,22 @@ var init_specs2 = __esm({
           for (const deltaItem of delta2) {
             const key = identityKeyOf(field, deltaItem);
             const idx = key === null ? -1 : merged.findIndex((item) => identityKeyOf(field, item) === key);
+            assertDeltaMarkers(deltaItem, `${field} entry "${String(key)}"`);
             const isDelete = deltaItem?.remove === true || deltaItem?.action === "delete";
             if (idx !== -1) {
               if (isDelete) merged.splice(idx, 1);
               else merged[idx] = { ...merged[idx], ...deltaItem };
-            } else if (!isDelete) {
+            } else {
+              if (key !== null) {
+                assertUnmatchedIsAnAddition(
+                  deltaItem,
+                  key,
+                  merged.map((i) => identityKeyOf(field, i)).filter((k) => k !== null),
+                  field
+                );
+              } else if (isDelete) {
+                throw new Error(`Refusing to delete a ${field} entry with no resolvable identity.`);
+              }
               merged.push(deltaItem);
             }
           }
@@ -16694,8 +16930,8 @@ __export(agent_resolver_exports, {
   resolveAgentTopology: () => resolveAgentTopology
 });
 function listFilesRecursiveSafe(dirPath, ext) {
-  if (!fs10.existsSync(dirPath)) return [];
-  const nameLower = path14.basename(dirPath).toLowerCase();
+  if (!fs11.existsSync(dirPath)) return [];
+  const nameLower = path16.basename(dirPath).toLowerCase();
   const IGNORED_DIRS = /* @__PURE__ */ new Set([
     "node_modules",
     "target",
@@ -16710,10 +16946,10 @@ function listFilesRecursiveSafe(dirPath, ext) {
     ".vscode"
   ]);
   if (IGNORED_DIRS.has(nameLower)) return [];
-  const entries = fs10.readdirSync(dirPath, { withFileTypes: true });
+  const entries = fs11.readdirSync(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path14.join(dirPath, entry.name);
+    const fullPath = path16.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...listFilesRecursiveSafe(fullPath, ext));
     } else if (entry.isFile() && entry.name.endsWith(ext)) {
@@ -16726,8 +16962,8 @@ function getProjectFiles(projectDir) {
   let files = projectFilesCache.get(projectDir);
   if (!files) {
     files = [];
-    const srcDir = path14.join(projectDir, "src");
-    const legacySrcDir = path14.join(projectDir, "legacy-src");
+    const srcDir = path16.join(projectDir, "src");
+    const legacySrcDir = path16.join(projectDir, "legacy-src");
     let searchDir = projectDir;
     if (pathExists(srcDir)) {
       searchDir = srcDir;
@@ -16742,7 +16978,7 @@ function getProjectFiles(projectDir) {
       files.push(...listFilesRecursiveSafe(searchDir, ext));
     }
     const rootDir = getProjectRoot();
-    files = files.map((f) => path14.relative(rootDir, f).replace(/\\/g, "/"));
+    files = files.map((f) => path16.relative(rootDir, f).replace(/\\/g, "/"));
     projectFilesCache.set(projectDir, files);
   }
   return files;
@@ -16767,8 +17003,8 @@ function inferSourcePathForComponent(comp, subsystems) {
     let bestFile = null;
     let bestScore = -1;
     for (const f of files) {
-      const ext = path14.extname(f);
-      const base = path14.basename(f, ext).toLowerCase();
+      const ext = path16.extname(f);
+      const base = path16.basename(f, ext).toLowerCase();
       if (candidates.has(base)) {
         let score = 0;
         const normalizedPath = f.toLowerCase();
@@ -16864,7 +17100,7 @@ function resolveAgentTopology() {
   });
   for (const sub of subsystems) {
     if (sub.projectPath) {
-      const mountSpecPath = path14.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/");
+      const mountSpecPath = path16.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/");
       agents.push({
         id: `${sub.id}-owner`,
         name: `${sub.name} (chained subproject)`,
@@ -16886,9 +17122,9 @@ function resolveAgentTopology() {
     }
     const subComponents = components.filter((c) => c.subsystem === sub.id);
     const ownedPaths = [];
-    ownedPaths.push(path14.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/"));
+    ownedPaths.push(path16.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/"));
     for (const c of subComponents) {
-      ownedPaths.push(path14.relative(getProjectRoot(), getComponentPath(c.id, sub.id)).replace(/\\/g, "/"));
+      ownedPaths.push(path16.relative(getProjectRoot(), getComponentPath(c.id, sub.id)).replace(/\\/g, "/"));
     }
     if (!config.rules.generateComponentImplementers) {
       for (const comp of subComponents) {
@@ -16961,10 +17197,10 @@ function resolveAgentTopology() {
       }
       const dependencies = comp.dependsOn.map((depId) => `${depId}-implementer`);
       const readPaths = [
-        path14.relative(getProjectRoot(), AI_PATHS.specsSystem()).replace(/\\/g, "/"),
-        path14.relative(getProjectRoot(), getComponentPath(comp.id, comp.subsystem)).replace(/\\/g, "/"),
-        ...compInterfaces.map((i) => path14.relative(getProjectRoot(), getInterfacePath(i.id, comp.id)).replace(/\\/g, "/")),
-        ...compImpls.map((impl) => path14.relative(getProjectRoot(), getImplementationPath(impl.id, impl.contract)).replace(/\\/g, "/"))
+        path16.relative(getProjectRoot(), AI_PATHS.specsSystem()).replace(/\\/g, "/"),
+        path16.relative(getProjectRoot(), getComponentPath(comp.id, comp.subsystem)).replace(/\\/g, "/"),
+        ...compInterfaces.map((i) => path16.relative(getProjectRoot(), getInterfacePath(i.id, comp.id)).replace(/\\/g, "/")),
+        ...compImpls.map((impl) => path16.relative(getProjectRoot(), getImplementationPath(impl.id, impl.contract)).replace(/\\/g, "/"))
       ];
       agents.push({
         id: `${comp.id}-implementer`,
@@ -17047,12 +17283,12 @@ ${guidance.trim()}
     variantGuidance: record.variantGuidance || void 0
   };
 }
-var path14, fs10, projectFilesCache, UnknownAgentError;
+var path16, fs11, projectFilesCache, UnknownAgentError;
 var init_agent_resolver = __esm({
   "src/core/agent_resolver.ts"() {
     "use strict";
-    path14 = __toESM(require("path"));
-    fs10 = __toESM(require("fs"));
+    path16 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
     init_loader();
     init_fs();
     init_errors();
@@ -17083,12 +17319,12 @@ __export(loader_exports, {
   saveTopologyConfig: () => saveTopologyConfig
 });
 function aiPathsAt(rootDir) {
-  const resolvedRoot = path15.resolve(rootDir);
+  const resolvedRoot = path17.resolve(rootDir);
   const aiDirAt = (...segments) => {
-    const waiPath = path15.join(resolvedRoot, ".wai");
-    const waironPath = path15.join(resolvedRoot, ".wairon");
-    const base = !fs11.existsSync(waiPath) && fs11.existsSync(waironPath) ? waironPath : waiPath;
-    return path15.join(base, ...segments);
+    const waiPath = path17.join(resolvedRoot, ".wai");
+    const waironPath = path17.join(resolvedRoot, ".wairon");
+    const base = !fs12.existsSync(waiPath) && fs12.existsSync(waironPath) ? waironPath : waiPath;
+    return path17.join(base, ...segments);
   };
   const specsDir = () => {
     try {
@@ -17096,7 +17332,7 @@ function aiPathsAt(rootDir) {
       if (pathExists(projConfig)) {
         const raw = readYamlFile(projConfig);
         if (raw && raw.paths && raw.paths.specsDir) {
-          return path15.resolve(resolvedRoot, raw.paths.specsDir);
+          return path17.resolve(resolvedRoot, raw.paths.specsDir);
         }
       }
     } catch {
@@ -17117,12 +17353,12 @@ function aiPathsAt(rootDir) {
     contextDomainsMd: () => aiDirAt("context", "domains.md"),
     contextWaironGuideMd: () => aiDirAt("context", "wairon-guide.md"),
     specsDir,
-    specsSystem: () => path15.join(specsDir(), ".index.yaml"),
-    specsSubsystemsDir: () => path15.join(specsDir(), "subsystems"),
-    specsComponentsDir: () => path15.join(specsDir(), "components"),
-    specsInterfacesDir: () => path15.join(specsDir(), "interfaces"),
-    specsImplementationsDir: () => path15.join(specsDir(), "implementations"),
-    specsTypesDir: () => path15.join(specsDir(), "types")
+    specsSystem: () => path17.join(specsDir(), ".index.yaml"),
+    specsSubsystemsDir: () => path17.join(specsDir(), "subsystems"),
+    specsComponentsDir: () => path17.join(specsDir(), "components"),
+    specsInterfacesDir: () => path17.join(specsDir(), "interfaces"),
+    specsImplementationsDir: () => path17.join(specsDir(), "implementations"),
+    specsTypesDir: () => path17.join(specsDir(), "types")
   };
 }
 function isProjectInitialized() {
@@ -17165,12 +17401,12 @@ function loadTopologyConfig() {
 function saveTopologyConfig(config) {
   writeYamlFile(AI_PATHS.topologyConfig(), config);
 }
-var fs11, path15, AI_PATHS;
+var fs12, path17, AI_PATHS;
 var init_loader = __esm({
   "src/config/loader.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path15 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path17 = __toESM(require("path"));
     init_fs();
     init_yaml();
     init_errors();
@@ -17210,7 +17446,7 @@ __export(domains_exports, {
   resolveDomains: () => resolveDomains
 });
 function rel(p) {
-  return path17.relative(process.cwd(), p).replace(/\\/g, "/");
+  return path19.relative(process.cwd(), p).replace(/\\/g, "/");
 }
 function deriveSubsystemDomains() {
   const subsystems = loadSubsystemSpecs();
@@ -17260,11 +17496,11 @@ function removeFreeStandingDomain(id) {
   config.domains.splice(idx, 1);
   saveTopologyConfig(config);
 }
-var path17;
+var path19;
 var init_domains = __esm({
   "src/core/domains.ts"() {
     "use strict";
-    path17 = __toESM(require("path"));
+    path19 = __toESM(require("path"));
     init_loader();
     init_specs2();
     init_errors();
@@ -17595,6 +17831,7 @@ __export(src_exports, {
   skillExtendErrors: () => skillExtendErrors,
   skillsDirForTarget: () => skillsDirForTarget,
   snapshotSpecFiles: () => snapshotSpecFiles,
+  specPathsInScope: () => specPathsInScope,
   splitNamespace: () => splitNamespace,
   stateIdEquals: () => stateIdEquals,
   stateIdString: () => stateIdString,
@@ -17625,8 +17862,8 @@ init_defaults();
 init_loader();
 
 // src/core/detection.ts
-var fs12 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 init_defaults();
 var PACKAGE_MARKERS = [
   "package.json",
@@ -17678,7 +17915,7 @@ function deduplicateIds(candidates, existingIds = /* @__PURE__ */ new Set()) {
   });
 }
 function parseGitmodules(filePath) {
-  const content = fs12.readFileSync(filePath, "utf-8");
+  const content = fs13.readFileSync(filePath, "utf-8");
   const entries = [];
   let current2 = {};
   for (const line of content.split("\n")) {
@@ -17700,8 +17937,8 @@ function parseGitmodules(filePath) {
   return entries;
 }
 function detectGitSubmodules(projectRoot) {
-  const gitmodulesPath = path16.join(projectRoot, ".gitmodules");
-  if (!fs12.existsSync(gitmodulesPath)) return [];
+  const gitmodulesPath = path18.join(projectRoot, ".gitmodules");
+  if (!fs13.existsSync(gitmodulesPath)) return [];
   return parseGitmodules(gitmodulesPath).map((entry) => ({
     suggestedId: pathToId(entry.path),
     suggestedName: pathToName(entry.path),
@@ -17719,18 +17956,18 @@ function walkForGit(projectRoot, currentDir, depth, results) {
   if (depth > MAX_SCAN_DEPTH) return;
   let entries;
   try {
-    entries = fs12.readdirSync(currentDir, { withFileTypes: true });
+    entries = fs13.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 = path16.join(currentDir, entry.name);
-    const relPath = normalizePath3(path16.relative(projectRoot, fullPath));
+    const fullPath = path18.join(currentDir, entry.name);
+    const relPath = normalizePath3(path18.relative(projectRoot, fullPath));
     if (relPath === "" || relPath === ".") continue;
-    const gitPath = path16.join(fullPath, ".git");
-    if (fs12.existsSync(gitPath)) {
+    const gitPath = path18.join(fullPath, ".git");
+    if (fs13.existsSync(gitPath)) {
       results.push({
         suggestedId: pathToId(relPath),
         suggestedName: pathToName(relPath),
@@ -17752,17 +17989,17 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
   if (depth > MAX_SCAN_DEPTH) return;
   let entries;
   try {
-    entries = fs12.readdirSync(currentDir, { withFileTypes: true });
+    entries = fs13.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 = path16.join(currentDir, entry.name);
-    const relPath = normalizePath3(path16.relative(projectRoot, fullPath));
+    const fullPath = path18.join(currentDir, entry.name);
+    const relPath = normalizePath3(path18.relative(projectRoot, fullPath));
     if (relPath === "" || relPath === ".") continue;
-    const hasMarker = PACKAGE_MARKERS.some((m) => fs12.existsSync(path16.join(fullPath, m)));
+    const hasMarker = PACKAGE_MARKERS.some((m) => fs13.existsSync(path18.join(fullPath, m)));
     if (hasMarker) {
       results.push({
         suggestedId: pathToId(relPath),
@@ -17776,8 +18013,8 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
   }
 }
 function pathToId(relPath) {
-  const basename9 = path16.basename(relPath);
-  return basename9.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const basename10 = path18.basename(relPath);
+  return basename10.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function pathToName(relPath) {
   const id = pathToId(relPath);
@@ -17797,8 +18034,8 @@ init_rules();
 init_specs2();
 
 // src/core/provision.ts
-var fs13 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 init_specs2();
 init_loader();
 init_fs();
@@ -17846,7 +18083,7 @@ function provisionProject(name) {
 function ensureProjectInitialized(fallbackName) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paths = aiPathsAt(getProjectRoot());
-  const hasSystem = fs13.existsSync(paths.specsSystem());
+  const hasSystem = fs14.existsSync(paths.specsSystem());
   let name = fallbackName;
   if (hasSystem) {
     const existing = loadSystemSpec();
@@ -17854,7 +18091,7 @@ function ensureProjectInitialized(fallbackName) {
   }
   let wroteConfig = false;
   let wroteSystem = false;
-  if (!fs13.existsSync(paths.projectConfig())) {
+  if (!fs14.existsSync(paths.projectConfig())) {
     saveProjectConfig(defaultProjectConfig(name, now));
     wroteConfig = true;
   }
@@ -17883,11 +18120,11 @@ function promoteAllComplete() {
 function walkChainedSubprojects(projectRoot, onChild) {
   const visited = /* @__PURE__ */ new Set();
   const walk = (dir) => {
-    const resolved = path18.resolve(dir);
+    const resolved = path20.resolve(dir);
     if (visited.has(resolved)) return;
     visited.add(resolved);
     const specsDir = aiPathsAt(dir).specsDir();
-    if (!fs13.existsSync(specsDir)) return;
+    if (!fs14.existsSync(specsDir)) return;
     for (const file of listFilesRecursive(specsDir, ".yaml")) {
       let raw;
       try {
@@ -17905,7 +18142,7 @@ function walkChainedSubprojects(projectRoot, onChild) {
         continue;
       }
       const id = raw.id;
-      onChild(childDir, typeof id === "string" ? id : path18.basename(childDir));
+      onChild(childDir, typeof id === "string" ? id : path20.basename(childDir));
       walk(childDir);
     }
   };
@@ -17914,7 +18151,7 @@ function walkChainedSubprojects(projectRoot, onChild) {
 function listDirectChainedSubprojects(projectRoot) {
   const out = [];
   const specsDir = aiPathsAt(projectRoot).specsDir();
-  if (!fs13.existsSync(specsDir)) return out;
+  if (!fs14.existsSync(specsDir)) return out;
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
     let raw;
     try {
@@ -17932,12 +18169,12 @@ function listDirectChainedSubprojects(projectRoot) {
       continue;
     }
     const id = raw.id;
-    out.push({ dir, subsystemId: typeof id === "string" ? id : path18.basename(dir) });
+    out.push({ dir, subsystemId: typeof id === "string" ? id : path20.basename(dir) });
   }
   return out;
 }
 function childHasSpecsButNoConfig(childDir) {
-  return fs13.existsSync(aiPathsAt(childDir).specsDir()) && !fs13.existsSync(aiPathsAt(childDir).projectConfig());
+  return fs14.existsSync(aiPathsAt(childDir).specsDir()) && !fs14.existsSync(aiPathsAt(childDir).projectConfig());
 }
 function findChainingSubprojectsMissingConfig(projectRoot) {
   const missing = [];
@@ -17986,14 +18223,14 @@ function moveSubsystemProject(subsystemId, newProjectPath) {
   const oldDir = assertContainedProjectPath(root, sub.projectPath);
   const newDir = assertContainedProjectPath(root, nextPath);
   if (oldDir !== newDir) {
-    if (!fs13.existsSync(oldDir)) {
+    if (!fs14.existsSync(oldDir)) {
       throw new WaironError(`Subproject directory not found at its current path: ${oldDir}`);
     }
-    if (fs13.existsSync(newDir)) {
+    if (fs14.existsSync(newDir)) {
       throw new WaironError(`Target directory already exists: ${newDir}`);
     }
-    ensureDir(path18.dirname(newDir));
-    fs13.renameSync(oldDir, newDir);
+    ensureDir(path20.dirname(newDir));
+    fs14.renameSync(oldDir, newDir);
   }
   saveSubsystemSpec({ ...sub, projectPath: nextPath, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
   invalidateSpecCache();
@@ -18002,9 +18239,9 @@ function toPosixPath(p) {
   return p.replace(/\\/g, "/");
 }
 function isWithinDir(dir, file) {
-  const d = path18.resolve(dir);
-  const f = path18.resolve(file);
-  return f === d || f.startsWith(d + path18.sep);
+  const d = path20.resolve(dir);
+  const f = path20.resolve(file);
+  return f === d || f.startsWith(d + path20.sep);
 }
 function externalizeSubsystem(subsystemId, projectPath) {
   if (subsystemId.includes("::")) {
@@ -18016,14 +18253,14 @@ function externalizeSubsystem(subsystemId, projectPath) {
   }
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
-  const fooDir = path18.join(parentSpecsDir, subsystemId);
-  if (!fs13.existsSync(fooDir)) {
+  const fooDir = path20.join(parentSpecsDir, subsystemId);
+  if (!fs14.existsSync(fooDir)) {
     throw new WaironError(`subsystem specs directory not found: ${fooDir}`);
   }
   const relPath = toPosixPath(projectPath);
   const childDir = assertContainedProjectPath(parentRoot, relPath);
-  const childFooDir = path18.join(childDir, ".wai", "specs", subsystemId);
-  if (fs13.existsSync(childFooDir)) {
+  const childFooDir = path20.join(childDir, ".wai", "specs", subsystemId);
+  if (fs14.existsSync(childFooDir)) {
     throw new WaironError(`target already contains a "${subsystemId}" subsystem: ${childFooDir}`);
   }
   const renameMap = buildRenameMap(
@@ -18033,17 +18270,17 @@ function externalizeSubsystem(subsystemId, projectPath) {
   );
   const childSystemName = foo.name || subsystemId;
   runWithProjectRoot(childDir, () => {
-    ensureDir(path18.join(childDir, ".wai", "specs"));
+    ensureDir(path20.join(childDir, ".wai", "specs"));
     provisionProject(childSystemName);
   });
-  ensureDir(path18.dirname(childFooDir));
-  fs13.renameSync(fooDir, childFooDir);
-  patchSubsystemIndex(path18.join(childFooDir, ".index.yaml"), (s) => {
+  ensureDir(path20.dirname(childFooDir));
+  fs14.renameSync(fooDir, childFooDir);
+  patchSubsystemIndex(path20.join(childFooDir, ".index.yaml"), (s) => {
     s.parentSystem = childSystemName;
     delete s.projectPath;
   });
   ensureDir(fooDir);
-  writeYamlFile(path18.join(fooDir, ".index.yaml"), {
+  writeYamlFile(path20.join(fooDir, ".index.yaml"), {
     id: subsystemId,
     name: foo.name,
     description: foo.description,
@@ -18069,9 +18306,9 @@ function internalizeSubsystem(subsystemId) {
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
   const childDir = assertContainedProjectPath(parentRoot, foo.projectPath);
-  const childWai = path18.join(childDir, ".wai");
-  const childFooDir = path18.join(childDir, ".wai", "specs", subsystemId);
-  if (!fs13.existsSync(childFooDir)) {
+  const childWai = path20.join(childDir, ".wai");
+  const childFooDir = path20.join(childDir, ".wai", "specs", subsystemId);
+  if (!fs14.existsSync(childFooDir)) {
     throw new WaironError(`external subproject missing subsystem "${subsystemId}": ${childFooDir}`);
   }
   const childOwnSubs = runWithProjectRoot(childDir, () => loadSubsystemSpecs()).filter((s) => !s.id.includes("::"));
@@ -18084,15 +18321,15 @@ function internalizeSubsystem(subsystemId) {
     false
   );
   const parentSystemName = loadSystemSpec()?.name ?? foo.parentSystem;
-  const fooDir = path18.join(parentSpecsDir, subsystemId);
-  fs13.rmSync(fooDir, { recursive: true, force: true });
-  ensureDir(path18.dirname(fooDir));
-  fs13.renameSync(childFooDir, fooDir);
-  patchSubsystemIndex(path18.join(fooDir, ".index.yaml"), (s) => {
+  const fooDir = path20.join(parentSpecsDir, subsystemId);
+  fs14.rmSync(fooDir, { recursive: true, force: true });
+  ensureDir(path20.dirname(fooDir));
+  fs14.renameSync(childFooDir, fooDir);
+  patchSubsystemIndex(path20.join(fooDir, ".index.yaml"), (s) => {
     s.parentSystem = parentSystemName;
     delete s.projectPath;
   });
-  fs13.rmSync(childWai, { recursive: true, force: true });
+  fs14.rmSync(childWai, { recursive: true, force: true });
   rewriteRefsInDir(parentSpecsDir, renameMap, fooDir);
   invalidateSpecCache();
 }
@@ -18189,7 +18426,7 @@ function rewriteRefsInDir(specsDir, renameMap, excludeDir) {
   }
 }
 function patchSubsystemIndex(indexPath, mutate) {
-  if (!fs13.existsSync(indexPath)) return;
+  if (!fs14.existsSync(indexPath)) return;
   const raw = readYamlFile(indexPath);
   mutate(raw);
   raw.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -18203,8 +18440,8 @@ init_statehash();
 init_agent_resolver();
 
 // src/core/skills.ts
-var path19 = __toESM(require("path"));
-var fs14 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
 init_fs();
 init_defaults();
 init_extensions();
@@ -18338,16 +18575,16 @@ function packNamespace(pack) {
   return pack.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
 function extensionsFor(builtin, packSkills) {
-  return packSkills.filter((s) => s.extends === builtin && fs14.existsSync(s.sourcePath));
+  return packSkills.filter((s) => s.extends === builtin && fs15.existsSync(s.sourcePath));
 }
 function composeBuiltinSkill(name, packSkills) {
   const srcPath = skillTemplatePath(name);
-  const base = fs14.existsSync(srcPath) ? fs14.readFileSync(srcPath, "utf-8") : "";
+  const base = fs15.existsSync(srcPath) ? fs15.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 = fs14.readFileSync(section.sourcePath, "utf-8").replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+    const body = fs15.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")}
@@ -18363,16 +18600,16 @@ function readFrontmatter(raw, fallbackName) {
   return { name: field("name") || fallbackName, description: field("description") };
 }
 function builtinSkillsDir() {
-  return path19.resolve(__dirname, "..", "templates", "skills");
+  return path21.resolve(__dirname, "..", "templates", "skills");
 }
 function skillTemplatePath(name) {
-  return path19.join(builtinSkillsDir(), `${name}.md`);
+  return path21.join(builtinSkillsDir(), `${name}.md`);
 }
 function skillDestPath(type, destDir, name) {
   if (type === "claude" || type === "codex" || type === "gemini" || type === "agy") {
-    return path19.join(destDir, name, "SKILL.md");
+    return path21.join(destDir, name, "SKILL.md");
   }
-  return path19.join(destDir, `${name}.md`);
+  return path21.join(destDir, `${name}.md`);
 }
 function skillsDirForTarget(type) {
   switch (type) {
@@ -18407,22 +18644,22 @@ function exportSddSkills(targetTypes) {
     ensureDir(destDir);
     destinations.push(destDir);
     for (const name of SKILL_NAMES) {
-      if (!fs14.existsSync(skillTemplatePath(name))) continue;
+      if (!fs15.existsSync(skillTemplatePath(name))) continue;
       const content = composeBuiltinSkill(name, packSkills.filter((s) => s.targets.includes(type)));
       const destPath = skillDestPath(type, destDir, name);
-      ensureDir(path19.dirname(destPath));
-      fs14.writeFileSync(destPath, content, "utf-8");
+      ensureDir(path21.dirname(destPath));
+      fs15.writeFileSync(destPath, content, "utf-8");
       fileCount++;
     }
     for (const skill of packSkills) {
       if (skill.extends !== void 0) continue;
       if (!skill.targets.includes(type)) continue;
-      if (!fs14.existsSync(skill.sourcePath)) continue;
+      if (!fs15.existsSync(skill.sourcePath)) continue;
       const id = packSkillId(skill);
-      const content = fs14.readFileSync(skill.sourcePath, "utf-8");
+      const content = fs15.readFileSync(skill.sourcePath, "utf-8");
       const destPath = skillDestPath(type, destDir, id);
-      ensureDir(path19.dirname(destPath));
-      fs14.writeFileSync(destPath, content, "utf-8");
+      ensureDir(path21.dirname(destPath));
+      fs15.writeFileSync(destPath, content, "utf-8");
       fileCount++;
     }
   }
@@ -18435,12 +18672,12 @@ function checkSkillFreshness(type) {
   const packSkills = loadProjectExtensions2().skills.filter((s) => s.targets.includes(type));
   for (const name of SKILL_NAMES) {
     const destPath = skillDestPath(type, dir, name);
-    if (!fs14.existsSync(destPath)) {
+    if (!fs15.existsSync(destPath)) {
       result.missing.push(name);
       continue;
     }
     const want = composeBuiltinSkill(name, packSkills);
-    const have = fs14.readFileSync(destPath, "utf-8");
+    const have = fs15.readFileSync(destPath, "utf-8");
     if (have === want) result.ok.push(name);
     else result.stale.push(name);
   }
@@ -18460,7 +18697,7 @@ var SkillResourceNotFoundError = class extends Error {
   }
 };
 function readSkillFrontmatter(name) {
-  return readFrontmatter(fs14.readFileSync(skillTemplatePath(name), "utf-8"), name);
+  return readFrontmatter(fs15.readFileSync(skillTemplatePath(name), "utf-8"), name);
 }
 function listSkillResources() {
   const builtin = RESOURCE_SKILL_IDS.map((id) => {
@@ -18474,9 +18711,9 @@ function listSkillResources() {
       defaultForHostedMcp: true
     };
   });
-  const pack = loadProjectExtensions2().skills.filter((s) => s.extends === void 0 && fs14.existsSync(s.sourcePath)).map((skill) => {
+  const pack = loadProjectExtensions2().skills.filter((s) => s.extends === void 0 && fs15.existsSync(s.sourcePath)).map((skill) => {
     const id = packSkillId(skill);
-    const fm = readFrontmatter(fs14.readFileSync(skill.sourcePath, "utf-8"), id);
+    const fm = readFrontmatter(fs15.readFileSync(skill.sourcePath, "utf-8"), id);
     return {
       id,
       name: fm.name,
@@ -18492,8 +18729,8 @@ function readSkillResource(resourceId) {
   const packSkills = loadProjectExtensions2().skills;
   if (SKILL_NAMES.includes(resourceId)) return composeBuiltinSkill(resourceId, packSkills);
   const packSkill = packSkills.find((s) => s.extends === void 0 && packSkillId(s) === resourceId);
-  if (packSkill) return fs14.readFileSync(packSkill.sourcePath, "utf-8");
-  return fs14.readFileSync(skillTemplatePath(resourceId), "utf-8");
+  if (packSkill) return fs15.readFileSync(packSkill.sourcePath, "utf-8");
+  return fs15.readFileSync(skillTemplatePath(resourceId), "utf-8");
 }
 function listResources() {
   return listSkillResources();
@@ -18682,7 +18919,7 @@ var WAIRON_MANAGED_MARKER = "wairon:managed";
 var WAIRON_MANAGED_BANNER = `<!-- ${WAIRON_MANAGED_MARKER} \u2014 generated by \`wairon generate\`; do not edit, changes are overwritten -->`;
 
 // src/exporters/claude.ts
-var path20 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 init_fs();
 var ClaudeExporter = class {
   constructor() {
@@ -18691,7 +18928,7 @@ var ClaudeExporter = class {
   outputPath(ctx) {
     const { agent, target, projectRoot } = ctx;
     const outputDir = "outputDir" in target ? target.outputDir : ".claude/agents";
-    return path20.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+    return path22.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
   }
   export(ctx) {
     const { agent, renderedInstructions } = ctx;
@@ -18712,7 +18949,7 @@ var ClaudeExporter = class {
 };
 
 // src/exporters/custom.ts
-var path21 = __toESM(require("path"));
+var path23 = __toESM(require("path"));
 init_fs();
 var CustomExporter = class {
   constructor() {
@@ -18723,7 +18960,7 @@ var CustomExporter = class {
     if (!("outputDir" in target)) {
       throw new Error("CustomExporter requires target.outputDir");
     }
-    return path21.resolve(projectRoot, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+    return path23.resolve(projectRoot, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
   }
   export(ctx) {
     const { agent, target, renderedInstructions } = ctx;
@@ -18746,7 +18983,7 @@ var CustomExporter = class {
 };
 
 // src/exporters/gemini.ts
-var path22 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 init_fs();
 var GeminiExporter = class {
   constructor() {
@@ -18755,7 +18992,7 @@ var GeminiExporter = class {
   outputPath(ctx) {
     const { agent, target, projectRoot } = ctx;
     const outputDir = "outputDir" in target ? target.outputDir : ".gemini/agents";
-    return path22.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
+    return path24.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
   }
   export(ctx) {
     const { agent, renderedInstructions } = ctx;
@@ -18780,7 +19017,7 @@ function yamlString(value) {
 }
 
 // src/exporters/generate.ts
-var path23 = __toESM(require("path"));
+var path25 = __toESM(require("path"));
 init_fs();
 
 // src/exporters/registry.ts
@@ -18847,7 +19084,7 @@ function resolveExpectedOutputPaths(agents, projectConfig, projectRoot = getProj
       const targetConfig = resolveTargetConfig(agentTarget, projectConfig);
       if (!targetConfig) continue;
       const ctx = { agent, projectRoot, target: targetConfig };
-      expected.add(path23.resolve(getExporter(targetConfig).outputPath(ctx)));
+      expected.add(path25.resolve(getExporter(targetConfig).outputPath(ctx)));
     }
   }
   return expected;
@@ -19242,6 +19479,7 @@ init_yaml();
   skillExtendErrors,
   skillsDirForTarget,
   snapshotSpecFiles,
+  specPathsInScope,
   splitNamespace,
   stateIdEquals,
   stateIdString,