@wairon/cli 5.1.1-dev.48 → 5.1.1-dev.49

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.48";
+    WAIRON_VERSION = "5.1.1-dev.49";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -17746,15 +17746,6 @@ function componentIdsUnder(dir) {
   }
   return ids;
 }
-function specKind(raw) {
-  if ("componentType" in raw) return "component";
-  if ("parentSystem" in raw) return "subsystem";
-  if ("vision" in raw) return "system";
-  if ("component" in raw && Array.isArray(raw.methods)) return "interface";
-  if ("contract" in raw && Array.isArray(raw.methods)) return "implementation";
-  if ("kind" in raw && Array.isArray(raw.fields)) return "type";
-  return void 0;
-}
 function rewriteRefFields(specsDir, remap, excludeDir) {
   const rewritten = [];
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
@@ -17766,81 +17757,10 @@ function rewriteRefFields(specsDir, remap, excludeDir) {
       continue;
     }
     if (!raw || typeof raw !== "object") continue;
-    let changed = false;
-    const rewrite = (holder, key, position) => {
-      const ref = holder?.[key];
-      if (typeof ref !== "string") return;
-      const next = remap(ref, position);
-      if (next !== ref) {
-        holder[key] = next;
-        changed = true;
-      }
-    };
-    const rewriteMethod = (holder, key, owner) => {
-      const name = holder?.[key];
-      if (typeof name !== "string" || typeof owner !== "string") return;
-      const next = remap(name, "method", owner);
-      if (next !== name) {
-        holder[key] = next;
-        changed = true;
-      }
-    };
-    const entries = (list2) => Array.isArray(list2) ? list2 : [];
-    const rewriteEach = (list2, position) => {
-      entries(list2).forEach((_, i) => rewrite(list2, i, position));
-    };
-    const rewritePublished = (list2) => {
-      for (const published of entries(list2)) {
-        rewrite(published, "component", "component");
-        rewrite(published, "interface", "interface");
-      }
-    };
     const kind = specKind(raw);
-    if (kind === "component") {
-      rewriteEach(raw.dependsOn, "component");
-      rewriteEach(raw.owns, "component");
-      for (const binding of entries(raw.dispatch)) {
-        rewriteMethod(binding, "method", binding?.component);
-        rewrite(binding, "component", "component");
-      }
-    } else if (kind === "subsystem") {
-      for (const entrypoint of entries(raw.lifecycle)) {
-        rewriteMethod(entrypoint, "method", entrypoint?.component);
-        rewrite(entrypoint, "component", "component");
-      }
-      rewritePublished(raw.publicInterfaces);
-    } else if (kind === "system") {
-      rewritePublished(raw.publicInterfaces);
-    } else if (kind === "interface") {
-      rewrite(raw, "component", "component");
-      for (const method2 of raw.methods) {
-        for (const param of entries(method2?.params)) rewrite(param, "type", "type");
-      }
-    } else if (kind === "implementation") {
-      rewrite(raw, "contract", "interface");
-      for (const method2 of raw.methods) {
-        for (const step of entries(method2?.narrative)) {
-          rewriteMethod(step, "targetMethod", step?.targetComponent);
-          rewrite(step, "targetComponent", "component");
-          const source = step?.auth?.from;
-          if (typeof source === "string" && source.startsWith(COMPONENT_AUTH_SOURCE)) {
-            const id = source.slice(COMPONENT_AUTH_SOURCE.length);
-            const next = remap(id, "auth-source");
-            if (next !== id) {
-              step.auth.from = `${COMPONENT_AUTH_SOURCE}${next}`;
-              changed = true;
-            }
-          }
-        }
-      }
-    } else if (kind === "type") {
-      rewrite(raw, "componentClass", "entity-class");
-      for (const field of raw.fields) rewrite(field, "type", "type");
-    }
-    if (changed && kind) {
-      writeYamlFile(file, raw);
-      rewritten.push({ kind, id: kind === "system" ? "system" : String(raw.id) });
-    }
+    if (!rewriteSpecRefs(raw, remap) || !kind) continue;
+    writeYamlFile(file, raw);
+    rewritten.push({ kind, id: kind === "system" ? "system" : String(raw.id) });
   }
   return rewritten;
 }
