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

package/dist/index.js

@@ -1222,7 +1222,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";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -19332,6 +19332,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 method = holder?.[methodKey2];
+    rewriteMethod(holder, methodKey2, component);
+    rewrite(holder, componentKey, "component", typeof method === "string" ? method : void 0);
+  };
+  const entries = (list) => Array.isArray(list) ? list : [];
+  const rewriteEach = (list, position) => {
+    entries(list).forEach((_, i) => rewrite(list, i, position));
+  };
+  const rewritePublished = (list) => {
+    for (const published of entries(list)) {
+      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 method of entries(raw.methods)) {
+      for (const param of entries(method?.params)) rewrite(param, "type", "type");
+    }
+  } else if (kind === "implementation") {
+    rewrite(raw, "contract", "interface");
+    for (const method of entries(raw.methods)) {
+      for (const step of entries(method?.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(method?.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;
+        method.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 text = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
@@ -19543,6 +19636,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 method = step.targetMethod;
+      if (!target) continue;
+      if (target === from && method && moved.has(method)) 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_FIELDS.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 = path16.resolve(rootDir);
   let ws = workspaces.get(key);
@@ -19771,7 +19942,10 @@ function findLegacySpecFiles() {
 function updateSpec(kind, id, delta, hooks, dryRun) {
   return current().updateSpec(kind, id, delta, hooks, dryRun);
 }
-var fs11, path16, 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 fs11, path16, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, COMPONENT_AUTH_SOURCE, DELTA_VERBS, JUMP_LABEL_TWINS, LABEL_TWIN_CONTAINERS, SpecWorkspace, DEFAULT_DEPENDENCY_LIMIT, PROSE_FIELDS, workspaces;
 var init_specs2 = __esm({
   "src/core/specs.ts"() {
     "use strict";
@@ -19790,6 +19964,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",
@@ -21648,7 +21823,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 report of reports) {
+            const edit = edits.find((e) => e.kind === report.kind && e.id === report.id);
+            report.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_FIELDS = /* @__PURE__ */ new Set([
+      "description",
+      "intent",
+      "summary",
+      "condition",
+      "over",
+      "outcome",
+      "error",
+      "note",
+      "caller"
+    ]);
     workspaces = /* @__PURE__ */ new Map();
   }
 });
@@ -22549,15 +23099,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")) {
@@ -22569,81 +23110,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 = (list) => Array.isArray(list) ? list : [];
-    const rewriteEach = (list, position) => {
-      entries(list).forEach((_, i) => rewrite(list, i, position));
-    };
-    const rewritePublished = (list) => {
-      for (const published of entries(list)) {
-        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 method of raw.methods) {
-        for (const param of entries(method?.params)) rewrite(param, "type", "type");
-      }
-    } else if (kind === "implementation") {
-      rewrite(raw, "contract", "interface");
-      for (const method of raw.methods) {
-        for (const step of entries(method?.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;
 }
@@ -22836,7 +23306,7 @@ function collectMentions(specsDir, methodName, moved) {
   const namesMethod = (value) => {
     if (Array.isArray(value)) return value.some(namesMethod);
     if (!value || typeof value !== "object") return false;
-    return Object.entries(value).some(([key, nested]) => typeof nested === "string" ? PROSE_FIELDS.has(key) && named.test(nested) : namesMethod(nested));
+    return Object.entries(value).some(([key, nested]) => typeof nested === "string" ? PROSE_FIELDS2.has(key) && named.test(nested) : namesMethod(nested));
   };
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
     let raw;
@@ -22855,7 +23325,7 @@ function collectMentions(specsDir, methodName, moved) {
 function identifierPattern(methodName) {
   return new RegExp(`(?<![A-Za-z0-9_])${methodName}(?![A-Za-z0-9_])`);
 }
-var fs14, path20, COMPONENT_AUTH_SOURCE, METHOD_NAME, PROSE_FIELDS;
+var fs14, path20, METHOD_NAME, PROSE_FIELDS2;
 var init_provision = __esm({
   "src/core/provision.ts"() {
     "use strict";
@@ -22868,9 +23338,8 @@ 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([
+    PROSE_FIELDS2 = /* @__PURE__ */ new Set([
       "description",
       "intent",
       "summary",
@@ -27158,6 +27627,7 @@ __export(src_exports, {
   BuiltinTargetConfigSchema: () => BuiltinTargetConfigSchema,
   BuiltinTargetSchema: () => BuiltinTargetSchema,
   BundleNotFoundError: () => BundleNotFoundError,
+  COMPONENT_AUTH_SOURCE: () => COMPONENT_AUTH_SOURCE,
   CONTEXT_PATHS: () => CONTEXT_PATHS,
   CarriedDebtKindSchema: () => CarriedDebtKindSchema,
   CarriedDebtSchema: () => CarriedDebtSchema,
@@ -27462,6 +27932,7 @@ __export(src_exports, {
   methodGenericParameters: () => methodGenericParameters,
   methodSourceFile: () => methodSourceFile,
   methodTypeRefs: () => methodTypeRefs,
+  moveMethods: () => moveMethods,
   moveSubsystemProject: () => moveSubsystemProject,
   narrativeStepForeignFields: () => narrativeStepForeignFields,
   normalizeApprover: () => normalizeApprover,
@@ -27521,6 +27992,7 @@ __export(src_exports, {
   resolveVariantGuidance: () => resolveVariantGuidance,
   restoreSpecFiles: () => restoreSpecFiles,
   retireSpecialists: () => retireSpecialists,
+  rewriteSpecRefs: () => rewriteSpecRefs,
   runWithProjectBinding: () => runWithProjectBinding,
   runWithProjectRoot: () => runWithProjectRoot,
   sameContract: () => sameContract,
@@ -27543,6 +28015,7 @@ __export(src_exports, {
   skillsDirForTarget: () => skillsDirForTarget,
   snapshotSpecFiles: () => snapshotSpecFiles,
   specChanges: () => specChanges,
+  specKind: () => specKind,
   specPathsInScope: () => specPathsInScope,
   splitNamespace: () => splitNamespace,
   stateIdEquals: () => stateIdEquals,
@@ -27898,6 +28371,7 @@ function loadProjectConfig4() {
   BuiltinTargetConfigSchema,
   BuiltinTargetSchema,
   BundleNotFoundError,
+  COMPONENT_AUTH_SOURCE,
   CONTEXT_PATHS,
   CarriedDebtKindSchema,
   CarriedDebtSchema,
@@ -28202,6 +28676,7 @@ function loadProjectConfig4() {
   methodGenericParameters,
   methodSourceFile,
   methodTypeRefs,
+  moveMethods,
   moveSubsystemProject,
   narrativeStepForeignFields,
   normalizeApprover,
@@ -28261,6 +28736,7 @@ function loadProjectConfig4() {
   resolveVariantGuidance,
   restoreSpecFiles,
   retireSpecialists,
+  rewriteSpecRefs,
   runWithProjectBinding,
   runWithProjectRoot,
   sameContract,
@@ -28283,6 +28759,7 @@ function loadProjectConfig4() {
   skillsDirForTarget,
   snapshotSpecFiles,
   specChanges,
+  specKind,
   specPathsInScope,
   splitNamespace,
   stateIdEquals,