@wairon/cli 5.1.1-dev.76 → 5.1.1-dev.77

package/dist/index.js

@@ -3919,6 +3919,40 @@ var BundleNotFoundError = class extends WaironError {
   }
 };
 
+// src/models/identity-rename.ts
+var EDGE = " -> ";
+var QUALIFIED_UNIT = /^(\d+:)?([^.\s]+)\.([^.\s]+)$/;
+function movedComponent(rename, id) {
+  return rename.components?.find((c) => c.from === id)?.to ?? id;
+}
+function rekeyUnit(rename, unit) {
+  if (unit.includes(EDGE)) return unit.split(EDGE).map((side) => movedComponent(rename, side)).join(EDGE);
+  const qualified = QUALIFIED_UNIT.exec(unit);
+  if (!qualified) return unit;
+  const [, step = "", component, method] = qualified;
+  const moved = rename.methods?.find((m) => m.component === component && m.method === method);
+  if (moved) return `${step}${moved.toComponent}.${moved.toMethod}`;
+  return `${step}${movedComponent(rename, component)}.${method}`;
+}
+function rekeyAnchor(rename, anchor) {
+  const { spec, at, covers } = anchor;
+  const movedSpec = rename.specs?.find((s) => s.from === spec && (!s.sites || at !== void 0 && s.sites.includes(at)));
+  let site = at;
+  if (at !== void 0) {
+    if (at.includes(EDGE)) {
+      site = rekeyUnit(rename, at);
+    } else {
+      const moved = rename.methods?.find((m) => m.method === at && m.specs?.includes(spec));
+      if (moved) site = moved.toMethod;
+    }
+  }
+  return {
+    spec: movedSpec?.to ?? spec,
+    ...site !== void 0 ? { at: site } : {},
+    ...covers !== void 0 ? { covers: covers.map((unit) => rekeyUnit(rename, unit)) } : {}
+  };
+}
+
 // src/models/project.ts
 var path2 = __toESM(require("path"));
 var import_zod3 = require("zod");
@@ -4554,6 +4588,12 @@ function projectConfigFsAdapterAt(rootDir) {
     },
     documentExists() {
       return fs2.existsSync(file());
+    },
+    readText() {
+      return readFileOrNull(file());
+    },
+    writeText(text2) {
+      writeFile(file(), text2);
     }
   };
 }
@@ -4579,9 +4619,159 @@ function storeOver(adapter, root) {
     },
     readField(field) {
       return valueAt(currentDocument(), field);
+    },
+    rewriteScalars(edits, dryRun = false) {
+      if (edits.length === 0) return;
+      const text2 = adapter.readText();
+      if (text2 === null) throw new ProjectNotInitializedError();
+      const next = rewriteScalarsInText(text2, edits, root);
+      if (!dryRun) adapter.writeText(next);
     }
   };
 }