@@ -18052,7 +17972,7 @@ function collectMentions(specsDir, methodName, moved) {
 function identifierPattern(methodName) {
   return new RegExp(`(?<![A-Za-z0-9_])${methodName}(?![A-Za-z0-9_])`);
 }
-var fs13, path17, COMPONENT_AUTH_SOURCE, METHOD_NAME, PROSE_FIELDS;
+var fs13, path17, METHOD_NAME, PROSE_FIELDS;
 var init_provision = __esm({
   "src/core/provision.ts"() {
     "use strict";
@@ -18065,7 +17985,6 @@ var init_provision = __esm({
     init_yaml();
     init_errors();
     init_models();
-    COMPONENT_AUTH_SOURCE = "component:";
     METHOD_NAME = /^[a-z][a-zA-Z0-9]*$/;
     PROSE_FIELDS = /* @__PURE__ */ new Set([
       "description",
@@ -24140,6 +24059,7 @@ var init_diagram = __esm({
 // src/core/specs.ts
 var specs_exports = {};
 __export(specs_exports, {
+  COMPONENT_AUTH_SOURCE: () => COMPONENT_AUTH_SOURCE,
   SpecWorkspace: () => SpecWorkspace,
   applySpecStatus: () => applySpecStatus,
   assertContainedProjectPath: () => assertContainedProjectPath,
@@ -24185,6 +24105,7 @@ __export(specs_exports, {
   loadTypeSpec: () => loadTypeSpec,
   loadTypeSpecs: () => loadTypeSpecs,
   markSelectionsBundled: () => markSelectionsBundled,
+  moveMethods: () => moveMethods,
   normalizeComponentLayout: () => normalizeComponentLayout,
   readLockState: () => readLockState,
   rebaseReference: () => rebaseReference,
@@ -24194,6 +24115,7 @@ __export(specs_exports, {
   resolveChainingParent: () => resolveChainingParent,
   resolveSubprojectForNamespace: () => resolveSubprojectForNamespace,
   restoreSpecFiles: () => restoreSpecFiles,
+  rewriteSpecRefs: () => rewriteSpecRefs,
   saveComponentSpec: () => saveComponentSpec,
   saveGroupSpec: () => saveGroupSpec,
   saveImplementationSpec: () => saveImplementationSpec,
@@ -24206,6 +24128,7 @@ __export(specs_exports, {
   setProjectType: () => setProjectType,
   snapshotSpecFiles: () => snapshotSpecFiles,
   specChanges: () => specChanges,
+  specKind: () => specKind,
   specPathsInScope: () => specPathsInScope,
   updateSpec: () => updateSpec,
   upsertPackSelection: () => upsertPackSelection,
@@ -24589,6 +24512,99 @@ function computeSpecTreeSignature(dirs) {
   }
   return parts.join("|");
 }
+function specKind(raw) {
+  if ("componentType" in raw) return "component";
+  if ("parentSystem" in raw) return "subsystem";
+  if ("vision" in raw) return "system";
+  if ("component" in raw && Array.isArray(raw.methods)) return "interface";
+  if ("contract" in raw && Array.isArray(raw.methods)) return "implementation";
+  if ("kind" in raw && Array.isArray(raw.fields)) return "type";
+  return void 0;
+}
+function rewriteSpecRefs(raw, remap) {
+  if (!raw || typeof raw !== "object") return false;
+  let changed = false;
+  const rewrite = (holder, key, position, owner) => {
+    const ref = holder?.[key];
+    if (typeof ref !== "string") return;
+    const next = remap(ref, position, owner);
+    if (next !== ref) {
+      holder[key] = next;
+      changed = true;
+    }
+  };
+  const rewriteMethod = (holder, key, owner) => {
+    const name = holder?.[key];
+    if (typeof name !== "string" || typeof owner !== "string") return;
+    const next = remap(name, "method", owner);
+    if (next !== name) {
+      holder[key] = next;
+      changed = true;
+    }
+  };
+  const rewritePair = (holder, componentKey, methodKey2) => {
+    const component = holder?.[componentKey];
+    const method2 = holder?.[methodKey2];
+    rewriteMethod(holder, methodKey2, component);
+    rewrite(holder, componentKey, "component", typeof method2 === "string" ? method2 : void 0);
+  };
+  const entries = (list2) => Array.isArray(list2) ? list2 : [];
+  const rewriteEach = (list2, position) => {
+    entries(list2).forEach((_, i) => rewrite(list2, i, position));
+  };
+  const rewritePublished = (list2) => {
+    for (const published of entries(list2)) {
+      rewrite(published, "component", "component");
+      rewrite(published, "interface", "interface");
+    }
+  };
+  const kind = specKind(raw);
+  if (kind === "component") {
+    rewriteEach(raw.dependsOn, "component");
+    rewriteEach(raw.owns, "component");
+    for (const binding of entries(raw.dispatch)) rewritePair(binding, "component", "method");
+  } else if (kind === "subsystem") {
+    for (const entrypoint of entries(raw.lifecycle)) rewritePair(entrypoint, "component", "method");
+    rewritePublished(raw.publicInterfaces);
+  } else if (kind === "system") {
+    rewritePublished(raw.publicInterfaces);
+  } else if (kind === "interface") {
+    rewrite(raw, "component", "component");
+    for (const method2 of entries(raw.methods)) {
+      for (const param of entries(method2?.params)) rewrite(param, "type", "type");
+    }
+  } else if (kind === "implementation") {
+    rewrite(raw, "contract", "interface");
+    for (const method2 of entries(raw.methods)) {
+      for (const step of entries(method2?.narrative)) {
+        rewritePair(step, "targetComponent", "targetMethod");
+        const source = step?.auth?.from;
+        if (typeof source === "string" && source.startsWith(COMPONENT_AUTH_SOURCE)) {
+          const id = source.slice(COMPONENT_AUTH_SOURCE.length);
+          const next = remap(id, "auth-source");
+          if (next !== id) {
+            step.auth.from = `${COMPONENT_AUTH_SOURCE}${next}`;
+            changed = true;
+          }
+        }
+      }
+      entries(method2?.calls).forEach((entry, i) => {
+        if (typeof entry !== "string") return;
+        const call = parseDeclaredCall(entry);
+        if (!call) return;
+        const component = remap(call.compId, "component", call.methodName);
+        const name = remap(call.methodName, "method", call.compId);
+        if (component === call.compId && name === call.methodName) return;
+        method2.calls[i] = `${component}.${name}`;
+        changed = true;
+      });
+    }
+  } else if (kind === "type") {
+    rewrite(raw, "componentClass", "entity-class");
+    for (const field of entries(raw.fields)) rewrite(field, "type", "type");
+  }
+  return changed;
+}
 function summarizeValue(value) {
   if (value === void 0) return "";
   const text2 = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
@@ -24800,6 +24816,84 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
   walk2(delta, merged, stored, "", "");
   return out;
 }
+function cloneSpec(spec) {
+  return JSON.parse(JSON.stringify(spec));
+}
+function namedMethods(methods) {
+  return methods.map((m) => `"${m}"`).join(", ");
+}
+function statusOfContracts(contracts, component) {
+  return contracts.find((i) => i.component === component)?.status;
+}
+function reachOf(entries, from, moved) {
+  const reach = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    for (const step of entry.narrative ?? []) {
+      const target = step.targetComponent;
+      const method2 = step.targetMethod;
+      if (!target) continue;
+      if (target === from && method2 && moved.has(method2)) continue;
+      reach.add(target);
+    }
+    for (const call of entry.calls ?? []) {
+      const parsed = parseDeclaredCall(call);
+      if (!parsed) continue;
+      if (parsed.compId === from && moved.has(parsed.methodName)) continue;
+      reach.add(parsed.compId);
+    }
+  }
+  return [...reach].sort();
+}
+function namesInProse(value, named) {
+  if (Array.isArray(value)) return value.some((v) => namesInProse(v, named));
+  if (!value || typeof value !== "object") return false;
+  return Object.entries(value).some(([key, nested]) => typeof nested === "string" ? PROSE_FIELDS2.has(key) && named.test(nested) : namesInProse(nested, named));
+}
+function judgeMoveResult(hooks, plan) {
+  const refusals = [];
+  const notices = [];
+  for (const resulting of [plan.edits.get(`component:${plan.source.id}`), plan.edits.get(`component:${plan.target.id}`)]) {
+    if (!resulting) continue;
+    try {
+      const raised = hooks.gate?.("component", resulting.after);
+      if (raised?.length) notices.push(...raised);
+    } catch (e) {
+      const codes = hooks.assess?.("component", resulting.after) ?? [];
+      refusals.push(...codes.length ? codes : [String(e?.message ?? e)]);
+    }
+  }
+  return { refusals: [...new Set(refusals)], notices };
+}
+function weighMoveHome(hooks, candidate, reach, dependencyLimit) {
+  const held = /* @__PURE__ */ new Set([...candidate.dependsOn ?? [], ...candidate.owns ?? []]);
+  const newDependencies = reach.filter((id) => id !== candidate.id && !held.has(id));
+  const resulting = { ...candidate, dependsOn: [...candidate.dependsOn ?? [], ...newDependencies] };
+  const refusals = hooks.assess?.("component", resulting) ?? [];
+  return {
+    component: candidate.id,
+    legal: refusals.length === 0,
+    newDependencies,
+    dependencyCount: resulting.dependsOn.length,
+    dependencyLimit,
+    refusals
+  };
+}
+function moveChangeReports(edits, dryRun) {
+  return edits.map((edit) => ({ edit, changes: specChanges(edit.before, edit.after) })).filter(({ changes }) => changes.length > 0).map(({ edit, changes }) => ({
+    kind: edit.kind,
+    id: edit.id,
+    written: !dryRun,
+    dryRun,
+    changes,
+    ineffective: [],
+    notices: [],
+    summary: `${dryRun ? "Would move" : "Moved"} into ${edit.kind} "${edit.id}": ${changes.length} change${changes.length === 1 ? "" : "s"}.`
+  }));
+}
+function refusedMoveSummary(from, to, methods, refusals, alternatives) {
+  const cheapest = alternatives.find((c) => c.legal);
+  return `Refused: moving ${namedMethods(methods)} from "${from}" to "${to}" is refused by ${refusals.join(", ")}. Nothing was written. ` + (cheapest ? `The cheapest legal home is "${cheapest.component}" (${cheapest.newDependencies.length} new dependenc${cheapest.newDependencies.length === 1 ? "y" : "ies"}, ${cheapest.dependencyCount} of ${cheapest.dependencyLimit}).` : `No component of this subsystem can take them as they stand \u2014 ${alternatives.length} were weighed.`);
+}
 function workspaceFor(rootDir) {
   const key = path23.resolve(rootDir);
   let ws = workspaces.get(key);
@@ -25028,7 +25122,10 @@ function findLegacySpecFiles() {
 function updateSpec(kind, id, delta, hooks, dryRun) {
   return current().updateSpec(kind, id, delta, hooks, dryRun);
 }
-var fs17, path23, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, DELTA_VERBS, JUMP_LABEL_TWINS, LABEL_TWIN_CONTAINERS, SpecWorkspace, workspaces;
+function moveMethods(from, to, methods, hooks, dryRun) {
+  return current().moveMethods(from, to, methods, hooks, dryRun);
+}
+var fs17, path23, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, COMPONENT_AUTH_SOURCE, DELTA_VERBS, JUMP_LABEL_TWINS, LABEL_TWIN_CONTAINERS, SpecWorkspace, DEFAULT_DEPENDENCY_LIMIT, PROSE_FIELDS2, workspaces;
 var init_specs2 = __esm({
   "src/core/specs.ts"() {
     "use strict";
@@ -25047,6 +25144,7 @@ var init_specs2 = __esm({
     init_diagram();
     NO_ROOT_SUBSYSTEMS = /* @__PURE__ */ new Set();
     SIGNATURE_TTL_MS = 2e3;
+    COMPONENT_AUTH_SOURCE = "component:";
     DELTA_VERBS = /* @__PURE__ */ new Set(["action", "remove", "captureJumps"]);
     JUMP_LABEL_TWINS = /* @__PURE__ */ new Set([
       "onTrueLabel",
@@ -26905,7 +27003,382 @@ var init_specs2 = __esm({
           summary: `Updated ${kind} "${id}": ${changes.length} change${changes.length === 1 ? "" : "s"}.`
         };
       }
+      // -------------------------------------------------------------------------
+      // Method move (icore_orchestrator.moveMethods)
+      //
+      // A rename changes a NAME and can stay mechanical. A move changes which
+      // component OWNS behaviour, which is exactly what the stereotype and
+      // dependency rules judge — so the mechanics live here and the judgement
+      // arrives as an injected hook, for the same reason `gate` does: this module
+      // must not import the rule engine.
+      //
+      // It is several writes at once: both contracts, both implementations, the
+      // target component (which gains the dependencies the moved narratives call),
+      // and every caller whose steps, dispatch bindings, lifecycle entrypoints or
+      // `calls` entries name the old home. Every edit is computed before the first
+      // is written and a failed write restores the ones already made, because a
+      // half-moved method leaves callers naming a home it no longer has.
+      // -------------------------------------------------------------------------
+      /**
+       * Move contract methods from one component to another, and every reference
+       * with them.
+       *
+       * Each method leaves the source component's contract and arrives on the
+       * target's, carrying its signature, params, returns, guarantees and endpoint
+       * binding unchanged; its implementation entry travels with it, carrying
+       * narrative, sourcePath, symbol, detail, intent, calls and findings. Prose is
+       * never rewritten and a wire endpoint keeps its address — moving a method
+       * between components must not silently re-address an RPC — so both are
+       * reported as mentions instead.
+       *
+       * 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, and a component inside a chained
+       * subproject.
+       */
+      moveMethods(from, to, methods, hooks, dryRun = false) {
+        const source = this.loadComponentSpec(from);
+        const complaint = this.unmovableRequest(source, from, to, methods);
+        if (complaint) throw new Error(`unmovable request: ${complaint}`);
+        const contracts = this.loadInterfaceSpecs();
+        const plan = this.planMethodMove(source, to, methods, contracts);
+        const repointed = this.repointToNewHome(from, to, methods, plan);
+        const mentions = this.moveMentions(from, plan);
+        if (hooks) {
+          const verdict = judgeMoveResult(hooks, plan);
+          plan.notices.push(...verdict.notices);
+          if (verdict.refusals.length > 0) {
+            const alternatives = this.rankMoveHomes(hooks, from, to, plan);
+            return {
+              moved: false,
+              from,
+              to,
+              methods,
+              edits: [],
+              repointed: 0,
+              refusals: verdict.refusals,
+              alternatives,
+              notices: plan.notices,
+              summary: refusedMoveSummary(from, to, methods, verdict.refusals, alternatives),
+              dryRun,
+              mentions
+            };
+          }
+        }
+        if (dryRun) {
+          const edits2 = moveChangeReports([...plan.edits.values()], true);
+          return {
+            moved: false,
+            from,
+            to,
+            methods,
+            edits: edits2,
+            repointed,
+            refusals: [],
+            alternatives: [],
+            notices: plan.notices,
+            summary: `Dry run: moving ${namedMethods(methods)} from "${from}" to "${to}" would touch ${edits2.length} spec${edits2.length === 1 ? "" : "s"} and re-point ${repointed} reference${repointed === 1 ? "" : "s"}. Nothing was written.`,
+            dryRun: true,
+            mentions
+          };
+        }
+        const edits = this.writeMoveEdits([...plan.edits.values()]);
+        return {
+          moved: true,
+          from,
+          to,
+          methods,
+          edits,
+          repointed,
+          refusals: [],
+          alternatives: [],
+          notices: plan.notices,
+          summary: `Moved ${namedMethods(methods)} from "${from}" to "${to}": ${edits.length} spec${edits.length === 1 ? "" : "s"} written, ${repointed} reference${repointed === 1 ? "" : "s"} re-pointed${mentions.length ? `, ${mentions.length} still naming the old home in prose or on the wire` : ""}.`,
+          dryRun: false,
+          mentions
+        };
+      }
+      /**
+       * 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
+       * is a mistake to correct — never a rule refusing the design.
+       */
+      unmovableRequest(source, from, to, methods) {
+        const chained = [from, to].find((id) => id.includes("::"));
+        if (chained) {
+          return `"${chained}" lives in a chained subproject; move its methods from that project's own root.`;
+        }
+        if (!source) return `no component has the id "${from}".`;
+        if (!this.loadComponentSpec(to)) return `no component has the id "${to}".`;
+        if (from === to) return `"${from}" is both the source and the target; a method cannot move to where it already lives.`;
+        if (methods.length === 0) return "no method names were given.";
+        const contracts = this.loadInterfaceSpecs();
+        const ofSource = contracts.filter((i) => i.component === from);
+        const ofTarget = contracts.filter((i) => i.component === to);
+        for (const name of methods) {
+          const declaring = ofSource.filter((i) => i.methods.some((m) => m.name === name));
+          if (declaring.length === 0) return `no contract of "${from}" declares the method "${name}".`;
+          if (declaring.length > 1) {
+            return `${declaring.map((i) => `"${i.id}"`).join(" and ")} both declare "${name}" on "${from}" \u2014 a move has to know which contract the method leaves, so split or rename them first.`;
+          }
+        }
+        const taken = methods.filter((name) => ofTarget.some((i) => i.methods.some((m) => m.name === name)));
+        if (taken.length > 0) {
+          return `"${to}" already declares ${namedMethods(taken)}.`;
+        }
+        const receiving = this.moveTargetContract(to, ofTarget);
+        if (typeof receiving === "string") return receiving;
+        const travelling = this.loadImplementationSpecs().some((impl) => ofSource.some((i) => i.id === impl.contract) && impl.methods.some((m) => methods.includes(m.name)));
+        if (travelling && !this.loadImplementationSpecs().some((i) => i.contract === receiving.id)) {
+          return `no implementation realizes "${receiving.id}", so the moved methods' narratives would have nowhere to arrive.`;
+        }
+        return null;
+      }
+      /** The contract of `to` that receives the methods, or why that cannot be decided. */
+      moveTargetContract(to, ofTarget) {
+        if (ofTarget.length === 0) return `"${to}" declares no contract, so the methods would have nowhere to arrive.`;
+        if (ofTarget.length === 1) return ofTarget[0];
+        const named = ofTarget.find((i) => i.id === `i${to}` || i.id.endsWith(`::i${to}`));
+        return named ?? `"${to}" declares ${ofTarget.length} contracts and none is named "i${to}", so which one receives the methods is not decidable.`;
+      }
+      /**
+       * The whole move as staged edits, computed before anything is written: the
+       * contract entries that leave the source and arrive on the target, the
+       * implementation entries that travel with them, and the dependencies the
+       * moved narratives call that the target does not have yet.
+       */
+      planMethodMove(source, to, methods, contracts) {
+        const target = this.loadComponentSpec(to);
+        const receiving = this.moveTargetContract(to, contracts.filter((i) => i.component === to));
+        const implementations = this.loadImplementationSpecs();
+        const plan = {
+          edits: /* @__PURE__ */ new Map(),
+          source,
+          target,
+          reach: [],
+          newDependencies: [],
+          wireBound: [],
+          notices: []
+        };
+        const arriving = [];
+        const travelling = [];
+        for (const contract of contracts.filter((i) => i.component === source.id)) {
+          const leaving = contract.methods.filter((m) => methods.includes(m.name));
+          if (leaving.length === 0) continue;
+          arriving.push(...cloneSpec(leaving));
+          const remaining = cloneSpec(contract);
+          remaining.methods = remaining.methods.filter((m) => !methods.includes(m.name));
+          this.stageMoveEdit(plan, "interface", contract.id, contract, remaining);
+          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.`);
+          }
+          for (const impl of implementations.filter((i) => i.contract === contract.id)) {
+            const moving = impl.methods.filter((m) => methods.includes(m.name));
+            if (moving.length === 0) continue;
+            travelling.push(...cloneSpec(moving));
+            const kept = cloneSpec(impl);
+            kept.methods = kept.methods.filter((m) => !methods.includes(m.name));
+            this.stageMoveEdit(plan, "implementation", impl.id, impl, kept);
+          }
+        }
+        this.stageMoveEdit(plan, "interface", receiving.id, receiving, {
+          ...cloneSpec(receiving),
+          methods: [...cloneSpec(receiving.methods), ...arriving]
+        });
+        if (arriving.some((m) => m.endpoint)) plan.wireBound.push(receiving.id);
+        if (receiving.status !== void 0 && receiving.status !== statusOfContracts(contracts, source.id)) {
+          plan.notices.push(`"${receiving.id}" is ${receiving.status} where the methods came from a ${statusOfContracts(contracts, source.id)} contract \u2014 the status of a moved method is the status of its new home.`);
+        }
+        for (const entry of travelling) {
+          if ((entry.narrative ?? []).length === 0 && !entry.intent) {
+            plan.notices.push(`"${entry.name}" moves with an empty narrative and no intent \u2014 nothing followed it but its name.`);
+          }
+        }
+        const targetImpl = implementations.find((i) => i.contract === receiving.id);
+        if (travelling.length > 0 && targetImpl) {
+          this.stageMoveEdit(plan, "implementation", targetImpl.id, targetImpl, {
+            ...cloneSpec(targetImpl),
+            methods: [...cloneSpec(targetImpl.methods), ...travelling]
+          });
+        }
+        plan.reach = reachOf(travelling, source.id, new Set(methods)).filter((id) => id !== to);
+        const held = /* @__PURE__ */ new Set([...target.dependsOn ?? [], ...target.owns ?? []]);
+        plan.newDependencies = plan.reach.filter((id) => !held.has(id) && id !== to);
+        this.stageMoveEdit(plan, "component", source.id, source, cloneSpec(source));
+        this.stageMoveEdit(plan, "component", target.id, target, {
+          ...cloneSpec(target),
+          dependsOn: [...target.dependsOn ?? [], ...plan.newDependencies]
+        });
+        return plan;
+      }
+      /** Stage one spec's rewrite, keeping the version it started from as the snapshot a failed write restores. */
+      stageMoveEdit(plan, kind, id, before, after) {
+        plan.edits.set(`${kind}:${id}`, { kind, id, before, after });
+      }
+      /**
+       * Re-point every reference that names the old home, through the one
+       * reference-field table, and answer with how many followed.
+       *
+       * A reference is only re-pointed when it names BOTH the old home and a method
+       * that is moving: another method of the same component, and another
+       * component's method of the same name, stay exactly where they point.
+       */
+      repointToNewHome(from, to, methods, plan) {
+        const moved = new Set(methods);
+        let repointed = 0;
+        const remap = (ref, position, owner) => {
+          if (position !== "component" || ref !== from || !owner || !moved.has(owner)) return ref;
+          repointed += 1;
+          return to;
+        };
+        for (const { kind, id, spec } of this.everySpecInTree()) {
+          const staged = plan.edits.get(`${kind}:${id}`);
+          const subject = staged ? staged.after : cloneSpec(spec);
+          if (!rewriteSpecRefs(subject, remap)) continue;
+          if (staged) continue;
+          if (id.includes("::")) {
+            plan.notices.push(`"${id}" lives in a chained subproject and still names "${from}" \u2014 re-point it from that project's own root.`);
+            repointed -= 1;
+            continue;
+          }
+          this.stageMoveEdit(plan, kind, id, spec, subject);
+        }
+        plan.notices.push(...this.callersOwingADependency(to, plan));
+        return repointed;
+      }
+      /**
+       * The components that now reach the new home without declaring it. The move
+       * re-points the reference; it never edits another component's dependency
+       * list, because a dependency nobody judged is exactly what the gate exists to
+       * prevent.
+       */
+      callersOwingADependency(to, plan) {
+        const contracts = this.loadInterfaceSpecs();
+        const owing = /* @__PURE__ */ new Set();
+        for (const edit of plan.edits.values()) {
+          const owner = edit.kind === "component" ? edit.id : contracts.find((i) => i.id === edit.after.contract)?.component;
+          if (!owner || owner === to) continue;
+          const component = owner === plan.target.id ? plan.target : this.loadComponentSpec(owner);
+          if (!component) continue;
+          const held = /* @__PURE__ */ new Set([...component.dependsOn ?? [], ...component.owns ?? []]);
+          if (!held.has(to)) owing.add(owner);
+        }
+        return [...owing].map((id) => `"${id}" now reaches "${to}" but does not declare it \u2014 add the dependency, or the call is undeclared.`);
+      }
+      /**
+       * Where these methods could live instead, cheapest legal home first, with the
+       * requested target among them so its shortfall reads beside the others.
+       *
+       * The store enumerates, because the store holds the tree; the hook judges,
+       * because the gate holds the judgement. `assess` answers rather than throws,
+       * so this is a search and not a sequence of caught exceptions.
+       */
+      rankMoveHomes(hooks, from, to, plan) {
+        const limit = this.dependencyLimit();
+        const pool = this.loadComponentSpecs().filter((c) => c.subsystem === plan.source.subsystem && c.id !== from);
+        if (!pool.some((c) => c.id === to)) pool.push(plan.target);
+        return pool.map((candidate) => weighMoveHome(hooks, candidate, plan.reach, limit)).sort((a, b) => Number(b.legal) - Number(a.legal) || a.newDependencies.length - b.newDependencies.length || a.component.localeCompare(b.component));
+      }
+      /**
+       * The project's `maxComponentDependencies`, so a candidate's dependency count
+       * can be read without looking up the config. A project that sets none is read
+       * against the same default the coupling-health rule applies.
+       */
+      dependencyLimit() {
+        try {
+          return projectConfigRepository.load()?.rules?.complexity?.maxComponentDependencies ?? DEFAULT_DEPENDENCY_LIMIT;
+        } catch {
+          return DEFAULT_DEPENDENCY_LIMIT;
+        }
+      }
+      /** Every spec in the bound tree, with the kind and id a staged edit addresses it by. */
+      *everySpecInTree() {
+        const system = this.loadSystemSpec();
+        if (system) yield { kind: "system", id: system.name, spec: system };
+        for (const spec of this.loadSubsystemSpecs()) yield { kind: "subsystem", id: spec.id, spec };
+        for (const spec of this.loadComponentSpecs()) yield { kind: "component", id: spec.id, spec };
+        for (const spec of this.loadInterfaceSpecs()) yield { kind: "interface", id: spec.id, spec };
+        for (const spec of this.loadImplementationSpecs()) yield { kind: "implementation", id: spec.id, spec };
+        for (const spec of this.loadTypeSpecs()) yield { kind: "type", id: spec.id, spec };
+      }
+      /**
+       * What still names the old home once the move is written, every one of it
+       * left exactly as it was: the specs whose prose carries the id, and the
+       * receiving contract whose moved methods keep their wire address. A move
+       * never edits prose and never re-addresses an RPC.
+       */
+      moveMentions(from, plan) {
+        const mentions = new Set(plan.wireBound);
+        const named = new RegExp(`(?<![A-Za-z0-9_])${from}(?![A-Za-z0-9_])`);
+        for (const { kind, id, spec } of this.everySpecInTree()) {
+          if (namesInProse(spec, named)) mentions.add(kind === "system" ? "system" : id);
+        }
+        return [...mentions];
+      }
+      /**
+       * Write every staged edit, restoring the ones already written if one fails.
+       *
+       * The snapshots are the versions the plan started from, so a restore puts the
+       * authored content back exactly; only `updatedAt` reads as touched, because
+       * the store stamps every write it accepts. Nothing invalidates the cache
+       * 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) {
+        const reports = moveChangeReports(edits, false);
+        const written = [];
+        try {
+          for (const report2 of reports) {
+            const edit = edits.find((e) => e.kind === report2.kind && e.id === report2.id);
+            report2.notices.push(...this.saveMovedSpec(edit.kind, edit.after));
+            written.push(edit);
+          }
+        } catch (e) {
+          for (const edit of [...written].reverse()) {
+            try {
+              this.saveMovedSpec(edit.kind, edit.before);
+            } catch {
+            }
+          }
+          throw new Error(
+            `move-write-failed: ${String(e?.message ?? e)} \u2014 ${written.length} edit${written.length === 1 ? "" : "s"} already written ${written.length === 1 ? "was" : "were"} restored, so nothing moved.`
+          );
+        }
+        return reports;
+      }
+      /** Persist one moved spec through the store's own writer, and answer with its placement notices. */
+      saveMovedSpec(kind, spec) {
+        const opts = { allowStatusDemotion: true };
+        switch (kind) {
+          case "system":
+            this.saveSystemSpec(spec);
+            return [];
+          case "subsystem":
+            this.saveSubsystemSpec(spec, opts);
+            return [];
+          case "component":
+            return this.saveComponentSpec(spec, opts);
+          case "interface":
+            return this.saveInterfaceSpec(spec, opts);
+          case "implementation":
+            return this.saveImplementationSpec(spec, opts);
+          case "type":
+            return this.saveTypeSpec(spec);
+        }
+      }
     };
+    DEFAULT_DEPENDENCY_LIMIT = 8;
+    PROSE_FIELDS2 = /* @__PURE__ */ new Set([
+      "description",
+      "intent",
+      "summary",
+      "condition",
+      "over",
+      "outcome",
+      "error",
+      "note",
+      "caller"
+    ]);
     workspaces = /* @__PURE__ */ new Map();
   }
 });
@@ -27773,6 +28246,32 @@ function addComponent(candidate) {
 function updateSpecGated(kind, id, delta, dryRun) {
   return updateSpec(kind, id, delta, componentCandidateGate(), dryRun);
 }
+function methodMoveGate(source) {
+  const bound2 = candidateOptions();
+  return {
+    gate: (kind, merged) => {
+      if (kind !== "component") return;
+      const { codes, verdict, ceiling } = judgeMoveHome(merged, source, bound2);
+      if (codes.length === 0) return noticesFrom(verdict);
+      throw new Error(
+        `${codes.join(", ")} refuses "${merged.id}" as the home for these methods. ` + (verdict.errors.length ? formatCandidateRefusal(verdict) : `It would reach ${merged.dependsOn?.length ?? 0} dependencies against a ceiling of ${ceiling}.`)
+      );
+    },
+    assess: (kind, merged) => kind === "component" ? judgeMoveHome(merged, source, bound2).codes : []
+  };
+}
+function judgeMoveHome(component, source, options) {
+  const ceiling = options.rules?.complexity?.maxComponentDependencies;
+  const verdict = validateComponentCandidate(component, options);
+  const codes = verdict.errors.map((e) => e.code);
+  if (component.id !== source && ceiling !== void 0 && (component.dependsOn?.length ?? 0) > ceiling) {
+    codes.push("EXCESSIVE_DEPENDENCIES");
+  }
+  return { codes: [...new Set(codes)], verdict, ceiling };
+}
+function moveMethods2(from, to, methods, dryRun) {
+  return moveMethods(from, to, methods, methodMoveGate(from), dryRun);
+}
 var init_authoring = __esm({
   "src/core/authoring.ts"() {
     "use strict";
@@ -28529,6 +29028,31 @@ function createMcpServer(options = {}) {
       }
     }
   );
+  reg(
+    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. 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, 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)"),
+        methods: import_zod11.z.array(import_zod11.z.string()).describe("The method names to move; every one must exist on the source contract"),
+        dryRun: import_zod11.z.boolean().optional().describe("Answer with what the move would do and write nothing")
+      }
+    },
+    ({ from, to, methods, dryRun }) => {
+      try {
+        const { loadComponentSpec: loadComponentSpec2 } = requireSpecs();
+        const source = qualifiedComponentId(from);
+        const target = qualifiedComponentId(to);
+        if (!loadComponentSpec2(source)) return errText(`no component has the id "${from}".`);
+        if (!loadComponentSpec2(target)) return errText(`no component has the id "${to}".`);
+        return json(moveMethods2(source, target, methods, dryRun));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
   const componentInput = {
     id: import_zod11.z.string().describe("Lowercase identifier for the component"),
     name: import_zod11.z.string().describe("Human-readable display name"),