+var KEY_RE = /^('(?:[^']|'')*'|"(?:[^"\\]|\\.)*"|[^\s'"#{}[\],&*!|>%@`][^:#]*?)\s*:(?=\s|$)/;
+function tokenize(lines) {
+  const tokens = [];
+  let blockAbove = null;
+  lines.forEach((raw, line) => {
+    const content = raw.replace(/\r?\n$/, "");
+    const indent = content.length - content.trimStart().length;
+    const trimmed = content.trim();
+    if (blockAbove !== null) {
+      if (trimmed === "" || indent > blockAbove) return;
+      blockAbove = null;
+    }
+    if (trimmed === "" || trimmed.startsWith("#")) return;
+    let col = indent;
+    let rest = content.slice(indent);
+    while (rest === "-" || rest.startsWith("- ")) {
+      tokens.push({ kind: "item", col, line });
+      const after = rest.slice(1);
+      const pad = after.length - after.trimStart().length;
+      col += 1 + pad;
+      rest = after.trimStart();
+    }
+    if (rest === "") return;
+    const key = KEY_RE.exec(rest);
+    if (key) {
+      const name = key[1].startsWith("'") ? key[1].slice(1, -1).replace(/''/g, "'") : key[1].startsWith('"') ? JSON.parse(key[1]) : key[1].trim();
+      const afterKey = rest.slice(key[0].length);
+      const value = afterKey.trimStart();
+      const token = { kind: "key", col, line, name };
+      if (value !== "" && !value.startsWith("#")) token.valueStart = col + key[0].length + (afterKey.length - value.length);
+      tokens.push(token);
+      if (/^[|>][-+0-9]*\s*(#.*)?$/.test(value)) blockAbove = col;
+      return;
+    }
+    tokens.push({ kind: "scalar", col, line, valueStart: col });
+    if (/^[|>][-+0-9]*\s*(#.*)?$/.test(rest)) blockAbove = col - 2;
+  });
+  return tokens;
+}
+function childrenOf(tokens, index) {
+  const parent = tokens[index];
+  const out = [];
+  for (let i = index + 1; i < tokens.length; i += 1) {
+    const t = tokens[i];
+    const nested = t.col > parent.col || parent.kind === "key" && t.kind === "item" && t.col === parent.col;
+    if (!nested) break;
+    out.push(t);
+  }
+  return out;
+}
+function locateScalar(tokens, path31) {
+  let region = tokens;
+  for (let k = 0; k < path31.length; k += 1) {
+    const segment = path31[k];
+    if (region.length === 0) return `nothing is nested at ${path31.slice(0, k).join(".")}`;
+    const base = Math.min(...region.map((t) => t.col));
+    const last = k === path31.length - 1;
+    let at;
+    if (typeof segment === "string") {
+      at = region.findIndex((t) => t.kind === "key" && t.col === base && t.name === segment);
+      if (at < 0) return `no block key "${segment}" at ${path31.slice(0, k).join(".") || "the document root"}`;
+      if (last) return region[at].valueStart !== void 0 ? region[at] : `"${segment}" holds no inline scalar`;
+    } else {
+      const items = region.map((t, i) => ({ t, i })).filter(({ t }) => t.kind === "item" && t.col === base);
+      if (segment >= items.length) return `no block sequence item ${segment} at ${path31.slice(0, k).join(".")}`;
+      at = items[segment].i;
+      if (last) {
+        const value = region[at + 1];
+        return value && value.kind === "scalar" && value.line === region[at].line ? value : `item ${segment} holds no inline scalar`;
+      }
+    }
+    const regionStart = tokens.indexOf(region[at]);
+    region = childrenOf(tokens, regionStart);
+  }
+  return "an empty path addresses no scalar";
+}
+function readScalar(text2) {
+  if (text2.startsWith("'")) {
+    let i = 1;
+    let value = "";
+    while (i < text2.length) {
+      if (text2[i] === "'") {
+        if (text2[i + 1] === "'") {
+          value += "'";
+          i += 2;
+          continue;
+        }
+        return { value, style: "single", end: i + 1 };
+      }
+      value += text2[i];
+      i += 1;
+    }
+    return null;
+  }
+  if (text2.startsWith('"')) {
+    const closing = /^"(?:[^"\\]|\\.)*"/.exec(text2);
+    if (!closing) return null;
+    try {
+      return { value: JSON.parse(closing[0]), style: "double", end: closing[0].length };
+    } catch {
+      return null;
+    }
+  }
+  const comment = text2.search(/\s#/);
+  const body = (comment < 0 ? text2 : text2.slice(0, comment)).trimEnd();
+  return { value: body, style: "plain", end: body.length };
+}
+function writeScalar(value, style) {
+  if (style === "double") return JSON.stringify(value);
+  if (style === "plain" && /^[A-Za-z0-9_][A-Za-z0-9_./-]*$/.test(value)) return value;
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function setAt(document, path31, value) {
+  let node = document;
+  for (const segment of path31.slice(0, -1)) node = node[segment];
+  node[path31[path31.length - 1]] = value;
+}
+function rewriteScalarsInText(text2, edits, root) {
+  const refuse = (why) => {
+    throw new WaironError(`Cannot rewrite .wai/project.yaml at ${root} without disturbing its formatting: ${why}. Nothing was written.`);
+  };
+  const lines = text2.split(/(?<=\n)/);
+  const tokens = tokenize(lines);
+  const expected = parseYaml(text2);
+  for (const edit of edits) {
+    const where = edit.path.join(".");
+    const token = locateScalar(tokens, edit.path);
+    if (typeof token === "string") refuse(`${where}: ${token}`);
+    const { line, valueStart } = token;
+    const content = lines[line].replace(/\r?\n$/, "");
+    const ending = lines[line].slice(content.length);
+    const scalar = readScalar(content.slice(valueStart));
+    if (!scalar) refuse(`${where}: the scalar there is not written on one line`);
+    if (scalar.value !== edit.from) refuse(`${where} holds "${scalar.value}", not "${edit.from}"`);
+    lines[line] = content.slice(0, valueStart) + writeScalar(edit.to, scalar.style) + content.slice(valueStart + scalar.end) + ending;
+    setAt(expected, edit.path, edit.to);
+  }
+  const next = lines.join("");
+  if (JSON.stringify(parseYaml(next)) !== JSON.stringify(expected)) {
+    refuse("the edited text does not read back as exactly the intended change");
+  }
+  return next;
+}
 function parseConfig(document, root) {
   try {
     return ProjectConfigSchema.parse(document);
@@ -4723,6 +4913,35 @@ function registryOver(store, root) {
         ...config,
         extensions: { ...config.extensions, packs: [...packsOf(config), ...selections], useGlobalPacks: false }
       });
+    },
+    rekeyCarried(rename, dryRun = false) {
+      const groups = store.readField("rules.conformance.carried");
+      if (!Array.isArray(groups)) return [];
+      const edits = [];
+      const rekeys = [];
+      groups.forEach((group, g) => {
+        const findings = group?.findings;
+        if (!Array.isArray(findings)) return;
+        findings.forEach((finding, f) => {
+          const entry = finding;
+          if (!entry || typeof entry.spec !== "string") return;
+          const at = typeof entry.at === "string" ? entry.at : void 0;
+          const covers = Array.isArray(entry.covers) ? entry.covers.filter((u) => typeof u === "string") : void 0;
+          const next = rekeyAnchor(rename, { spec: entry.spec, at, covers });
+          const base = ["rules", "conformance", "carried", g, "findings", f];
+          const named = { code: String(entry.code), spec: entry.spec, at: at ?? "" };
+          const change = (path31, field, from, to) => {
+            if (from === to) return;
+            edits.push({ path: [...base, ...path31], from, to });
+            rekeys.push({ ...named, field, from, to });
+          };
+          change(["spec"], "spec", entry.spec, next.spec);
+          if (at !== void 0) change(["at"], "at", at, next.at);
+          (covers ?? []).forEach((unit, u) => change(["covers", u], "covers", unit, next.covers[u]));
+        });
+      });
+      store.rewriteScalars(edits, dryRun);
+      return rekeys;
     }
   };
 }
@@ -4807,6 +5026,9 @@ function projectConfigRepositoryOver(adapter, rootDir) {
     },
     pinGlobalPacksAsSelections(selections) {
       registry.pinGlobalPacksAsSelections(selections);
+    },
+    rekeyCarried(rename, dryRun) {
+      return registry.rekeyCarried(rename, dryRun);
     }
   };
 }
@@ -4856,6 +5078,9 @@ var projectConfigRepository = {
   },
   pinGlobalPacksAsSelections(selections) {
     bound().pinGlobalPacksAsSelections(selections);
+  },
+  rekeyCarried(rename, dryRun) {
+    return bound().rekeyCarried(rename, dryRun);
   }
 };
 
@@ -11858,7 +12083,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.76";
+var WAIRON_VERSION = "5.1.1-dev.77";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -12647,6 +12872,28 @@ function buildCodeIndex(model) {
     return out;
   };
   const declarationsAt = (path31) => namesAt(declarations, pathKey(path31), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
+  const forwardsOf = (start, name) => {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const queue = [{ file: pathKey(start), name }];
+    while (queue.length) {
+      const at = queue.shift();
+      const key = `${at.file}#${at.name}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(at);
+      for (const binding of facts.get(at.file)?.reexportBindings ?? []) {
+        const star = binding.exported === "*";
+        if (!star && binding.exported !== at.name) continue;
+        if (star && at.name === "default") continue;
+        const to = resolveImport(at.file, binding.from, paths);
+        if (!to) continue;
+        if (star && !facts.get(to)?.exportedNames.includes(at.name)) continue;
+        queue.push({ file: to, name: star ? at.name : binding.local });
+      }
+    }
+    return out;
+  };
   return {
     paths,
     exactPaths,
@@ -12655,7 +12902,8 @@ function buildCodeIndex(model) {
     anchorsAt: (path31) => namesAt(anchors, pathKey(path31), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
     findingAnchorsAt: (path31) => namesAt(findingAnchors, pathKey(path31), (f) => new Set(f.anchoredNames)),
     originOf: originOf2,
-    possibleOriginsOf
+    possibleOriginsOf,
+    forwardsOf
   };
 }
 function buildRealizationIndex(ctx) {
@@ -16718,6 +16966,25 @@ function resolveCallTarget(ctx, componentId, methodName) {
   }
   return { accepted, files };
 }
+function isTarget(pairs, target) {
+  return pairs.some((p) => target.files.has(p.file) && target.accepted.has(p.name));
+}
+function invokedAs(code, site, file) {
+  const scope = pathKey(site.from ?? file);
+  const facts = code.factsAt(scope);
+  if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") return [];
+  if (!site.member) {
+    const binding = importBindingOf(facts, site.name);
+    if (!binding || binding.namespace) return [];
+    const module3 = resolveImport(scope, binding.from, code.paths);
+    return module3 ? code.forwardsOf(module3, binding.imported ?? site.name) : [];
+  }
+  if (!site.via) return [];
+  const receiver = importBindingOf(facts, site.via);
+  if (!receiver?.namespace) return [];
+  const module2 = resolveImport(scope, receiver.from, code.paths);
+  return module2 ? code.forwardsOf(module2, site.name) : [];
+}
 function claimsOf(implMethod) {
   const claims = [];
   for (const step of implMethod.narrative) {
@@ -16783,6 +17050,7 @@ var callConformanceRule = {
         if (!ctx.componentMap.has(claim.component)) continue;
         const target = resolveCallTarget(ctx, claim.component, claim.method);
         if (target.accepted.has(fnSymbol)) continue;
+        if (isTarget(code.forwardsOf(file, fnSymbol), target)) continue;
         const matching = sites.filter((s) => target.accepted.has(s.name));
         const ref = `${claim.component}.${claim.method}`;
         if (target.files.size === 0) {
@@ -16791,6 +17059,7 @@ var callConformanceRule = {
           }
           continue;
         }
+        if (sites.some((s) => !target.accepted.has(s.name) && isTarget(invokedAs(code, s, file), target))) continue;
         const landed = /* @__PURE__ */ new Set();
         let realized = false;
         for (const site of matching) {
@@ -20087,6 +20356,10 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
             exportedNames: [...facts.exported],
             imports: [...facts.imports],
             reexports: [...facts.reexports],
+            reexportBindings: [
+              ...facts.namedReexports.map(({ exported, local, from }) => ({ exported, local, from })),
+              ...facts.starExports.map((from) => ({ exported: "*", local: "*", from }))
+            ],
             functionComplexity: Object.fromEntries(facts.complexity),
             functionCallSites: Object.fromEntries([...facts.calls].map(([k, v]) => [k, [...v.values()]])),
             importBindings: Object.fromEntries(facts.importBindings),
@@ -20114,6 +20387,28 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
   }
   return { files, projectRoot, rootFiles };
 }
+var IMPORT_FROM_RE = /(?:^|;)[ \t]*import\s+(?!\()([^'";]*?)\s*from\s*['"]([^'"]+)['"]/gm;
+var DYNAMIC_IMPORT_RE = /\{([^{}]*)\}\s*=\s*await\s+import\(\s*['"]([^'"]+)['"]\s*\)/g;
+var IDENTIFIER_ONLY_RE = /^[A-Za-z_$][\w$]*$/;
+function clauseBindings(clause, specifier) {
+  const out = [];
+  const body = clause.replace(/^\s*type\s+/, "");
+  const named = /\{([^}]*)\}/.exec(body);
+  if (named) {
+    for (const piece of named[1].split(",")) {
+      const sides = piece.replace(/^\s*type\s+/, "").split(/\s+as\s+/).map((s) => s.trim());
+      const exported = sides[0];
+      const local = sides[1] ?? exported;
+      if (IDENTIFIER_ONLY_RE.test(exported) && IDENTIFIER_ONLY_RE.test(local)) out.push({ exported, local, specifier });
+    }
+  }
+  const namespace = /\*\s*as\s+([A-Za-z_$][\w$]*)/.exec(body);
+  if (namespace) out.push({ exported: "*", local: namespace[1], specifier });
+  const head = body.replace(/\{[^}]*\}/, "").replace(/\*\s*as\s+[A-Za-z_$][\w$]*/, "");
+  const defaulted = /^\s*([A-Za-z_$][\w$]*)/.exec(head);
+  if (defaulted) out.push({ exported: "default", local: defaulted[1], specifier });
+  return out;
+}
 function readTestFiles(testRoots, projectRoot) {
   const scanned = [];
   for (const key of walkDeclaredRoots(testRoots, [], projectRoot)) {
@@ -20129,25 +20424,100 @@ function readTestFiles(testRoots, projectRoot) {
     for (const m of text2.matchAll(NAMED_IMPORT_BINDINGS_RE)) {
       for (const name of boundNames(m[1] ?? "", false)) imports.add(name);
     }
+    const code = stripComments(text2, JS_PATTERNS);
+    const bindings = [];
+    for (const m of code.matchAll(IMPORT_FROM_RE)) bindings.push(...clauseBindings(m[1], m[2]));
+    for (const m of code.matchAll(DYNAMIC_IMPORT_RE)) bindings.push(...clauseBindings(`{${m[1].replace(/:/g, " as ")}}`, m[2]));
     const words2 = /* @__PURE__ */ new Set();
     for (const m of text2.matchAll(IDENTIFIER_RE)) words2.add(m[0]);
-    scanned.push({ path: key, imports, words: words2 });
+    scanned.push({ path: key, imports, bindings, words: words2 });
   }
   return scanned;
 }
+var NAMED_REEXPORT_RE = /\bexport\s+(?:type\s+)?\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/g;
+var STAR_REEXPORT_RE = /\bexport\s+\*\s+from\s*['"]([^'"]+)['"]/g;
+function reexportReader() {
+  const cache = /* @__PURE__ */ new Map();
+  return (file) => {
+    const cached = cache.get(file);
+    if (cached) return cached;
+    const found = { named: [], stars: [] };
+    try {
+      const code = stripComments(fs10.readFileSync(file, "utf8"), JS_PATTERNS);
+      for (const m of code.matchAll(NAMED_REEXPORT_RE)) {
+        for (const piece of m[1].split(",")) {
+          const sides = piece.replace(/^\s*type\s+/, "").split(/\s+as\s+/).map((s) => s.trim());
+          if (!IDENTIFIER_ONLY_RE.test(sides[0] ?? "")) continue;
+          found.named.push({ local: sides[0], exported: sides[1] ?? sides[0], specifier: m[2] });
+        }
+      }
+      for (const m of code.matchAll(STAR_REEXPORT_RE)) found.stars.push(m[1]);
+    } catch {
+    }
+    cache.set(file, found);
+    return found;
+  };
+}
+function publishesFrom(module2, name, target, symbol, readReexports, visited = /* @__PURE__ */ new Set()) {
+  if (path13.resolve(module2) === target && name === symbol) return true;
+  const key = `${module2}#${name}`;
+  if (visited.has(key)) return false;
+  visited.add(key);
+  const reexports = readReexports(module2);
+  for (const re of reexports.named) {
+    if (re.exported !== name) continue;
+    const next = resolveRelativeModule(module2, re.specifier);
+    if (next && publishesFrom(next, re.local, target, symbol, readReexports, visited)) return true;
+  }
+  if (name === "default") return false;
+  for (const specifier of reexports.stars) {
+    const next = resolveRelativeModule(module2, specifier);
+    if (next && publishesFrom(next, name, target, symbol, readReexports, visited)) return true;
+  }
+  return false;
+}
 function findTestsReferencing(methods, projectRoot, testRoots = []) {
   const scanned = readTestFiles(testRoots, projectRoot);
   if (scanned.length === 0) return [];
   const indiscriminateAbove = scanned.length / 10;
-  const found = [];
+  const searches = [];
   for (const method of methods) {
     const symbol = method.symbol ?? method.name;
-    const imported = scanned.filter((f) => f.imports.has(symbol)).map((f) => f.path);
-    const mentioned = scanned.filter((f) => !f.imports.has(symbol) && f.words.has(symbol)).map((f) => f.path);
+    let search = searches.find((s) => s.method === method.name && s.symbol === symbol);
+    if (!search) {
+      search = { method: method.name, symbol, files: [] };
+      searches.push(search);
+    }
+    const file = method.sourcePath ? path13.resolve(projectRoot, method.sourcePath) : void 0;
+    if (file && !search.files.includes(file)) search.files.push(file);
+  }
+  const readReexports = reexportReader();
+  const found = [];
+  for (const { method, symbol, files } of searches) {
+    const imported = [];
+    const mentioned = [];
+    for (const test of scanned) {
+      if (files.length === 0) {
+        if (test.imports.has(symbol)) imported.push(test.path);
+        else if (test.words.has(symbol)) mentioned.push(test.path);
+        continue;
+      }
+      const testFile = path13.resolve(projectRoot, test.path);
+      const fromMethod = (binding, name) => {
+        const module2 = resolveRelativeModule(testFile, binding.specifier);
+        return module2 !== null && files.some((target) => publishesFrom(module2, name, target, symbol, readReexports));
+      };
+      const naming = test.bindings.filter((b) => b.exported === symbol || b.local === symbol);
+      if (test.bindings.some((b) => b.exported !== "*" && fromMethod(b, b.exported)) || test.words.has(symbol) && test.bindings.some((b) => b.exported === "*" && fromMethod(b, symbol))) {
+        imported.push(test.path);
+      } else if (naming.length === 0 && test.words.has(symbol)) {
+        mentioned.push(test.path);
+      }
+    }
     const indiscriminate = mentioned.length > indiscriminateAbove;
     if (imported.length === 0 && mentioned.length === 0) continue;
     found.push({
-      method: method.name,
+      method,
       symbol,
       imported,
       mentioned: indiscriminate ? [] : mentioned,
@@ -24373,6 +24743,8 @@ var SpecWorkspace = class {
     const plan = this.planMethodMove(source, to, methods, contracts);
     const repointed = this.repointToNewHome(from, to, methods, plan);
     const mentions = this.moveMentions(from, plan);
+    const rename = moveRename(from, to, methods, plan);
+    this.rekeyMoveAllows(plan, rename);
     if (hooks) {
       const verdict = judgeMoveResult(hooks, plan);
       plan.notices.push(...verdict.notices);
@@ -24391,10 +24763,12 @@ var SpecWorkspace = class {
           summary: refusedMoveSummary(from, to, methods, verdict.refusals, alternatives),
           dryRun,
           mentions,
-          created: []
+          created: [],
+          carried: []
         };
       }
     }
+    const carried = projectConfigRepository.rekeyCarried(rename, true);
     if (dryRun) {
       const edits2 = moveChangeReports([...plan.edits.values()], true);
       return {
@@ -24407,13 +24781,16 @@ var SpecWorkspace = class {
         refusals: [],
         alternatives: [],
         notices: plan.notices,
-        summary: `Dry run: moving ${namedMethods(methods)} from "${from}" to "${to}" would touch ${edits2.length} spec${edits2.length === 1 ? "" : "s"}${createdClause(plan.created, "would create")} and re-point ${repointed} reference${repointed === 1 ? "" : "s"}. Nothing was written.`,
+        summary: `Dry run: moving ${namedMethods(methods)} from "${from}" to "${to}" would touch ${edits2.length} spec${edits2.length === 1 ? "" : "s"}${createdClause(plan.created, "would create")} and re-point ${repointed} reference${repointed === 1 ? "" : "s"}${registerClause(carried, "would rekey")}. Nothing was written.`,
         dryRun: true,
         mentions,
-        created: plan.created
+        created: plan.created,
+        carried
       };
     }
-    const edits = this.writeMoveEdits([...plan.edits.values()]);
+    const edits = this.writeMoveEdits([...plan.edits.values()], () => {
+      projectConfigRepository.rekeyCarried(rename);
+    });
     return {
       moved: true,
       from,
@@ -24424,12 +24801,49 @@ var SpecWorkspace = class {
       refusals: [],
       alternatives: [],
       notices: plan.notices,
-      summary: `Moved ${namedMethods(methods)} from "${from}" to "${to}": ${edits.length} spec${edits.length === 1 ? "" : "s"} written${createdClause(plan.created, "created")}, ${repointed} reference${repointed === 1 ? "" : "s"} re-pointed${mentions.length ? `, ${mentions.length} still naming the old home in prose or on the wire` : ""}.`,
+      summary: `Moved ${namedMethods(methods)} from "${from}" to "${to}": ${edits.length} spec${edits.length === 1 ? "" : "s"} written${createdClause(plan.created, "created")}, ${repointed} reference${repointed === 1 ? "" : "s"} re-pointed${registerClause(carried, "rekeyed")}${mentions.length ? `, ${mentions.length} still naming the old home in prose or on the wire` : ""}.`,
       dryRun: false,
       mentions,
-      created: plan.created
+      created: plan.created,
+      carried
     };
   }
+  /**
+   * Rekey every lint allow keyed on a moved method, staging each spec it
+   * changes like any other reference the move follows. An allow anchored at a
+   * moved method on a spec the method left moves to the spec it arrived in; a
+   * covered `<from>.<method>` unit anywhere names `<to>.<method>`. An allow
+   * whose new home the plan does not stage stays where it is.
+   */
+  rekeyMoveAllows(plan, rename) {
+    const subjects = [...this.everySpecInTree()];
+    for (const edit of plan.edits.values()) if (edit.before === null) subjects.push({ kind: edit.kind, id: edit.id, spec: edit.after });
+    const stagedAfter = (kind, id) => plan.edits.get(`${kind}:${id}`)?.after;
+    for (const { kind, id, spec } of subjects) {
+      if (id.includes("::")) continue;
+      const allows = spec?.lint?.allow ?? [];
+      if (allows.length === 0) continue;
+      const staged = plan.edits.get(`${kind}:${id}`);
+      const subject = staged ? staged.after : cloneSpec(spec);
+      const kept = [];
+      let changed = false;
+      for (const allow of subject.lint?.allow ?? []) {
+        const next = rekeyAnchor(rename, { spec: id, ...allow.at !== void 0 ? { at: allow.at } : {}, ...allow.covers ? { covers: allow.covers } : {} });
+        const rekeyed = { ...allow, ...next.at !== void 0 ? { at: next.at } : {}, ...next.covers ? { covers: next.covers } : {} };
+        if (JSON.stringify(rekeyed) !== JSON.stringify(allow)) changed = true;
+        const home = next.spec !== id ? stagedAfter(kind, next.spec) : void 0;
+        if (home) {
+          home.lint = { ...home.lint ?? {}, allow: [...home.lint?.allow ?? [], rekeyed] };
+          changed = true;
+          continue;
+        }
+        kept.push(rekeyed);
+      }
+      if (!changed) continue;
+      subject.lint = { ...subject.lint, allow: kept };
+      if (!staged) this.stageMoveEdit(plan, kind, id, spec, subject);
+    }
+  }
   /**
    * Why this move cannot be attempted at all, or null when the request is
    * answerable. Every check here is about what the CALLER named, so its answer
@@ -24502,8 +24916,10 @@ var SpecWorkspace = class {
       newDependencies: [],
       wireBound: [],
       notices: [],
-      created: []
+      created: [],
+      rehomed: []
     };
+    const leftImplementations = [];
     const receiving = stated ?? createdContract(target, source.id, methods, contracts);
     const arriving = [];
     const travelling = [];
@@ -24515,6 +24931,7 @@ var SpecWorkspace = class {
       const remaining = cloneSpec(contract);
       remaining.methods = remaining.methods.filter((m) => !methods.includes(m.name));
       this.stageMoveEdit(plan, "interface", contract.id, contract, remaining);
+      plan.rehomed.push({ from: contract.id, to: receiving.id });
       if (contract.methods.length === leaving.length) {
         plan.notices.push(`"${contract.id}" is left with no methods \u2014 "${source.id}" no longer declares anything on it.`);
       }
@@ -24526,6 +24943,7 @@ var SpecWorkspace = class {
         const kept = cloneSpec(impl);
         kept.methods = kept.methods.filter((m) => !methods.includes(m.name));
         this.stageMoveEdit(plan, "implementation", impl.id, impl, kept);
+        leftImplementations.push(impl.id);
       }
     }
     this.stageMoveEdit(plan, "interface", receiving.id, stated, {
@@ -24554,9 +24972,11 @@ var SpecWorkspace = class {
         ...cloneSpec(targetImpl),
         methods: [...cloneSpec(targetImpl.methods), ...travelling]
       });
+      for (const id of leftImplementations) plan.rehomed.push({ from: id, to: targetImpl.id });
     } else if (travelling.length > 0) {
       const created = createdImplementation(target, receiving.id, source.id, travelling, implementations, contracts);
       this.stageMoveEdit(plan, "implementation", created.spec.id, null, created.spec);
+      for (const id of leftImplementations) plan.rehomed.push({ from: id, to: created.spec.id });
       plan.created.push(created.named);
       plan.notices.push(...created.notices);
     }
@@ -24686,7 +25106,7 @@ var SpecWorkspace = class {
    * here: every save does it already, and a second call would only be a hop
    * across a component boundary that no narrative claims.
    */
-  writeMoveEdits(edits) {
+  writeMoveEdits(edits, finish) {
     const reports = moveChangeReports(edits, false);
     const written = [];
     try {
@@ -24695,6 +25115,7 @@ var SpecWorkspace = class {
         report.notices.push(...this.saveMovedSpec(edit.kind, edit.after));
         written.push(edit);
       }
+      finish?.();
     } catch (e) {
       for (const edit of [...written].reverse()) {
         try {
@@ -24801,6 +25222,15 @@ function moveChangeReports(edits, dryRun) {
     summary: edit.before === null ? `${dryRun ? "Would create" : "Created"} ${edit.kind} "${edit.id}" to receive the moved methods.` : `${dryRun ? "Would move" : "Moved"} into ${edit.kind} "${edit.id}": ${changes.length} change${changes.length === 1 ? "" : "s"}.`
   }));
 }
+function moveRename(from, to, methods, plan) {
+  return {
+    specs: plan.rehomed.map(({ from: left, to: arrived }) => ({ from: left, to: arrived, sites: [...methods] })),
+    methods: methods.map((method) => ({ component: from, method, toComponent: to, toMethod: method }))
+  };
+}
+function registerClause(carried, verb) {
+  return carried.length ? `, ${verb} ${carried.length} debt-register key${carried.length === 1 ? "" : "s"}` : "";
+}
 function createdClause(created, verb) {
   return created.length ? `, ${verb} ${created.join(" and ")}` : "";
 }
@@ -25490,6 +25920,42 @@ function rewriteRefFields(specsDir, remap, excludeDir) {
   }
   return rewritten;
 }
+function rekeyLintAllows(specsDir, rename) {
+  const rewritten = [];
+  for (const file of listFilesRecursive(specsDir, ".yaml")) {
+    let raw;
+    try {
+      raw = readYamlFile(file);
+    } catch {
+      continue;
+    }
+    const allows = raw?.lint?.allow;
+    const kind = raw && typeof raw === "object" ? specKind(raw) : null;
+    if (!kind || !Array.isArray(allows)) continue;
+    const specId = kind === "system" ? "system" : String(raw.id);
+    let changed = false;
+    for (const allow of allows) {
+      if (!allow || typeof allow !== "object") continue;
+      const next = rekeyAnchor(rename, {
+        spec: specId,
+        ...typeof allow.at === "string" ? { at: allow.at } : {},
+        ...Array.isArray(allow.covers) ? { covers: allow.covers } : {}
+      });
+      if (next.at !== void 0 && next.at !== allow.at) {
+        allow.at = next.at;
+        changed = true;
+      }
+      if (next.covers && JSON.stringify(next.covers) !== JSON.stringify(allow.covers)) {
+        allow.covers = next.covers;
+        changed = true;
+      }
+    }
+    if (!changed) continue;
+    writeYamlFile(file, raw);
+    rewritten.push({ kind, id: specId });
+  }
+  return rewritten;
+}
 function rebaseImplementationPaths(specsDir, fromRoot, toRoot) {
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
     let raw;
@@ -25559,24 +26025,32 @@ function renameComponent(componentId, newId) {
     ...movingInterface ? [{ kind: "interface", from: movingInterface.id, to: interfaceId }] : [],
     ...movingImplementation ? [{ kind: "implementation", from: movingImplementation.id, to: implementationId }] : []
   ];
-  const rewritten = rewriteRefFields(aiPathsAt(getProjectRoot()).specsDir(), (ref, position) => {
+  const rename = {
+    specs: renamed.map(({ from, to }) => ({ from, to })),
+    components: [{ from: componentId, to: newId }]
+  };
+  projectConfigRepository.rekeyCarried(rename, true);
+  const rewrittenRefs = rewriteRefFields(aiPathsAt(getProjectRoot()).specsDir(), (ref, position) => {
     if (position === "component" || position === "entity-class" || position === "auth-source") {
       return ref === componentId ? newId : ref;
     }
     if (position === "interface" && ref === movingInterface?.id) return interfaceId;
     return ref;
-  }).filter((spec) => !renamed.some((moved) => moved.kind === spec.kind && moved.from === spec.id)).map((spec) => spec.id);
+  });
+  const allowsRekeyed = rekeyLintAllows(aiPathsAt(getProjectRoot()).specsDir(), rename);
+  const rewritten = [...new Set([...rewrittenRefs, ...allowsRekeyed].filter((spec) => !renamed.some((moved) => moved.kind === spec.kind && moved.from === spec.id)).map((spec) => spec.id))];
   invalidateSpecCache();
   moveRenamedSpecs(componentId, newId, component, movingInterface, movingImplementation);
-  return { renamed, rewritten };
+  const carried = projectConfigRepository.rekeyCarried(rename);
+  return { renamed, rewritten, carried };
 }
 function moveRenamedSpecs(componentId, newId, component, movingInterface, movingImplementation) {
   const interfaceId = `i${newId}`;
   const implementationId = `${newId}_impl`;
-  const movedComponent = loadComponentSpec(componentId) ?? component;
+  const movedComponent2 = loadComponentSpec(componentId) ?? component;
   const movedInterface = movingInterface ? loadInterfaceSpec(movingInterface.id) ?? movingInterface : null;
   const movedImplementation = movingImplementation ? loadImplementationSpec(movingImplementation.id) ?? movingImplementation : null;
-  saveComponentSpec({ ...movedComponent, id: newId });
+  saveComponentSpec({ ...movedComponent2, id: newId });
   if (movedInterface) saveInterfaceSpec({ ...movedInterface, id: interfaceId, component: newId });
   if (movedImplementation) {
     const oldFile = getImplementationPath(movedImplementation.id);
@@ -25641,6 +26115,19 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   const implementations = loadImplementationSpecs();
   const movingContracts = new Set(moving.map((i) => i.id));
   const renamed = [];
+  const rename = {
+    methods: [{
+      component: componentId,
+      method: methodName,
+      toComponent: componentId,
+      toMethod: newName,
+      specs: [
+        ...moving.map((i) => i.id),
+        ...implementations.filter((impl) => movingContracts.has(impl.contract) && impl.methods.some((m) => m.name === methodName)).map((impl) => impl.id)
+      ]
+    }]
+  };
+  projectConfigRepository.rekeyCarried(rename, true);
   for (const contract of moving) {
     saveInterfaceSpec({
       ...contract,
@@ -25663,8 +26150,11 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   }
   invalidateSpecCache();
   const specsDir = aiPathsAt(getProjectRoot()).specsDir();
-  const rewritten = rewriteRefFields(specsDir, (ref, position, owner) => position === "method" && owner === componentId && ref === methodName ? newName : ref).map((spec) => spec.id);
+  const retargeted = rewriteRefFields(specsDir, (ref, position, owner) => position === "method" && owner === componentId && ref === methodName ? newName : ref);
+  const allowsRekeyed = rekeyLintAllows(specsDir, rename);
+  const rewritten = [...new Set([...retargeted, ...allowsRekeyed].map((spec) => spec.id))];
   const mentions = collectMentions(specsDir, methodName, moving);
+  const carried = projectConfigRepository.rekeyCarried(rename);
   return {
     component: componentId,
     from: methodName,
@@ -25672,7 +26162,8 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
     renamed,
     rewritten,
     mentions,
-    ...pinnedSymbol ? { pinnedSymbol } : {}
+    ...pinnedSymbol ? { pinnedSymbol } : {},
+    carried
   };
 }
 function renameInSignature(signature, from, to) {
@@ -28048,7 +28539,8 @@ var MISSING_PARENT = {
   subsystem: () => "System spec must be initialized (sdd_initialize_system) first.",
   component: (id) => `Parent subsystem "${id}" does not exist.`,
   interface: (id) => `Component "${id}" does not exist.`,
-  implementation: (id) => `Interface contract "${id}" does not exist.`
+  implementation: (id) => `Interface contract "${id}" does not exist.`,
+  type: (id) => `Owning subsystem "${id}" does not exist \u2014 name a subsystem the tree has, or omit subsystem for a system-level value object.`
 };
 var REWRITE_LABEL = {
   system: "System spec",
@@ -28069,6 +28561,8 @@ function restatementParent(restatement) {
       return { kind: "component", id: spec.component };
     case "implementation":
       return { kind: "interface", id: spec.contract };
+    case "type":
+      return typeof spec.subsystem === "string" && spec.subsystem !== "" ? { kind: "subsystem", id: spec.subsystem } : null;
     default:
       return null;
   }
@@ -28272,7 +28766,7 @@ function writeSpec(restatement) {
   if (application.refusal !== void 0) throw new Error(application.refusal);
   const gateNotices = restatement.kind === "component" ? judgeComponent(application.spec, bound2) : [];
   const persisted = persistCandidate(restatement.kind, application.spec);
-  const testsToRevisit = testsInvalidatedBy(application.changedMethods, [existing, application.spec], bound2);
+  const testsToRevisit = testsInvalidatedBy(restatement.kind, id, application.changedMethods, [existing, application.spec], bound2);
   return {
     kind: restatement.kind,
     id,
@@ -28297,42 +28791,59 @@ function persistCandidate(kind, spec) {
   }
   return { notices: saveSpec(kind, spec) };
 }
-function testsInvalidatedBy(methods, specs, options) {
+function testsInvalidatedBy(kind, id, methods, specs, options, written = []) {
   const testRoots = options.rules?.conformance?.testRoots ?? [];
   if (methods.length === 0 || testRoots.length === 0) return [];
-  const symbolOf = (name) => specs.map((s) => (s?.methods ?? []).find((m) => m.name === name)?.symbol).find((symbol) => symbol !== void 0);
-  return findTestsReferencing2(methods.map((name) => ({ name, symbol: symbolOf(name) })), getProjectRoot(), testRoots);
+  return findTestsReferencing2(searchedMethods(kind, id, methods, specs, written), getProjectRoot(), testRoots);
+}
+function searchedMethods(kind, id, names, specs, written) {
+  const stated = (name) => written.find((m) => m?.name === name)?.symbol;
+  if (kind === "interface") {
+    const realizations = loadImplementationSpecs().filter((impl) => impl.contract === id);
+    return names.flatMap((name) => {
+      const found = realizations.flatMap((impl) => impl.methods.filter((m) => m.name === name).map((m) => ({ name, symbol: stated(name) ?? m.symbol, sourcePath: m.sourcePath ?? impl.sourcePath })));
+      return found.length > 0 ? found : [{ name, symbol: stated(name) }];
+    });
+  }
+  return names.map((name) => {
+    const holders = specs.map((spec) => {
+      const holder = spec;
+      const method = holder?.methods?.find((m) => m.name === name);
+      return method ? { method, file: method.sourcePath ?? holder?.sourcePath } : null;
+    }).filter((h) => h !== null);
+    const symbol = stated(name) ?? holders.map((h) => h.method.symbol).find((s) => s !== void 0);
+    const sourcePath = holders.map((h) => h.file).find((f) => f !== void 0) ?? specs.map((spec) => spec?.sourcePath).find((f) => f !== void 0);
+    return { name, symbol, sourcePath };
+  });
 }
 function deleteSpec2(kind, id) {
   const bound2 = candidateOptions();
   const stored = loadSpec(kind, id);
   const deleted = deleteSpec(kind, id);
   const methods = deleted ? (stored?.methods ?? []).map((m) => m.name) : [];
-  const testsToRevisit = testsInvalidatedBy(methods, [stored], bound2);
+  const testsToRevisit = testsInvalidatedBy(kind, id, methods, [stored], bound2);
   return { kind, id, deleted, testsToRevisit };
 }
 function updateSpecGated(kind, id, delta, dryRun) {
   const bound2 = candidateOptions();
   const gate = componentCandidateGate(bound2);
-  const report = updateSpec(kind, id, delta, gate, dryRun);
   const testRoots = bound2.rules?.conformance?.testRoots ?? [];
-  const changed = changedMethods(report, delta);
+  const stored = testRoots.length > 0 ? loadSpec(kind, id) : null;
+  const report = updateSpec(kind, id, delta, gate, dryRun);
+  const changed = changedMethods(report);
   if (changed.length > 0 && testRoots.length > 0) {
-    report.testsToRevisit = findTestsReferencing2(changed, getProjectRoot(), testRoots);
+    const written = Array.isArray(delta?.methods) ? delta.methods : [];
+    report.testsToRevisit = testsInvalidatedBy(kind, id, changed, [stored], bound2, written);
   }
   return report;
 }
-function changedMethods(report, delta) {
+function changedMethods(report) {
   const named = /* @__PURE__ */ new Set();
   for (const change of report.changes) {
     const [field, name] = change.path.split(".");
     if (field === "methods" && name) named.add(name);
   }
-  const written = Array.isArray(delta?.methods) ? delta.methods : [];
-  return [...named].map((name) => ({
-    name,
-    symbol: written.find((m) => m?.name === name)?.symbol
-  }));
+  return [...named];
 }
 function methodMoveGate(source) {
   const bound2 = candidateOptions();
@@ -29288,7 +29799,7 @@ ${renderChangeReport(report)}`,
     server,
     "sdd_rename_component",
     {
-      description: "Rename a component and rewrite every reference to it in the bound tree: dependsOn, owns and dispatch entries, lifecycle entrypoints, published interfaces at L1 and L0, narrative call/dispatch/register targets, an interface's component, an implementation's contract and an entity's componentClass. The interface named i<id> and the implementation named <id>_impl move to the new ids and files; interfaces and implementations named otherwise keep their ids. Display names are left as they are. Refuses, writing nothing: a component that does not exist (component-missing), one inside a chained subproject (chained-component \u2014 rename it from that project's own root), a new id that is not a lowercase identifier without a namespace separator (invalid-id), and a new id \u2014 or i<newId> or <newId>_impl \u2014 already in use (id-taken). Returns the specs moved, each with its old and new id, and the ids of the other specs rewritten.",
+      description: "Rename a component and rewrite every reference to it in the bound tree: dependsOn, owns and dispatch entries, lifecycle entrypoints, published interfaces at L1 and L0, narrative call/dispatch/register targets, an interface's component, an implementation's contract and an entity's componentClass. The interface named i<id> and the implementation named <id>_impl move to the new ids and files; interfaces and implementations named otherwise keep their ids. Findings keyed on the component follow it too: every lint allow naming it on an edge site or in a covered unit, and every entry of the debt register (.wai/project.yaml rules.conformance.carried) anchored on a renamed spec or naming the component in its site or units \u2014 rewritten in place, every comment and all other formatting of the register kept, so unchanged debt never reads as paid and new at once. A register that cannot be rewritten that precisely is refused before the first write. Display names are left as they are. Refuses, writing nothing: a component that does not exist (component-missing), one inside a chained subproject (chained-component \u2014 rename it from that project's own root), a new id that is not a lowercase identifier without a namespace separator (invalid-id), and a new id \u2014 or i<newId> or <newId>_impl \u2014 already in use (id-taken). Returns the specs moved, each with its old and new id, the ids of the other specs rewritten (lint allows included), and `carried`: each register edit \u2014 the entry by code, spec and site as it stood, the key changed (spec, at or covers), from and to.",
       inputSchema: {
         id: import_zod11.z.string().describe("The component to rename (namespaced if needed)"),
         newId: import_zod11.z.string().describe("Its new id: a lowercase identifier with no namespace separator")
@@ -29306,7 +29817,7 @@ ${renderChangeReport(report)}`,
     server,
     "sdd_rename_method",
     {
-      description: "Rename a contract method and retarget every reference to it in the bound tree. The method moves on every interface of the component that declares it \u2014 its name, and the name inside its signature \u2014 and on the implementations of those contracts, carrying narrative, sourcePath, symbol, detail, intent and findings unchanged; an implementation that declared no symbol is pinned to the old name unless pinSymbol is false, so the function it already binds to keeps binding. Narrative call, register and dispatch steps naming this component and method, dispatch-table bindings and lifecycle entrypoints are retargeted. Prose is never rewritten and a gRPC endpoint binding keeps its wire method \u2014 renaming a contract method must not silently rename an RPC; both are reported as mentions. Refuses, writing nothing: a component that does not exist (component-missing), one inside a chained subproject (chained-component \u2014 rename its method from that project's own root), a new name that is not a camel-case identifier (invalid-name), a method the component does not declare (method-missing), and a name a moving contract already declares (name-taken). Returns the specs the method moved in, the specs retargeted, the specs whose prose still names it, and the pinned symbol when one was set.",
+      description: "Rename a contract method and retarget every reference to it in the bound tree. The method moves on every interface of the component that declares it \u2014 its name, and the name inside its signature \u2014 and on the implementations of those contracts, carrying narrative, sourcePath, symbol, detail, intent and findings unchanged; an implementation that declared no symbol is pinned to the old name unless pinSymbol is false, so the function it already binds to keeps binding. Narrative call, register and dispatch steps naming this component and method, dispatch-table bindings and lifecycle entrypoints are retargeted, and so are the findings keyed on it: a lint allow at the method on a spec it moved in or covering `<component>.<method>`, and every debt-register entry (.wai/project.yaml rules.conformance.carried) keyed the same way \u2014 rewritten in place with every comment and all other formatting kept (a register that cannot be rewritten that precisely is refused before the first write). Prose is never rewritten and a gRPC endpoint binding keeps its wire method \u2014 renaming a contract method must not silently rename an RPC; both are reported as mentions. Refuses, writing nothing: a component that does not exist (component-missing), one inside a chained subproject (chained-component \u2014 rename its method from that project's own root), a new name that is not a camel-case identifier (invalid-name), a method the component does not declare (method-missing), and a name a moving contract already declares (name-taken). Returns the specs the method moved in, the specs retargeted (lint allows included), the specs whose prose still names it, the pinned symbol when one was set, and `carried`: each register edit.",
       inputSchema: {
         id: import_zod11.z.string().describe("The component whose method is renamed (namespaced if needed)"),
         method: import_zod11.z.string().describe("The method name as it stands"),
@@ -29326,7 +29837,7 @@ ${renderChangeReport(report)}`,
     server,
     "sdd_move_methods",
     {
-      description: "Move contract methods from one component to another, carrying each method's narrative, calls and bindings, and re-pointing every reference that named the old home: narrative call/register/dispatch steps, dispatch-table bindings, lifecycle entrypoints and `calls` entries. The target gains the dependencies the moved narratives call. ONE all-or-nothing gated write: if a rule refuses the move nothing is written and the report names the rule plus where these methods could live instead, cheapest legal home first, with the requested target among them so its shortfall reads beside the others. Prose is never rewritten and a wire endpoint keeps its address \u2014 moving a method between components must not silently re-address an RPC; both are reported as mentions. A target that declares no contract yet receives one, i<target>, and when implementation entries travel and no implementation realizes the receiving contract, <target>_impl is created for them, inheriting the source implementation's sourcePath; the report's `created` names every spec the move created. Refuses before the first write (unmovable request): a component or method that does not exist, a method name already declared on the target, a source and target that are the same component, a target with several contracts none named i<target>, a contract or implementation to create whose id another spec already holds, and a component inside a chained subproject (move it from that project's own root). A dry run runs the whole move, gate included, and reports what it would have done.",
+      description: "Move contract methods from one component to another, carrying each method's narrative, calls and bindings, and re-pointing every reference that named the old home: narrative call/register/dispatch steps, dispatch-table bindings, lifecycle entrypoints and `calls` entries. The target gains the dependencies the moved narratives call. Findings keyed on a moved method follow it: a lint allow anchored at it moves to the receiving spec, one covering `<from>.<method>` names `<to>.<method>`, and the debt register (.wai/project.yaml rules.conformance.carried) is rekeyed the same way in place, every comment and all other formatting kept \u2014 the report's `carried` lists each register edit, and a register that cannot be rewritten that precisely is refused before the first write. ONE all-or-nothing gated write: if a rule refuses the move nothing is written and the report names the rule plus where these methods could live instead, cheapest legal home first, with the requested target among them so its shortfall reads beside the others. Prose is never rewritten and a wire endpoint keeps its address \u2014 moving a method between components must not silently re-address an RPC; both are reported as mentions. A target that declares no contract yet receives one, i<target>, and when implementation entries travel and no implementation realizes the receiving contract, <target>_impl is created for them, inheriting the source implementation's sourcePath; the report's `created` names every spec the move created. Refuses before the first write (unmovable request): a component or method that does not exist, a method name already declared on the target, a source and target that are the same component, a target with several contracts none named i<target>, a contract or implementation to create whose id another spec already holds, and a component inside a chained subproject (move it from that project's own root). A dry run runs the whole move, gate included, and reports what it would have done.",
       inputSchema: {
         from: import_zod11.z.string().describe("The component the methods belong to (namespaced if needed)"),
         to: import_zod11.z.string().describe("The component that should receive them (namespaced if needed)"),
@@ -29679,7 +30190,7 @@ ${renderChangeReport(report)}`,
     id: import_zod11.z.string().describe("Lowercase identifier"),
     name: import_zod11.z.string().describe("Human-readable name"),
     description: import_zod11.z.string().optional(),
-    subsystem: import_zod11.z.string().optional().describe("Owning subsystem id; omit for a system-level shared value object"),
+    subsystem: import_zod11.z.string().optional().describe("Owning subsystem id; omit for a system-level shared value object. A subsystem the tree does not have is refused and nothing is written"),
     group: import_zod11.z.string().optional().describe("Optional logical group ID to organize this type in subfolders"),
     fields: import_zod11.z.array(import_zod11.z.object({
       name: import_zod11.z.string(),
@@ -29713,7 +30224,7 @@ ${renderChangeReport(report)}`,
     server,
     "sdd_add_type",
     {
-      description: "Define an entity or value-object type (the data components operate on). Entities are owned by a subsystem; shared value objects omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument. A type may also CLAIM code: sourcePath names the file holding its declaration (and each method may name its own), symbol binds the code-level name when it differs \u2014 the file must then resolve and the declaration must be anchored in it. Re-defining an existing id REPLACES fields/methods/invariants and restates sourcePath/symbol (an omitted list or path is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
+      description: "Define an entity or value-object type (the data components operate on). Entities are owned by a subsystem; shared value objects omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument. A type may also CLAIM code: sourcePath names the file holding its declaration (and each method may name its own), symbol binds the code-level name when it differs \u2014 the file must then resolve and the declaration must be anchored in it. An owning subsystem the tree does not have is refused, writing nothing, exactly as a component under an unknown subsystem is. Re-defining an existing id REPLACES fields/methods/invariants and restates sourcePath/symbol (an omitted list or path is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
       inputSchema: typeInput,
       outputSchema: specWriteReceiptOutput
     },