@wairon/cli 5.1.1-dev.96 → 5.1.1-dev.98

package/dist/index.js

@@ -1672,15 +1672,15 @@ var require_node = __commonJS({
     var slzh = function(d, b) {
       return b + 30 + b2(d, b + 26) + b2(d, b + 28);
     };
-    var zh = function(d, b, z12) {
+    var zh = function(d, b, z13) {
       var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
-      var _a2 = z64hs(d, es, efl, z12, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+      var _a2 = z64hs(d, es, efl, z13, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
       return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
     };
-    var z64hs = function(d, b, l, z12, sc, su, off) {
+    var z64hs = function(d, b, l, z13, sc, su, off) {
       var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
       var nf = nsc + nsu + noff;
-      if (z12 && nf) {
+      if (z13 && nf) {
         for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
           if (b2(d, b) == 1) {
             return [
@@ -1691,7 +1691,7 @@ var require_node = __commonJS({
             ];
           }
         }
-        if (z12 < 2)
+        if (z13 < 2)
           err(13);
       }
       return [sc, su, off, 0];
@@ -2300,18 +2300,18 @@ var require_node = __commonJS({
       if (lft) {
         var c = lft;
         var o = b4(data, e + 16);
-        var z12 = b4(data, e - 20) == 117853008;
-        if (z12) {
+        var z13 = b4(data, e - 20) == 117853008;
+        if (z13) {
           var ze = b4(data, e - 12);
-          z12 = b4(data, ze) == 101075792;
-          if (z12) {
+          z13 = b4(data, ze) == 101075792;
+          if (z13) {
             c = lft = b4(data, ze + 32);
             o = b4(data, ze + 48);
           }
         }
         var fltr = opts && opts.filter;
         var _loop_3 = function(i3) {
-          var _a2 = zh(data, o, z12), c_1 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+          var _a2 = zh(data, o, z13), c_1 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
           o = no;
           var cbl = function(e2, d) {
             if (e2) {
@@ -2366,18 +2366,18 @@ var require_node = __commonJS({
       if (!c)
         return {};
       var o = b4(data, e + 16);
-      var z12 = b4(data, e - 20) == 117853008;
-      if (z12) {
+      var z13 = b4(data, e - 20) == 117853008;
+      if (z13) {
         var ze = b4(data, e - 12);
-        z12 = b4(data, ze) == 101075792;
-        if (z12) {
+        z13 = b4(data, ze) == 101075792;
+        if (z13) {
           c = b4(data, ze + 32);
           o = b4(data, ze + 48);
         }
       }
       var fltr = opts && opts.filter;
       for (var i2 = 0; i2 < c; ++i2) {
-        var _a2 = zh(data, o, z12), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+        var _a2 = zh(data, o, z13), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
         o = no;
         if (!fltr || fltr({
           name: fn,
@@ -3414,9 +3414,30 @@ __export(src_exports, {
   CustomTargetConfigSchema: () => CustomTargetConfigSchema,
   CustomTargetSchema: () => CustomTargetSchema,
   DEFAULT_TARGET_DIRS: () => DEFAULT_TARGET_DIRS,
+  DESIGN_APPROVALS: () => DESIGN_APPROVALS,
+  DESIGN_DEPENDENCY_ROLES: () => DESIGN_DEPENDENCY_ROLES,
+  DESIGN_FORMAT: () => DESIGN_FORMAT,
+  DESIGN_FORMAT_VERSION: () => DESIGN_FORMAT_VERSION,
   DatabaseSpecSchema: () => DatabaseSpecSchema,
   DependencyClassSchema: () => DependencyClassSchema,
+  DesignApprovalSchema: () => DesignApprovalSchema,
+  DesignComponentSchema: () => DesignComponentSchema,
+  DesignDependencyRoleSchema: () => DesignDependencyRoleSchema,
+  DesignDependencySchema: () => DesignDependencySchema,
   DesignDepthSchema: () => DesignDepthSchema,
+  DesignExportEntrySchema: () => DesignExportEntrySchema,
+  DesignExportSchema: () => DesignExportSchema,
+  DesignFieldSchema: () => DesignFieldSchema,
+  DesignImplementationSchema: () => DesignImplementationSchema,
+  DesignInterfaceSchema: () => DesignInterfaceSchema,
+  DesignMethodBodySchema: () => DesignMethodBodySchema,
+  DesignMethodSchema: () => DesignMethodSchema,
+  DesignParamSchema: () => DesignParamSchema,
+  DesignProjectSchema: () => DesignProjectSchema,
+  DesignSourceSchema: () => DesignSourceSchema,
+  DesignSubsystemSchema: () => DesignSubsystemSchema,
+  DesignTypeRefSchema: () => DesignTypeRefSchema,
+  DesignTypeSchema: () => DesignTypeSchema,
   DiagramConfigSchema: () => DiagramConfigSchema,
   DispatchBindingSchema: () => DispatchBindingSchema,
   DoctorOptionsError: () => DoctorOptionsError,
@@ -3476,6 +3497,8 @@ __export(src_exports, {
   PortalAuthSchemeSchema: () => PortalAuthSchemeSchema,
   PortalMountSchema: () => PortalMountSchema,
   PortalTypeSchema: () => PortalTypeSchema,
+  PreviousIdsSchema: () => PreviousIdsSchema,
+  PreviousNamesSchema: () => PreviousNamesSchema,
   ProfileSelectionSubjectSchema: () => ProfileSelectionSubjectSchema,
   ProjectConfigSchema: () => ProjectConfigSchema,
   ProjectNotInitializedError: () => ProjectNotInitializedError,
@@ -3519,6 +3542,7 @@ __export(src_exports, {
   TopologyConfigSchema: () => TopologyConfigSchema,
   TransportSchema: () => TransportSchema,
   TrustedLinkSchema: () => TrustedLinkSchema,
+  TypeExpressionSchema: () => TypeExpressionSchema,
   TypeFieldSchema: () => TypeFieldSchema,
   TypeKindSchema: () => TypeKindSchema,
   TypeMethodSchema: () => TypeMethodSchema,
@@ -3606,6 +3630,7 @@ __export(src_exports, {
   ensureDir: () => ensureDir,
   ensureProjectInitialized: () => ensureProjectInitialized,
   excerptParent: () => excerpt,
+  exportDesign: () => exportDesign3,
   exportSpecTree: () => exportSpecTree,
   exportTargetKey: () => exportTargetKey,
   exportUsage: () => exportUsage,
@@ -3755,6 +3780,7 @@ __export(src_exports, {
   renameComponent: () => renameComponent,
   renameId: () => renameProjectId,
   renameMethod: () => renameMethod,
+  renameType: () => renameType,
   renderDiagram: () => renderDiagram,
   repairForeignStepFields: () => repairForeignStepFields,
   repairSignatures: () => repairSignatures,
@@ -3794,6 +3820,7 @@ __export(src_exports, {
   settledSpecPaths: () => settledSpecPaths,
   signatureFacts: () => signatureFacts,
   signatureTypeRefs: () => signatureTypeRefs,
+  specIndexRetiredBy: () => specIndexRetiredBy,
   specPathsInScope: () => specPathsInScope,
   splitNamespace: () => splitNamespace,
   stepConfigVerdict: () => stepConfigVerdict,
@@ -6996,6 +7023,22 @@ var PortalMountSchema = import_zod8.z.object({
    */
   via: import_zod8.z.string().optional()
 });
+var PreviousIdsSchema = import_zod8.z.array(import_zod8.z.string().min(1));
+var PreviousNamesSchema = import_zod8.z.array(import_zod8.z.string().min(1));
+function specIndexRetiredBy(index, kind, id) {
+  const holders = kind === "component" ? index.components : kind === "interface" ? index.interfaces : kind === "implementation" ? index.implementations : kind === "type" ? index.types : [];
+  for (const holder of holders) {
+    if (!holder.previousIds?.length) continue;
+    const key = kind === "type" && holder.subsystem && !holder.id.startsWith(`${holder.subsystem}::`) ? `${holder.subsystem}::${holder.id}` : holder.id;
+    const cut = key.lastIndexOf("::");
+    const namespace = cut >= 0 ? key.slice(0, cut + 2) : "";
+    for (const previous of holder.previousIds) {
+      const previousKey = previous.includes("::") ? previous : namespace + previous;
+      if (previousKey === id) return key;
+    }
+  }
+  return void 0;
+}
 var ComponentSpecSchema = import_zod8.z.object({
   id: SpecIdSchema,
   name: import_zod8.z.string(),
@@ -7039,6 +7082,8 @@ var ComponentSpecSchema = import_zod8.z.object({
    *  satisfies the source requirement for a source-less implementation (suppresses
    *  MISSING_SOURCE_PATH); `informative` links are context only. */
   externalLinks: import_zod8.z.array(ExternalLinkSchema).optional(),
+  /** The rename trace (see PreviousIdsSchema). */
+  previousIds: PreviousIdsSchema.optional(),
   /** Per-spec lint suppressions (see LintConfigSchema). */
   lint: LintConfigSchema.optional(),
   /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
@@ -7162,11 +7207,16 @@ var MethodSignatureSchema = import_zod8.z.object({
    */
   guarantees: import_zod8.z.array(GuaranteeSchema).optional(),
   /**
-   * State-effect direction of this method on its component's held state. Required on a
-   * durable Store's contract methods so the durability round-trip rule can pair external
-   * writes with hydration read-backs (MISSING_HYDRATION); optional elsewhere.
+   * What this method does to its component's held state: `read` observes it, `write`
+   * modifies an entity's domain fields, and `lifecycle` creates, destroys, or
+   * (un)registers an entity's existence or membership without modifying its fields —
+   * closed under composition (a lifecycle method calls only read and lifecycle methods,
+   * LIFECYCLE_CALLS_WRITE). Required on a durable Store's contract methods so the
+   * durability round-trip rule can pair mutations with hydration read-backs
+   * (MISSING_HYDRATION); a Supervisor may call a data component it does not own only
+   * through read and lifecycle methods (SUPERVISOR_WRITE_SHORTCUT). Optional elsewhere.
    */
-  effect: import_zod8.z.enum(["read", "write"]).optional(),
+  effect: import_zod8.z.enum(["read", "write", "lifecycle"]).optional(),
   /**
    * Typed acknowledgment of a real caller OUTSIDE the modeled narrative graph
    * (runtime timer/hook, external system, sibling subsystem). Unused-detection
@@ -7201,6 +7251,8 @@ var MethodSignatureSchema = import_zod8.z.object({
       seen.add(finding2.code);
     });
   }).optional(),
+  /** The method's rename trace (see PreviousNamesSchema). */
+  previousNames: PreviousNamesSchema.optional(),
   /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
   ext: ExtDataSchema.optional()
 });
@@ -7268,6 +7320,8 @@ var InterfaceSpecSchema = import_zod8.z.object({
   component: import_zod8.z.string(),
   // References L2 Component id
   methods: import_zod8.z.array(StoredMethodSignatureSchema).default([]),
+  /** The rename trace (see PreviousIdsSchema). */
+  previousIds: PreviousIdsSchema.optional(),
   /** Per-spec lint suppressions (see LintConfigSchema). */
   lint: LintConfigSchema.optional(),
   /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
@@ -7558,6 +7612,8 @@ var ImplementationSpecSchema = import_zod8.z.object({
   detail: NarrativeDetailSchema.optional(),
   /** Spec-level conformance tier default (each method may override). */
   conformance: ConformanceTierSchema.optional(),
+  /** The rename trace (see PreviousIdsSchema). */
+  previousIds: PreviousIdsSchema.optional(),
   /** Per-spec lint suppressions (see LintConfigSchema). */
   lint: LintConfigSchema.optional(),
   /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
@@ -7733,6 +7789,8 @@ var TypeSpecSchema = import_zod8.z.object({
    * as `InvoiceLine`.
    */
   symbol: import_zod8.z.string().optional(),
+  /** The rename trace (see PreviousIdsSchema): ids this type held within its owner. */
+  previousIds: PreviousIdsSchema.optional(),
   /** Per-spec lint suppressions (see LintConfigSchema). */
   lint: LintConfigSchema.optional(),
   /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
@@ -9382,12 +9440,12 @@ function exportTargetKey(e) {
 
 // src/models/project-family.ts
 var path10 = __toESM(require("path"));
-function walkMemberPath(byKey2, start, segments) {
+function walkMemberPath(byKey3, start, segments) {
   let node = start;
   for (const segment of segments.slice(0, -1)) {
     const next = node.aliases.get(segment);
     if (next !== void 0) {
-      const found = byKey2.get(next);
+      const found = byKey3.get(next);
       if (!found) return null;
       node = found;
       continue;
@@ -9399,13 +9457,13 @@ function walkMemberPath(byKey2, start, segments) {
   return { project: node, name: segments[segments.length - 1] };
 }
 function landReference(projects, reference, from) {
-  const byKey2 = new Map(projects.map((p) => [p.namespace, p]));
-  const origin = byKey2.get(from);
-  const root = byKey2.get("");
+  const byKey3 = new Map(projects.map((p) => [p.namespace, p]));
+  const origin = byKey3.get(from);
+  const root = byKey3.get("");
   if (!reference.includes("::")) return { kind: "project", project: from, name: reference };
   const land = (form, start, segments2) => {
     if (!start) return { kind: "unresolved", form };
-    const walked = walkMemberPath(byKey2, start, segments2);
+    const walked = walkMemberPath(byKey3, start, segments2);
     if (walked === "outside") return { kind: "outside", form };
     if (walked) return { kind: "project", form, project: walked.project.namespace, name: walked.name };
     return { kind: "unresolved", form };
@@ -9417,7 +9475,7 @@ function landReference(projects, reference, from) {
     while (segments[0] === "super") {
       segments.shift();
       if (!node || node.parent === void 0) return { kind: "outside", form: "super" };
-      node = byKey2.get(node.parent);
+      node = byKey3.get(node.parent);
     }
     if (segments.length === 0 || !node) return { kind: "unresolved", form: "super" };
     return land("super", node, segments);
@@ -9429,11 +9487,11 @@ function landReference(projects, reference, from) {
     return land(segments.length === 2 ? "alias" : "path", origin, segments);
   }
   if (origin.subsystems.has(first)) return { kind: "project", project: from, name: segments[segments.length - 1] };
-  const fromRoot = root ? walkMemberPath(byKey2, root, segments) : null;
+  const fromRoot = root ? walkMemberPath(byKey3, root, segments) : null;
   if (fromRoot && fromRoot !== "outside") return { kind: "project", form: "path", project: fromRoot.project.namespace, name: fromRoot.name };
   const byId = projects.filter((p) => p.id === first || p.namespace !== "" && p.namespace === first);
   if (byId.length === 1) {
-    const walked = walkMemberPath(byKey2, byId[0], segments.slice(1));
+    const walked = walkMemberPath(byKey3, byId[0], segments.slice(1));
     if (walked === "outside") return { kind: "outside", form: "path" };
     if (walked) return { kind: "project", form: "path", project: walked.project.namespace, name: walked.name };
   }
@@ -9573,6 +9631,188 @@ function selectsFamily(options, declaresMembers) {
   return declaresMembers && options?.memberDepth !== 0;
 }
 
+// src/models/design-export.ts
+var import_zod9 = require("zod");
+var DESIGN_FORMAT = "wairon-design";
+var DESIGN_FORMAT_VERSION = "1.0";
+var DESIGN_APPROVALS = ["locked", "stale", "unlocked", "unjudged"];
+var DesignApprovalSchema = import_zod9.z.enum(DESIGN_APPROVALS);
+var DESIGN_DEPENDENCY_ROLES = ["member", "external"];
+var DesignDependencyRoleSchema = import_zod9.z.enum(DESIGN_DEPENDENCY_ROLES);
+var ExtSchema = import_zod9.z.record(import_zod9.z.unknown());
+var TypeExpressionSchema = import_zod9.z.lazy(
+  () => import_zod9.z.object({
+    form: import_zod9.z.enum(["primitive", "named", "list", "set", "map", "optional", "union", "async", "applied"]),
+    name: import_zod9.z.string().optional(),
+    args: import_zod9.z.array(TypeExpressionSchema)
+  }).passthrough()
+);
+var DesignTypeRefSchema = import_zod9.z.object({
+  text: import_zod9.z.string(),
+  expression: TypeExpressionSchema.optional()
+}).passthrough();
+var DesignParamSchema = import_zod9.z.object({
+  name: import_zod9.z.string(),
+  type: DesignTypeRefSchema,
+  optional: import_zod9.z.boolean(),
+  description: import_zod9.z.string().optional()
+}).passthrough();
+var DesignFieldSchema = import_zod9.z.object({
+  name: import_zod9.z.string(),
+  type: DesignTypeRefSchema,
+  optional: import_zod9.z.boolean(),
+  description: import_zod9.z.string().optional(),
+  key: import_zod9.z.string().optional(),
+  references: import_zod9.z.string().optional()
+}).passthrough();
+var DeclaredInvocationSchema = MethodSignatureSchema.shape.invokedBy.unwrap().passthrough();
+var DesignMethodSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string().optional(),
+  params: import_zod9.z.array(DesignParamSchema),
+  returns: DesignTypeRefSchema,
+  signature: import_zod9.z.string(),
+  signatureType: import_zod9.z.string().optional(),
+  effect: import_zod9.z.string().optional(),
+  guarantees: import_zod9.z.array(import_zod9.z.string()),
+  invokedBy: DeclaredInvocationSchema.optional(),
+  endpoint: import_zod9.z.record(import_zod9.z.string()).optional(),
+  formerly: import_zod9.z.array(import_zod9.z.string()),
+  ext: ExtSchema.optional()
+}).passthrough();
+var DesignExportEntrySchema = import_zod9.z.object({
+  publicName: import_zod9.z.string(),
+  targetKind: import_zod9.z.string(),
+  target: import_zod9.z.string(),
+  audience: import_zod9.z.string().optional(),
+  version: import_zod9.z.string().optional(),
+  stability: import_zod9.z.string().optional()
+}).passthrough();
+var DesignDependencySchema = import_zod9.z.object({
+  alias: import_zod9.z.string(),
+  projectId: import_zod9.z.string(),
+  role: DesignDependencyRoleSchema,
+  digest: import_zod9.z.string().optional(),
+  uses: import_zod9.z.array(import_zod9.z.string())
+}).passthrough();
+var DesignSourceSchema = import_zod9.z.object({
+  projectId: import_zod9.z.string(),
+  stateId: import_zod9.z.string(),
+  approved: import_zod9.z.boolean(),
+  approval: DesignApprovalSchema
+}).passthrough();
+var DesignProjectSchema = import_zod9.z.object({
+  name: import_zod9.z.string(),
+  vision: import_zod9.z.string(),
+  boundaries: import_zod9.z.array(import_zod9.z.string()),
+  requirements: import_zod9.z.array(import_zod9.z.string()),
+  targetLanguage: import_zod9.z.string().optional(),
+  exports: import_zod9.z.array(DesignExportEntrySchema)
+}).passthrough();
+var DesignSubsystemSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string(),
+  status: import_zod9.z.string(),
+  profile: import_zod9.z.string().optional(),
+  targetLanguage: import_zod9.z.string().optional(),
+  lifecycle: import_zod9.z.array(LifecycleEntrypointSchema.passthrough()),
+  exports: import_zod9.z.array(DesignExportEntrySchema),
+  trustedLinks: import_zod9.z.array(import_zod9.z.string()),
+  ext: ExtSchema.optional()
+}).passthrough();
+var DesignComponentSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string(),
+  status: import_zod9.z.string(),
+  subsystem: import_zod9.z.string(),
+  stereotype: import_zod9.z.string(),
+  variant: import_zod9.z.string().optional(),
+  dependencyClass: import_zod9.z.string().optional(),
+  durability: import_zod9.z.string().optional(),
+  portalType: import_zod9.z.string().optional(),
+  owns: import_zod9.z.array(import_zod9.z.string()),
+  dependsOn: import_zod9.z.array(import_zod9.z.string()),
+  emits: import_zod9.z.array(EventBindingSchema.passthrough()),
+  subscribesTo: import_zod9.z.array(EventBindingSchema.passthrough()),
+  auth: PortalAuthSchema.passthrough().optional(),
+  basePath: import_zod9.z.string().optional(),
+  dispatch: import_zod9.z.array(DispatchBindingSchema.passthrough()),
+  /** A listener's mounts as declared, each portal as a key: entrypoint facts. */
+  mounts: import_zod9.z.array(PortalMountSchema.passthrough()),
+  /** The pack-declared patterns the component realizes, as declared. */
+  patterns: import_zod9.z.array(PatternRefSchema.passthrough()),
+  /** The opaque external references the component documents, as declared. */
+  externalLinks: import_zod9.z.array(ExternalLinkSchema.passthrough()),
+  formerly: import_zod9.z.array(import_zod9.z.string()),
+  ext: ExtSchema.optional()
+}).passthrough();
+var DesignInterfaceSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  component: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string(),
+  status: import_zod9.z.string(),
+  methods: import_zod9.z.array(DesignMethodSchema),
+  formerly: import_zod9.z.array(import_zod9.z.string()),
+  ext: ExtSchema.optional()
+}).passthrough();
+var DesignMethodBodySchema = import_zod9.z.object({
+  method: import_zod9.z.string(),
+  detail: import_zod9.z.string(),
+  intent: import_zod9.z.string().optional(),
+  calls: import_zod9.z.array(import_zod9.z.string()),
+  narrative: import_zod9.z.array(NarrativeStepSchema.passthrough())
+}).passthrough();
+var DesignImplementationSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  contract: import_zod9.z.string(),
+  component: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string(),
+  status: import_zod9.z.string(),
+  technologies: import_zod9.z.array(import_zod9.z.string()),
+  sourcePath: import_zod9.z.string().optional(),
+  methods: import_zod9.z.array(DesignMethodBodySchema),
+  formerly: import_zod9.z.array(import_zod9.z.string()),
+  ext: ExtSchema.optional()
+}).passthrough();
+var DesignTypeSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  kind: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string().optional(),
+  status: import_zod9.z.string().optional(),
+  fields: import_zod9.z.array(DesignFieldSchema),
+  methods: import_zod9.z.array(DesignMethodSchema),
+  params: import_zod9.z.array(DesignParamSchema),
+  returns: DesignTypeRefSchema.optional(),
+  values: import_zod9.z.array(EnumValueSchema.passthrough()),
+  holds: import_zod9.z.string().optional(),
+  invariants: import_zod9.z.array(InvariantSchema.passthrough()),
+  componentClass: import_zod9.z.string().optional(),
+  database: import_zod9.z.string().optional(),
+  table: import_zod9.z.string().optional(),
+  linkedEntity: import_zod9.z.string().optional(),
+  formerly: import_zod9.z.array(import_zod9.z.string()),
+  ext: ExtSchema.optional()
+}).passthrough();
+var DesignExportSchema = import_zod9.z.object({
+  format: import_zod9.z.literal(DESIGN_FORMAT),
+  formatVersion: import_zod9.z.string().regex(/^\d+\.\d+$/),
+  generator: import_zod9.z.string(),
+  source: DesignSourceSchema,
+  project: DesignProjectSchema,
+  dependencies: import_zod9.z.array(DesignDependencySchema),
+  subsystems: import_zod9.z.array(DesignSubsystemSchema),
+  components: import_zod9.z.array(DesignComponentSchema),
+  interfaces: import_zod9.z.array(DesignInterfaceSchema),
+  implementations: import_zod9.z.array(DesignImplementationSchema),
+  types: import_zod9.z.array(DesignTypeSchema)
+}).passthrough();
+
 // src/core/narrative-labels.ts
 var SCALAR_REFS = [
   ["onTrueLabel", "onTrueStep"],
@@ -14786,7 +15026,7 @@ var MODEL = __MODEL_JSON__;
 
 // src/core/surfaces.ts
 var fs9 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 
 // src/utils/filenames.ts
 function safeFilenamePart(value) {
@@ -14934,10 +15174,477 @@ function unpin(alias) {
 // src/core/openapi.ts
 var yaml2 = __toESM(require("js-yaml"));
 
+// src/config/defaults.ts
+var os2 = __toESM(require("os"));
+var path13 = __toESM(require("path"));
+var DEFAULT_TARGET_DIRS = {
+  claude: ".claude/agents",
+  gemini: ".gemini/agents",
+  agy: ".gemini/agents",
+  cursor: ".cursor/rules",
+  copilot: ".github/prompts",
+  codex: ".codex/agents"
+};
+function defaultTargetConfig(type) {
+  return {
+    type,
+    outputDir: DEFAULT_TARGET_DIRS[type],
+    enabled: true
+  };
+}
+var WAIRON_VERSION = "5.1.1-dev.98";
+var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
+var ARCHITECT_AGENT_ID = "agent-architect";
+var ARCHITECT_TEMPLATE_ID = "architect";
+function globalTemplatesDir(projectOverride) {
+  if (process.env.WAIRON_TEMPLATES_DIR) {
+    return process.env.WAIRON_TEMPLATES_DIR;
+  }
+  if (projectOverride) {
+    return projectOverride;
+  }
+  return path13.join(os2.homedir(), ".wairon", "templates");
+}
+var BACKEND_COMMANDS = {
+  claude: "claude",
+  gemini: "gemini"
+};
+function backendCommand(backend) {
+  return BACKEND_COMMANDS[backend] ?? backend;
+}
+var SUPPORTED_ALIASES = ["wai"];
+var SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  ".git",
+  ".cache",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "target",
+  // Rust
+  "vendor"
+]);
+
+// src/core/design-export.ts
+var NoSystemSpecError = class extends Error {
+  constructor() {
+    super("no-system: the tree has no L0 system spec to export (.wai/specs holds no system spec).");
+    this.code = "no-system";
+    this.name = "NoSystemSpecError";
+  }
+};
+var isOwn = (spec) => !spec.id.includes("::");
+var byKey = (a, b) => compareOrdinal(a.key, b.key);
+var KeyTable = class {
+  constructor(components, interfaces, types, members = []) {
+    this.components = /* @__PURE__ */ new Set();
+    /** component key → the interfaces it declares. */
+    this.interfacesOf = /* @__PURE__ */ new Map();
+    this.typeRefCache = /* @__PURE__ */ new Map();
+    /** bound key → `alias::publicName`, over every direct member. */
+    this.publicNames = /* @__PURE__ */ new Map();
+    /** alias → the public names this projection wrote a reference to. */
+    this.used = /* @__PURE__ */ new Map();
+    for (const m of members) for (const [bound2, name] of m.names) if (!this.publicNames.has(bound2)) this.publicNames.set(bound2, name);
+    for (const c of components) this.components.add(c.id);
+    for (const i of [...interfaces].sort((a, b) => compareOrdinal(a.id, b.id))) {
+      const list = this.interfacesOf.get(i.component) ?? [];
+      list.push(i);
+      this.interfacesOf.set(i.component, list);
+    }
+    this.types = [...types].sort((a, b) => compareOrdinal(qualifiedTypeId(a), qualifiedTypeId(b)));
+  }
+  /** A contract method's key: `<interface key>.<name>` on the first of the component's interfaces declaring it, else the name as written. */
+  methodKey(component, method) {
+    if (!component) return method;
+    const intf = (this.interfacesOf.get(component) ?? []).find((i) => i.methods.some((m) => m.name === method));
+    return intf ? `${intf.id}.${method}` : method;
+  }
+  /** Whether `component.method` names a contract method of an own component — a method signature source. */
+  isMethodSource(value) {
+    const dot = value.lastIndexOf(".");
+    if (dot <= 0 || dot === value.length - 1) return false;
+    const head2 = value.slice(0, dot);
+    const tail = value.slice(dot + 1);
+    return this.components.has(head2) && (this.interfacesOf.get(head2) ?? []).some((i) => i.methods.some((m) => m.name === tail));
+  }
+  /**
+   * The key of the own type a written name resolves to — same subsystem first,
+   * then system-level, then any, ordinal by key within a rank — or null when
+   * no own type answers to it (a generic parameter, or a name in another project).
+   */
+  typeKey(name, owner, kind) {
+    const cacheKey = `${owner ?? ""}|${kind ?? ""}|${name}`;
+    if (this.typeRefCache.has(cacheKey)) return this.typeRefCache.get(cacheKey);
+    const rank = (t) => t.subsystem === owner ? 0 : t.subsystem === void 0 ? 1 : 2;
+    const hit = this.types.filter((t) => (kind === void 0 || t.kind === kind) && (t.id === name || qualifiedTypeId(t) === name || typeMatchesRef(t, name))).sort((a, b) => rank(a) - rank(b))[0];
+    const key = hit ? qualifiedTypeId(hit) : null;
+    this.typeRefCache.set(cacheKey, key);
+    return key;
+  }
+  /** A reference to a type field (`Type.field`) or a type, resolved to its key; as written when it resolves to nothing. */
+  typeFieldRef(ref, owner) {
+    const whole = this.typeKey(ref, owner);
+    if (whole) return whole;
+    const dot = ref.lastIndexOf(".");
+    if (dot > 0) {
+      const head2 = this.typeKey(ref.slice(0, dot), owner);
+      if (head2) return `${head2}.${ref.slice(dot + 1)}`;
+      const outside = this.external(ref.slice(0, dot));
+      if (outside !== ref.slice(0, dot)) return `${outside}.${ref.slice(dot + 1)}`;
+    }
+    return this.external(ref);
+  }
+  /**
+   * A reference as a consumer resolves it: a bound key of an item a direct
+   * member exports as `alias::publicName` (recorded as used), anything else as
+   * written — an own key, an external's reference (already `alias::name`), or
+   * one binding no exported name, which the gate reports.
+   */
+  external(ref) {
+    const name = this.publicNames.get(ref);
+    if (name === void 0) return ref;
+    const cut = name.indexOf("::");
+    const alias = name.slice(0, cut);
+    const set = this.used.get(alias) ?? /* @__PURE__ */ new Set();
+    set.add(name.slice(cut + 2));
+    this.used.set(alias, set);
+    return name;
+  }
+  /** A component reference: an own component's key, or another project's item by its public name. */
+  componentRef(ref) {
+    return this.components.has(ref) ? ref : this.external(ref);
+  }
+};
+function resolveExpression(expr, keys, owner) {
+  const args = expr.args.map((a) => resolveExpression(a, keys, owner));
+  if ((expr.form === "named" || expr.form === "applied") && expr.name !== void 0) {
+    return { form: expr.form, name: keys.typeKey(expr.name, owner) ?? keys.external(expr.name), args };
+  }
+  return expr.name !== void 0 ? { form: expr.form, name: expr.name, args } : { form: expr.form, args };
+}
+function typeRef(text3, position, keys, owner) {
+  const parse = parseTypeExpression(text3, position);
+  if (!parse.expression) return { text: text3 };
+  const expression = resolveExpression(parse.expression, keys, owner);
+  return { text: canonicalTypeText(expression), expression };
+}
+function projectParams(params, position, keys, owner) {
+  return (params ?? []).map((p) => ({
+    name: p.name,
+    type: typeRef(p.type, position, keys, owner),
+    optional: p.optional === true,
+    ...p.description !== void 0 ? { description: p.description } : {}
+  }));
+}
+function exportEntry(e, keys) {
+  const target = e.kind === "type" ? { targetKind: "type", target: keys.typeKey(String(e.typeDef), e.source) ?? keys.external(String(e.typeDef)) } : e.interface ? { targetKind: "interface", target: keys.external(e.interface) } : { targetKind: "component", target: keys.componentRef(String(e.component)) };
+  return {
+    publicName: e.publicName,
+    ...target,
+    ...e.audience !== void 0 ? { audience: e.audience } : {},
+    ...e.version !== void 0 ? { version: e.version } : {},
+    ...e.stability !== void 0 ? { stability: e.stability } : {}
+  };
+}
+function exportRows(entries, keys) {
+  return entries.map((e) => exportEntry(e, keys)).sort((a, b) => compareOrdinal(a.publicName, b.publicName) || compareOrdinal(`${a.targetKind}:${a.target}`, `${b.targetKind}:${b.target}`));
+}
+var boundaryText = (b) => typeof b === "string" ? b : b.description ? `${b.name}: ${b.description}` : b.name;
+var requirementText = (r) => typeof r === "string" ? r : r.description;
+function projectSection(system, table, keys) {
+  return {
+    name: system.name,
+    vision: system.vision,
+    boundaries: system.boundaries.map(boundaryText),
+    requirements: system.globalRequirements.map(requirementText),
+    ...system.targetLanguage !== void 0 ? { targetLanguage: system.targetLanguage } : {},
+    exports: exportRows(table, keys)
+  };
+}
+function dependency(binding, lock, keys) {
+  const alias = binding.external.alias;
+  const digest3 = lock?.externals[alias]?.digest;
+  return {
+    alias,
+    projectId: binding.external.project,
+    role: binding.external.role,
+    ...digest3 !== void 0 ? { digest: digest3 } : {},
+    uses: [.../* @__PURE__ */ new Set([...(binding.usage?.used ?? []).map((u) => u.publicName), ...keys.used.get(alias) ?? []])].sort(compareOrdinal)
+  };
+}
+function memberDependency(member, lock, keys) {
+  const digest3 = lock?.externals[member.alias]?.digest;
+  return {
+    alias: member.alias,
+    projectId: member.projectId,
+    role: "member",
+    ...digest3 !== void 0 ? { digest: digest3 } : {},
+    uses: [...keys.used.get(member.alias) ?? []].sort(compareOrdinal)
+  };
+}
+function directMembers(family) {
+  return family.nodes.filter((n) => n.parent === "" && n.namespace !== "").map((n) => {
+    const alias = n.mountAlias ?? n.namespace;
+    const names = /* @__PURE__ */ new Map();
+    const bound2 = (key) => {
+      const local = key.startsWith(`${n.namespace}::`) ? key : `${n.namespace}::${key}`;
+      const last = `${n.namespace}::${key.split("::").pop() ?? key}`;
+      return [.../* @__PURE__ */ new Set([local, last])];
+    };
+    const rows = [...resolveProjectExports(n.namespace).entries].sort((a, b) => compareOrdinal(a.publicName, b.publicName));
+    for (const e of rows) {
+      const name = `${alias}::${e.publicName}`;
+      const targets = e.kind === "type" ? [e.typeDef] : e.interface !== void 0 ? [e.interface, e.component] : [e.component];
+      for (const target of targets) {
+        if (target === void 0) continue;
+        for (const key of bound2(target)) if (!names.has(key)) names.set(key, name);
+      }
+    }
+    return { alias, projectId: n.id ?? alias, names };
+  }).sort((a, b) => compareOrdinal(a.alias, b.alias));
+}
+function subsystemSection(s, table, keys) {
+  return {
+    key: s.id,
+    name: s.name,
+    description: s.description,
+    status: s.status,
+    ...s.profile !== void 0 ? { profile: s.profile } : {},
+    ...s.targetLanguage !== void 0 ? { targetLanguage: s.targetLanguage } : {},
+    lifecycle: (s.lifecycle ?? []).map((l) => ({ ...l, component: keys.componentRef(l.component) })),
+    exports: exportRows(table, keys),
+    trustedLinks: s.trustedLinks.map((t) => t.subsystem),
+    ...s.ext !== void 0 ? { ext: s.ext } : {}
+  };
+}
+function componentSection(c, keys) {
+  return {
+    key: c.id,
+    name: c.name,
+    description: c.description,
+    status: c.status,
+    subsystem: c.subsystem,
+    stereotype: c.componentType,
+    ...c.variant !== void 0 ? { variant: c.variant } : {},
+    ...c.dependencyClass !== void 0 ? { dependencyClass: c.dependencyClass } : {},
+    ...c.durability !== void 0 ? { durability: c.durability } : {},
+    ...c.portalType !== void 0 ? { portalType: c.portalType } : {},
+    owns: c.owns.map((o) => keys.componentRef(o)),
+    dependsOn: c.dependsOn.map((d) => keys.componentRef(d)),
+    emits: (c.emits ?? []).map((e) => ({ ...e })),
+    subscribesTo: (c.subscribesTo ?? []).map((e) => ({ ...e })),
+    ...c.auth !== void 0 ? { auth: c.auth } : {},
+    ...c.basePath !== void 0 ? { basePath: c.basePath } : {},
+    dispatch: (c.dispatch ?? []).map((d) => ({ ...d, component: keys.componentRef(d.component) })),
+    mounts: (c.mounts ?? []).map((m) => ({ ...m, portal: keys.componentRef(m.portal) })),
+    patterns: (c.patterns ?? []).map((p) => ({ ...p })),
+    externalLinks: (c.externalLinks ?? []).map((l) => ({ ...l })),
+    formerly: [...c.previousIds ?? []],
+    ...c.ext !== void 0 ? { ext: c.ext } : {}
+  };
+}
+function contractMethod(intf, m, keys, owner) {
+  const signatureType = m.signatureFrom !== void 0 && !keys.isMethodSource(m.signatureFrom) ? keys.typeKey(m.signatureFrom, owner, "signature") ?? void 0 : void 0;
+  return {
+    key: `${intf.id}.${m.name}`,
+    name: m.name,
+    description: m.description,
+    params: projectParams(m.params, "param", keys, owner),
+    returns: typeRef(m.returns, "returns", keys, owner),
+    signature: m.signature,
+    ...signatureType !== void 0 ? { signatureType } : {},
+    ...m.effect !== void 0 ? { effect: m.effect } : {},
+    guarantees: [...m.guarantees ?? []],
+    ...m.invokedBy !== void 0 ? { invokedBy: { ...m.invokedBy } } : {},
+    ...m.endpoint !== void 0 ? { endpoint: endpointFields(m.endpoint) } : {},
+    formerly: [...m.previousNames ?? []],
+    ...m.ext !== void 0 ? { ext: m.ext } : {}
+  };
+}
+function endpointFields(endpoint) {
+  const out = {};
+  for (const [k, v] of Object.entries(endpoint)) if (v !== void 0) out[k] = String(v);
+  return out;
+}
+function interfaceSection(intf, keys, owner) {
+  return {
+    key: intf.id,
+    component: intf.component,
+    name: intf.name,
+    description: intf.description,
+    status: intf.status,
+    methods: intf.methods.map((m) => contractMethod(intf, m, keys, owner)),
+    formerly: [...intf.previousIds ?? []],
+    ...intf.ext !== void 0 ? { ext: intf.ext } : {}
+  };
+}
+function stepWithKeys(step, keys) {
+  const out = { ...step };
+  if (step.targetMethod !== void 0) out.targetMethod = keys.methodKey(step.targetComponent, step.targetMethod);
+  if (step.targetComponent !== void 0) out.targetComponent = keys.componentRef(step.targetComponent);
+  const from = step.auth?.from;
+  if (from !== void 0 && from.startsWith("component:")) {
+    out.auth = { ...step.auth, from: `component:${keys.componentRef(from.slice("component:".length))}` };
+  }
+  return out;
+}
+function callKey(ref, keys) {
+  const dot = ref.lastIndexOf(".");
+  if (dot <= 0) return ref;
+  const key = keys.methodKey(ref.slice(0, dot), ref.slice(dot + 1));
+  return key.includes(".") ? key : `${keys.componentRef(ref.slice(0, dot))}.${ref.slice(dot + 1)}`;
+}
+function implementationSection(impl, contract, component, keys) {
+  const methods = impl.methods.map((m) => ({
+    method: `${impl.contract}.${m.name}`,
+    detail: effectiveDetail(m, impl, component).level,
+    ...m.intent !== void 0 ? { intent: m.intent } : {},
+    calls: (m.calls ?? []).map((c) => callKey(c, keys)),
+    narrative: m.narrative.map((s) => stepWithKeys(s, keys))
+  }));
+  return {
+    key: impl.id,
+    contract: impl.contract,
+    component: contract?.component ?? component?.id ?? "",
+    name: impl.name,
+    description: impl.description,
+    status: impl.status,
+    technologies: (impl.technologies ?? []).map(technologyName),
+    ...impl.sourcePath !== void 0 ? { sourcePath: impl.sourcePath } : {},
+    methods,
+    formerly: [...impl.previousIds ?? []],
+    ...impl.ext !== void 0 ? { ext: impl.ext } : {}
+  };
+}
+function typeSection(t, keys) {
+  const key = qualifiedTypeId(t);
+  const owner = t.subsystem;
+  return {
+    key,
+    kind: t.kind,
+    name: t.name,
+    ...t.description !== void 0 ? { description: t.description } : {},
+    fields: t.fields.map((f) => ({
+      name: f.name,
+      type: typeRef(f.type, "field", keys, owner),
+      optional: f.optional === true,
+      ...f.description !== void 0 ? { description: f.description } : {},
+      ...f.key !== void 0 ? { key: f.key } : {},
+      ...f.references !== void 0 ? { references: keys.typeFieldRef(f.references, owner) } : {}
+    })),
+    methods: t.methods.map((m) => ({
+      key: `${key}.${m.name}`,
+      name: m.name,
+      ...m.description !== void 0 ? { description: m.description } : {},
+      params: projectParams(m.params, "type-method-param", keys, owner),
+      returns: typeRef(m.returns, "type-method-returns", keys, owner),
+      signature: m.signature,
+      guarantees: [],
+      formerly: []
+    })),
+    params: t.kind === "signature" ? projectParams(t.params, "signature-param", keys, owner) : [],
+    ...t.kind === "signature" && t.returns !== void 0 ? { returns: typeRef(t.returns, "signature-returns", keys, owner) } : {},
+    values: (t.values ?? []).map((v) => ({ ...v })),
+    ...t.holds !== void 0 ? { holds: t.holds } : {},
+    invariants: (t.invariants ?? []).map((i) => ({ ...i })),
+    ...t.componentClass !== void 0 ? { componentClass: keys.componentRef(t.componentClass) } : {},
+    ...t.database !== void 0 ? { database: t.database } : {},
+    ...t.table !== void 0 ? { table: t.table } : {},
+    ...t.linkedEntity !== void 0 ? { linkedEntity: keys.typeKey(t.linkedEntity, owner) ?? keys.external(t.linkedEntity) } : {},
+    formerly: [...t.previousIds ?? []],
+    ...t.ext !== void 0 ? { ext: t.ext } : {}
+  };
+}
+function sortedKeys(value) {
+  if (Array.isArray(value)) return value.map(sortedKeys);
+  if (value && typeof value === "object") {
+    const src = value;
+    const out = {};
+    for (const k of Object.keys(src).sort(compareOrdinal)) {
+      if (src[k] !== void 0) out[k] = sortedKeys(src[k]);
+    }
+    return out;
+  }
+  return value;
+}
+function projectIdOf(system) {
+  try {
+    const config = loadProjectConfig();
+    return (config ? effectiveProjectId(config) : null) ?? system.name;
+  } catch {
+    return system.name;
+  }
+}
+function exportDesign(approval) {
+  const system = loadSystemSpec();
+  if (!system) throw new NoSystemSpecError();
+  const subsystems = loadSubsystemSpecs().filter(isOwn);
+  const components = loadComponentSpecs().filter(isOwn);
+  const interfaces = loadInterfaceSpecs().filter(isOwn);
+  const implementations = loadImplementationSpecs().filter(isOwn);
+  const types = loadTypeSpecs().filter(isOwn);
+  const projectTable = resolveProjectExports();
+  const subsystemTables = new Map(subsystems.map((s) => [s.id, resolveSubsystemExports(s.id).entries]));
+  const projectId = projectIdOf(system);
+  const bindings = resolveDeclared();
+  const members = directMembers(graph());
+  let lock = null;
+  try {
+    lock = externalsRepository.readLock();
+  } catch {
+    lock = null;
+  }
+  const stateId = computeStateId();
+  const state = approval ?? "unjudged";
+  const source = {
+    projectId,
+    stateId: `${stateId.algorithm}:${stateId.digest}`,
+    approval: state,
+    approved: state === "locked"
+  };
+  const keys = new KeyTable(components, interfaces, types, members);
+  const componentById = new Map(components.map((c) => [c.id, c]));
+  const interfaceById = new Map(interfaces.map((i) => [i.id, i]));
+  const ownerOf4 = (componentId) => componentId !== void 0 ? componentById.get(componentId)?.subsystem : void 0;
+  const project = projectSection(system, projectTable.entries, keys);
+  const subsystemSections = subsystems.map((s) => subsystemSection(s, subsystemTables.get(s.id) ?? [], keys)).sort(byKey);
+  const componentSections = components.map((c) => componentSection(c, keys)).sort(byKey);
+  const interfaceSections = interfaces.map((i) => interfaceSection(i, keys, ownerOf4(i.component))).sort(byKey);
+  const implementationSections = implementations.map((impl) => {
+    const contract = interfaceById.get(impl.contract);
+    return implementationSection(impl, contract, contract ? componentById.get(contract.component) : void 0, keys);
+  }).sort(byKey);
+  const typeSections = types.map((t) => typeSection(t, keys)).sort(byKey);
+  const externalAliases = new Set(bindings.map((b) => b.external.alias));
+  const dependencies = [
+    ...bindings.map((b) => dependency(b, lock, keys)),
+    ...members.filter((m) => !externalAliases.has(m.alias)).map((m) => memberDependency(m, lock, keys))
+  ].sort((a, b) => compareOrdinal(a.alias, b.alias));
+  const design = {
+    format: DESIGN_FORMAT,
+    formatVersion: DESIGN_FORMAT_VERSION,
+    generator: WAIRON_VERSION,
+    source,
+    project,
+    dependencies,
+    subsystems: subsystemSections,
+    components: componentSections,
+    interfaces: interfaceSections,
+    implementations: implementationSections,
+    types: typeSections
+  };
+  return sortedKeys(design);
+}
+
 // src/core/surfaces.ts
 var SURFACES_DIRNAME = "surfaces";
 function surfacesDir(rootDir) {
-  return path13.join(rootDir, ".wai", SURFACES_DIRNAME);
+  return path14.join(rootDir, ".wai", SURFACES_DIRNAME);
 }
 function audienceRank(audience) {
   const idx = SURFACE_AUDIENCES.indexOf(audience ?? "instance");
@@ -15016,7 +15723,7 @@ function boundProjectId() {
   }
 }
 function contractEntry(entry, comp, interfaces) {
-  const methods = interfaces.filter((i) => i.component === comp.id && (!entry.interface || i.id === entry.interface)).flatMap((i) => i.methods).map(({ signatureFrom: _source, ...method }) => method);
+  const methods = interfaces.filter((i) => i.component === comp.id && (!entry.interface || i.id === entry.interface)).flatMap((i) => i.methods).map(({ signatureFrom: _source, previousNames: _trace, ...method }) => method);
   return {
     id: entry.publicName,
     name: entry.name ?? comp.name,
@@ -15101,7 +15808,7 @@ function listSnapshots() {
   for (const file of fs9.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      out.push(SurfaceSnapshotSchema.parse(readYamlFile(path13.join(dir, file))));
+      out.push(SurfaceSnapshotSchema.parse(readYamlFile(path14.join(dir, file))));
     } catch {
     }
   }
@@ -15112,7 +15819,7 @@ function snapshotFilename(projectName) {
 }
 function removeSnapshot(projectName) {
   const dir = surfacesDir(getProjectRoot());
-  const direct = path13.join(dir, snapshotFilename(projectName));
+  const direct = path14.join(dir, snapshotFilename(projectName));
   if (fs9.existsSync(direct)) {
     fs9.unlinkSync(direct);
     return true;
@@ -15120,7 +15827,7 @@ function removeSnapshot(projectName) {
   if (!fs9.existsSync(dir)) return false;
   for (const file of fs9.readdirSync(dir)) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-    const p = path13.join(dir, file);
+    const p = path14.join(dir, file);
     try {
       const snap = SurfaceSnapshotSchema.parse(readYamlFile(p));
       if (snap.projectName === projectName) {
@@ -15159,6 +15866,32 @@ function listPinnedExternals() {
     return { alias, project: entry.project, entry, snapshot };
   });
 }
+function withSortedKeys(value) {
+  if (Array.isArray(value)) return value.map(withSortedKeys);
+  if (value && typeof value === "object") {
+    const src = value;
+    const out = {};
+    for (const k of Object.keys(src).sort(compareOrdinal)) if (src[k] !== void 0) out[k] = withSortedKeys(src[k]);
+    return out;
+  }
+  return value;
+}
+function writeDesignTo(targetPath, design) {
+  const resolved = path14.resolve(targetPath);
+  try {
+    fs9.mkdirSync(path14.dirname(resolved), { recursive: true });
+    fs9.writeFileSync(resolved, `${JSON.stringify(withSortedKeys(design), null, 2)}
+`, "utf8");
+  } catch (e) {
+    throw new Error(`Cannot write the design export to ${resolved}: ${e.message}`);
+  }
+  return resolved;
+}
+function exportDesign2(outPath, approval) {
+  const design = exportDesign(approval);
+  if (outPath) writeDesignTo(outPath, design);
+  return design;
+}
 function listFamilyPins() {
   const snapshots = listSnapshots();
   const pins = snapshots.filter((snapshot) => snapshot.origin === "generated").map((snapshot) => ({
@@ -15177,8 +15910,8 @@ var UnknownExternalAliasError = class extends Error {
 };
 var OUT_OF_REACH = "its root is outside the request's reach";
 function isWithinDir(dir, target) {
-  const rel2 = path13.relative(path13.resolve(dir), path13.resolve(target));
-  return rel2 === "" || !rel2.startsWith("..") && !path13.isAbsolute(rel2);
+  const rel2 = path14.relative(path14.resolve(dir), path14.resolve(target));
+  return rel2 === "" || !rel2.startsWith("..") && !path14.isAbsolute(rel2);
 }
 function producerUnreadable(external) {
   const directory = external.directory;
@@ -15431,6 +16164,9 @@ function listExternals() {
 }
 
 // src/core/surface-portal.ts
+function exportDesign3(outPath, approval) {
+  return exportDesign2(outPath, approval);
+}
 function listSnapshots2() {
   return listSnapshots();
 }
@@ -15464,7 +16200,7 @@ function pinnedParent2() {
 
 // src/core/family-validation.ts
 var fs10 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var path15 = __toESM(require("path"));
 
 // src/models/pack-impact.ts
 function packSettings(manifest, profile) {
@@ -15641,7 +16377,7 @@ function referencedOf(nodes) {
       if (e.sourceKind === "hosted") {
         const lookup2 = getHostedLookup();
         const root = lookup2 && e.hosted !== void 0 ? lookup2(e.hosted) : null;
-        if (root) directory = path14.resolve(root);
+        if (root) directory = path15.resolve(root);
         else problem = lookup2 ? `the hosted member \`${e.hosted}\` is unknown or outside this request's reach` : `hosted-only member \`${e.hosted}\`: available only through the hosted server`;
       }
       if (directory !== void 0 && !fs10.existsSync(directory)) {
@@ -15705,7 +16441,7 @@ function notSelectedHint(left) {
 }
 function run(options) {
   const family = graph();
-  const root = path14.resolve(getProjectRoot());
+  const root = path15.resolve(getProjectRoot());
   const ceiling = reachCeiling(root, options.family);
   const selected = selectProjects(family, options);
   const issues = [];
@@ -15925,7 +16661,7 @@ function pinOf(parent, alias, subject) {
 }
 function projectApprovals(depth) {
   const family = graph();
-  const root = path14.resolve(getProjectRoot());
+  const root = path15.resolve(getProjectRoot());
   const limit = depth ?? Infinity;
   const selected = family.nodes.filter((n) => depthOf(family, n) <= limit);
   const directoryOf = new Map(family.nodes.map((n) => [n.namespace, n.directory]));
@@ -15978,7 +16714,7 @@ function projectApprovals(depth) {
 function requiredBy(key) {
   return key === "" ? "the family root" : `"${key}"`;
 }
-function requirementText(requirement) {
+function requirementText2(requirement) {
   return `"${requirement.pack}" ${requirement.version}${requirement.profile ? ` (profile "${requirement.profile}")` : ""}`;
 }
 function isBelow(family, node, ancestor) {
@@ -16033,7 +16769,7 @@ function judgeAdoption(requiring, member, requirements) {
   const out = [];
   const who = `The member ${named(member)}`;
   for (const requirement of requirements) {
-    const wanted = `${requirementText(requirement)}, required by ${requiredBy(requiring)}`;
+    const wanted = `${requirementText2(requirement)}, required by ${requiredBy(requiring)}`;
     const adopted = entryFor(config, loaded, requirement.pack);
     if (!adopted) {
       out.push(policyIssue("POLICY_NOT_ADOPTED", `${who} does not select the pack ${wanted}. Select it in the member's own configuration (\`wairon pack use ${requirement.pack}@<version> --pin\` at its root).`, member));
@@ -16125,69 +16861,12 @@ var fs12 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
 var path17 = __toESM(require("path"));
 var import_module = require("module");
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/core/packstore.ts
 var crypto3 = __toESM(require("crypto"));
 var fs11 = __toESM(require("fs"));
 var path16 = __toESM(require("path"));
-
-// src/config/defaults.ts
-var os2 = __toESM(require("os"));
-var path15 = __toESM(require("path"));
-var DEFAULT_TARGET_DIRS = {
-  claude: ".claude/agents",
-  gemini: ".gemini/agents",
-  agy: ".gemini/agents",
-  cursor: ".cursor/rules",
-  copilot: ".github/prompts",
-  codex: ".codex/agents"
-};
-function defaultTargetConfig(type) {
-  return {
-    type,
-    outputDir: DEFAULT_TARGET_DIRS[type],
-    enabled: true
-  };
-}
-var WAIRON_VERSION = "5.1.1-dev.96";
-var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
-var ARCHITECT_AGENT_ID = "agent-architect";
-var ARCHITECT_TEMPLATE_ID = "architect";
-function globalTemplatesDir(projectOverride) {
-  if (process.env.WAIRON_TEMPLATES_DIR) {
-    return process.env.WAIRON_TEMPLATES_DIR;
-  }
-  if (projectOverride) {
-    return projectOverride;
-  }
-  return path15.join(os2.homedir(), ".wairon", "templates");
-}
-var BACKEND_COMMANDS = {
-  claude: "claude",
-  gemini: "gemini"
-};
-function backendCommand(backend) {
-  return BACKEND_COMMANDS[backend] ?? backend;
-}
-var SUPPORTED_ALIASES = ["wai"];
-var SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  "build",
-  "out",
-  ".git",
-  ".cache",
-  "coverage",
-  "__pycache__",
-  ".venv",
-  "venv",
-  "target",
-  // Rust
-  "vendor"
-]);
-
-// src/core/packstore.ts
 var UNVERSIONED = "0.0.0-unversioned";
 var INSTALL_RECORD = ".install.yaml";
 var DIGEST_EXCLUDED = /* @__PURE__ */ new Set([INSTALL_RECORD, ".git", "node_modules", ".DS_Store"]);
@@ -16355,10 +17034,10 @@ function uninstallPack(name, version) {
 }
 
 // src/core/extensions.ts
-var ProfileDefSchema = import_zod9.z.object({
-  family: import_zod9.z.enum(["backend-like", "frontend-like", "neutral"]).default("neutral"),
-  forbiddenStereotypes: import_zod9.z.array(import_zod9.z.object({ types: import_zod9.z.array(import_zod9.z.string()).min(1), reason: import_zod9.z.string().min(1) })).default([]),
-  discouragedStereotypes: import_zod9.z.array(import_zod9.z.object({ types: import_zod9.z.array(import_zod9.z.string()).min(1), reason: import_zod9.z.string().min(1) })).default([]),
+var ProfileDefSchema = import_zod10.z.object({
+  family: import_zod10.z.enum(["backend-like", "frontend-like", "neutral"]).default("neutral"),
+  forbiddenStereotypes: import_zod10.z.array(import_zod10.z.object({ types: import_zod10.z.array(import_zod10.z.string()).min(1), reason: import_zod10.z.string().min(1) })).default([]),
+  discouragedStereotypes: import_zod10.z.array(import_zod10.z.object({ types: import_zod10.z.array(import_zod10.z.string()).min(1), reason: import_zod10.z.string().min(1) })).default([]),
   /**
    * Edge deltas — the ALLOW half of the profile-scoped dependency matrix. An
    * entry LICENSES intra-subsystem dependsOn edges the builtin stereotype
@@ -16368,20 +17047,20 @@ var ProfileDefSchema = import_zod9.z.object({
    * boundary rules and pattern containment are never relaxable. The DENY
    * half is a `forbid-edge` declarative assertion.
    */
-  allowedEdges: import_zod9.z.array(import_zod9.z.object({
-    from: import_zod9.z.array(import_zod9.z.string().min(1)).min(1),
-    to: import_zod9.z.array(import_zod9.z.string().min(1)).min(1),
-    reason: import_zod9.z.string().min(1)
+  allowedEdges: import_zod10.z.array(import_zod10.z.object({
+    from: import_zod10.z.array(import_zod10.z.string().min(1)).min(1),
+    to: import_zod10.z.array(import_zod10.z.string().min(1)).min(1),
+    reason: import_zod10.z.string().min(1)
   })).default([]),
   rules: RulesConfigSchema.partial().optional()
 });
-var LanguagePackDefSchema = import_zod9.z.object({
-  unsupportedFlow: import_zod9.z.record(import_zod9.z.string()).default({}),
-  foreignBuiltins: import_zod9.z.array(import_zod9.z.string()).optional()
+var LanguagePackDefSchema = import_zod10.z.object({
+  unsupportedFlow: import_zod10.z.record(import_zod10.z.string()).default({}),
+  foreignBuiltins: import_zod10.z.array(import_zod10.z.string()).optional()
 });
-var PackSkillSchema = import_zod9.z.object({
+var PackSkillSchema = import_zod10.z.object({
   /** A NEW skill, installed namespaced as `<pack-id>-<id>`. Mutually exclusive with `extends`. */
-  id: import_zod9.z.string().min(1).optional(),
+  id: import_zod10.z.string().min(1).optional(),
   /**
    * EXTEND a builtin skill (`sdd-architect` | `sdd-narrative` | `sdd-auditor` |
    * `sdd-implement`) instead of standing beside it.
@@ -16393,90 +17072,90 @@ var PackSkillSchema = import_zod9.z.object({
    * appended under `## Platform: <pack>`; the builtin stays wairon's, so an
    * upgrade still updates it.
    */
-  extends: import_zod9.z.string().min(1).optional(),
-  source: import_zod9.z.string().min(1),
-  targets: import_zod9.z.array(import_zod9.z.string()).default([])
+  extends: import_zod10.z.string().min(1).optional(),
+  source: import_zod10.z.string().min(1),
+  targets: import_zod10.z.array(import_zod10.z.string()).default([])
 }).refine((s) => s.id === void 0 !== (s.extends === void 0), {
   message: "a pack skill declares either `id` (a new skill) or `extends` (a section appended to a builtin), not both and not neither"
 });
-var PackInstructionBlockSchema = import_zod9.z.union([
+var PackInstructionBlockSchema = import_zod10.z.union([
   // Scalar shorthand: `instructions: >- …` — the common case, unscoped.
-  import_zod9.z.string().min(1).transform((text3) => ({ text: text3 })),
-  import_zod9.z.object({
-    text: import_zod9.z.string().min(1),
-    profile: import_zod9.z.array(import_zod9.z.string().min(1)).min(1).optional()
+  import_zod10.z.string().min(1).transform((text3) => ({ text: text3 })),
+  import_zod10.z.object({
+    text: import_zod10.z.string().min(1),
+    profile: import_zod10.z.array(import_zod10.z.string().min(1)).min(1).optional()
   })
 ]);
-var PackInstructionsSchema = import_zod9.z.preprocess(
+var PackInstructionsSchema = import_zod10.z.preprocess(
   (raw) => raw === void 0 || raw === null ? [] : Array.isArray(raw) ? raw : [raw],
-  import_zod9.z.array(PackInstructionBlockSchema)
+  import_zod10.z.array(PackInstructionBlockSchema)
 );
-var PatternDefSchema = import_zod9.z.object({
-  id: import_zod9.z.string().min(1),
-  version: import_zod9.z.string().min(1),
-  description: import_zod9.z.string().optional(),
-  metadata: import_zod9.z.record(import_zod9.z.unknown()).optional()
+var PatternDefSchema = import_zod10.z.object({
+  id: import_zod10.z.string().min(1),
+  version: import_zod10.z.string().min(1),
+  description: import_zod10.z.string().optional(),
+  metadata: import_zod10.z.record(import_zod10.z.unknown()).optional()
 });
-var AssertionSelectorSchema = import_zod9.z.object({
-  componentType: import_zod9.z.array(import_zod9.z.string().min(1)).optional(),
-  profile: import_zod9.z.array(import_zod9.z.string().min(1)).optional(),
-  id: import_zod9.z.string().min(1).optional()
+var AssertionSelectorSchema = import_zod10.z.object({
+  componentType: import_zod10.z.array(import_zod10.z.string().min(1)).optional(),
+  profile: import_zod10.z.array(import_zod10.z.string().min(1)).optional(),
+  id: import_zod10.z.string().min(1).optional()
 });
 var assertionBase = {
   /** Pack-local code; surfaced namespaced as <PACK_NAME>_<CODE>. */
-  code: import_zod9.z.string().min(1),
-  severity: import_zod9.z.enum(["warning", "error"]).default("warning"),
+  code: import_zod10.z.string().min(1),
+  severity: import_zod10.z.enum(["warning", "error"]).default("warning"),
   /** The doctrine, stated for the finding message. */
-  reason: import_zod9.z.string().min(1)
+  reason: import_zod10.z.string().min(1)
 };
-var PackAssertionSchema = import_zod9.z.discriminatedUnion("kind", [
-  import_zod9.z.object({
-    kind: import_zod9.z.literal("forbid-edge"),
+var PackAssertionSchema = import_zod10.z.discriminatedUnion("kind", [
+  import_zod10.z.object({
+    kind: import_zod10.z.literal("forbid-edge"),
     ...assertionBase,
     from: AssertionSelectorSchema,
     to: AssertionSelectorSchema,
-    relation: import_zod9.z.array(import_zod9.z.enum(["dependsOn", "owns"])).default(["dependsOn", "owns"])
+    relation: import_zod10.z.array(import_zod10.z.enum(["dependsOn", "owns"])).default(["dependsOn", "owns"])
   }),
-  import_zod9.z.object({
-    kind: import_zod9.z.literal("require-field"),
+  import_zod10.z.object({
+    kind: import_zod10.z.literal("require-field"),
     ...assertionBase,
     on: AssertionSelectorSchema,
-    level: import_zod9.z.enum(["component", "interface", "implementation"]).default("component"),
+    level: import_zod10.z.enum(["component", "interface", "implementation"]).default("component"),
     /** A top-level spec field name, or one `ext.*` path — nothing else is addressable. */
-    field: import_zod9.z.string().min(1),
+    field: import_zod10.z.string().min(1),
     /** Optional closed value set (string equality). */
-    values: import_zod9.z.array(import_zod9.z.string()).optional()
+    values: import_zod10.z.array(import_zod10.z.string()).optional()
   }),
-  import_zod9.z.object({
-    kind: import_zod9.z.literal("endpoint-shape"),
+  import_zod10.z.object({
+    kind: import_zod10.z.literal("endpoint-shape"),
     ...assertionBase,
     on: AssertionSelectorSchema,
     /** Optional transport allowlist. */
-    transport: import_zod9.z.array(import_zod9.z.string().min(1)).optional(),
+    transport: import_zod10.z.array(import_zod10.z.string().min(1)).optional(),
     /** Optional anchored regex over the transport's address field (path/topic/command/…). */
-    pathPattern: import_zod9.z.string().min(1).optional()
+    pathPattern: import_zod10.z.string().min(1).optional()
   })
 ]);
 function assertionFullCode(packName, code) {
   const norm = (s) => s.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   return `${norm(packName)}_${norm(code)}`;
 }
-var DeclarativePackSchema = import_zod9.z.object({
-  name: import_zod9.z.string().min(1),
-  version: import_zod9.z.string().optional(),
-  profiles: import_zod9.z.record(ProfileDefSchema).default({}),
-  languages: import_zod9.z.record(LanguagePackDefSchema).default({}),
-  skills: import_zod9.z.array(PackSkillSchema).default([]),
-  patterns: import_zod9.z.array(PatternDefSchema).default([]),
+var DeclarativePackSchema = import_zod10.z.object({
+  name: import_zod10.z.string().min(1),
+  version: import_zod10.z.string().optional(),
+  profiles: import_zod10.z.record(ProfileDefSchema).default({}),
+  languages: import_zod10.z.record(LanguagePackDefSchema).default({}),
+  skills: import_zod10.z.array(PackSkillSchema).default([]),
+  patterns: import_zod10.z.array(PatternDefSchema).default([]),
   /** Declarative rule assertions — instances of closed kinds, hosted-safe. */
-  assertions: import_zod9.z.array(PackAssertionSchema).default([]),
+  assertions: import_zod10.z.array(PackAssertionSchema).default([]),
   /**
    * Semantic guarantee tokens this pack adds to the builtin vocabulary
    * (SEMANTIC_GUARANTEES). Declaring a token makes it legal on L3 method
    * `guarantees` and narrative `assertsGuarantees`; referenced tokens outside
    * builtin + declared are flagged UNKNOWN_GUARANTEE by the validator.
    */
-  guarantees: import_zod9.z.array(import_zod9.z.string().min(1)).default([]),
+  guarantees: import_zod10.z.array(import_zod10.z.string().min(1)).default([]),
   /**
    * Connecting-agent guidance appended to wairon's own MCP `initialize`
    * instructions, attributed to this pack, in pack load order.
@@ -16491,7 +17170,7 @@ var DeclarativePackSchema = import_zod9.z.object({
    * explicit in the new project's `project.yaml` where it is visible in review
    * and removable — never silent authority over projects that never mentioned it.
    */
-  applyByDefault: import_zod9.z.boolean().default(false)
+  applyByDefault: import_zod10.z.boolean().default(false)
 });
 var EXTENDABLE_BUILTIN_SKILLS = ["sdd-architect", "sdd-narrative", "sdd-auditor", "sdd-implement", "sdd-delegate"];
 function skillExtendErrors(skills) {
@@ -17126,7 +17805,7 @@ function buildImportGraph(index, universe) {
 function buildOwnershipIndex(ctx) {
   const ownedBy2 = /* @__PURE__ */ new Map();
   for (const comp of ctx.components) {
-    if (isRetired(comp) || !isPattern(comp)) continue;
+    if (isRetired(comp) || !(isPattern(comp) || comp.componentType === "Supervisor")) continue;
     for (const memberId of comp.owns) {
       const member = ctx.componentMap.get(memberId);
       if (!member || isPattern(member)) continue;
@@ -17911,6 +18590,66 @@ var namedScalarTypesRule = {
   }
 };
 
+// src/core/rules/integrity/rename-traces.ts
+var CODE = "RENAME_TRACE_CONFLICT";
+function namespaceOf(key) {
+  const cut = key.lastIndexOf("::");
+  return cut >= 0 ? key.slice(0, cut + 2) : "";
+}
+function judgeKind(ctx, noun, live, holders, qualify) {
+  const claimed = /* @__PURE__ */ new Map();
+  for (const holder of holders) {
+    for (const entry of holder.trace) {
+      const key = qualify(entry, holder);
+      const other = claimed.get(key);
+      if (live.has(key) && key !== holder.key) {
+        report(ctx, holder, `${holder.label} lists "${entry}" in its rename trace, but a live ${noun} has that key \u2014 a consumer of the design export would read the live ${noun} as this one renamed. Rename the newcomer, or unset the trace entry and accept that a consumer reads a delete plus an add.`);
+      } else if (live.has(key)) {
+        report(ctx, holder, `${holder.label} lists its own key "${entry}" in its rename trace \u2014 a rename never records the name it keeps. Unset the entry.`);
+      } else if (other && other !== holder) {
+        report(ctx, holder, `${holder.label} and ${other.label} both list "${entry}" in their rename traces \u2014 a consumer holding the old key cannot tell which one it became. Unset the entry on the one that was not renamed from it.`);
+      }
+      if (!other) claimed.set(key, holder);
+    }
+  }
+}
+function report(ctx, holder, message) {
+  if (!ctx.isSpecInScope(holder.specId)) return;
+  ctx.addIssue("warning", CODE, message, holder.specId);
+}
+var inNamespace = (entry, holder) => entry.includes("::") ? entry : namespaceOf(holder.key) + entry;
+var renameTracesRule = {
+  name: "rename-traces",
+  judges: "design",
+  description: "A rename trace (a spec's previousIds, a contract method's previousNames) names keys that no longer exist, and is what lets a consumer of the design export tell a rename from a delete plus an add; it must therefore be unambiguous. Reported: a trace entry equal to a live key of the same kind (a component, interface or implementation id; a type id within the same owner; `<interface>.<method>` of a declared method), and one former key claimed by two elements of the same kind. The rename tools and the gated write refuse both (id-retired, name-retired), so a finding means a hand edit; the message names both holders and the way out \u2014 rename the newcomer, or unset the trace entry and accept the delete plus an add a consumer will read.",
+  codes: [
+    { code: CODE, defaultSeverity: "warning", summary: "A rename-trace entry equals a live key of the same kind, or two elements claim one former key" }
+  ],
+  check(ctx) {
+    const specHolders = (specs, noun) => specs.filter((s) => s.previousIds?.length).map((s) => ({ key: s.id, specId: s.id, label: `${noun} "${s.id}"`, trace: s.previousIds }));
+    judgeKind(ctx, "component", new Set(ctx.components.map((c) => c.id)), specHolders(ctx.components, "Component"), inNamespace);
+    judgeKind(ctx, "interface", new Set(ctx.interfaces.map((i) => i.id)), specHolders(ctx.interfaces, "Interface"), inNamespace);
+    judgeKind(ctx, "implementation", new Set(ctx.implementations.map((i) => i.id)), specHolders(ctx.implementations, "Implementation"), inNamespace);
+    judgeKind(
+      ctx,
+      "type",
+      new Set(ctx.types.map((t) => qualifiedTypeId(t))),
+      ctx.types.filter((t) => t.previousIds?.length).map((t) => ({ key: qualifiedTypeId(t), specId: t.id, label: `Type "${qualifiedTypeId(t)}"`, trace: t.previousIds })),
+      inNamespace
+    );
+    const methodHolders = [];
+    const liveMethods = /* @__PURE__ */ new Set();
+    for (const intf of ctx.interfaces) {
+      for (const m of intf.methods) {
+        const key = `${intf.id}.${m.name}`;
+        liveMethods.add(key);
+        if (m.previousNames?.length) methodHolders.push({ key, specId: intf.id, label: `Method "${key}"`, trace: m.previousNames });
+      }
+    }
+    judgeKind(ctx, "contract method", liveMethods, methodHolders, inNamespace);
+  }
+};
+
 // src/core/rules/integrity/public-surface-binding.ts
 var publicSurfaceBindingRule = {
   name: "public-surface-binding",
@@ -18423,10 +19162,10 @@ var projectBoundariesRule = {
 var lintAllowsRule = {
   name: "lint-allows",
   judges: "design",
-  description: "Per-spec lint suppressions (lint.allow) must name real issue codes and actually suppress a finding \u2014 unknown codes and stale allows are flagged. An allow covers exactly the occurrence it names: a finding that reports a site is silenced only by an allow whose `at` is that site, a finding that reports none only by an allow that names none, and an aggregating finding only by an allow whose `covers` lists every unit it reports \u2014 a unit nobody listed is named back as new instead of inheriting a decision taken about its neighbours. So a coarse allow left on a rule that names sites, and an allow whose site the run no longer reports, are both UNUSED_LINT_ALLOW, and the finding names the sites that did fire. Allows silence warnings and notices; errors always surface.",
+  description: "Per-spec lint suppressions (lint.allow) must name real issue codes and actually suppress a finding \u2014 unknown codes and stale allows are flagged. An allow covers exactly the occurrence it names: a finding that reports a site is silenced only by an allow whose `at` is that site, a finding that reports none only by an allow that names none, and an aggregating finding only by an allow whose `covers` lists every unit it reports \u2014 a unit nobody listed is named back as new instead of inheriting a decision taken about its neighbours. So a coarse allow left on a rule that names sites, and an allow whose site the run no longer reports, are both UNUSED_LINT_ALLOW, and the finding names the sites that did fire. Allows silence warnings and notices; errors always surface \u2014 so an allow naming a code that is an error on its spec (it fired there as one, or its resolved severity is error) covers nothing, and the finding says plainly that an error cannot be allowed rather than that the code never fired.",
   codes: [
     { code: "UNKNOWN_LINT_ALLOW_CODE", defaultSeverity: "warning", summary: "lint.allow names an issue code no registered rule emits" },
-    { code: "UNUSED_LINT_ALLOW", defaultSeverity: "warning", summary: "lint.allow entry matched no finding this run \u2014 the code never fired, or it fired at sites this allow does not name" }
+    { code: "UNUSED_LINT_ALLOW", defaultSeverity: "warning", summary: "lint.allow entry covers nothing this run \u2014 the code never fired, it fired at sites this allow does not name, or it is an error, which no allow can cover" }
   ],
   check(ctx) {
     for (const a of ctx.lintAllows) {
@@ -18439,9 +19178,20 @@ var lintAllowsRule = {
         );
         continue;
       }
-      if (a.used) continue;
       const reported = ctx.sitesReported(a.specId, a.code);
       const at = a.at ? ` at "${a.at}"` : "";
+      const fired = reported.unsited || reported.sites.length > 0;
+      const isError = reported.errored || !fired && ctx.severityOf(a.code, a.specId) === "error";
+      if (isError) {
+        ctx.addIssue(
+          "warning",
+          "UNUSED_LINT_ALLOW",
+          `Spec "${a.specId}" allows "${a.code}"${at} (reason: ${a.reason}), but "${a.code}" is an error${fired ? " and fired here as one" : ""}, and an error cannot be allowed \u2014 lint.allow silences warnings and notices only. Fix what the finding names, or remove the allow (a project may re-tune the code's severity in rules.sddRuleSeverity).`,
+          a.specId
+        );
+        continue;
+      }
+      if (a.used) continue;
       let why;
       if (a.at && reported.unsited && reported.sites.length === 0) {
         why = `findings of "${a.code}" on this spec name no site at all, so this allow must not name one \u2014 drop the \`at\``;
@@ -18488,12 +19238,12 @@ var contractSymmetryRule = {
           );
         }
       }
-      for (const contractMethod of contract.methods) {
-        if (!implMethodNames.has(contractMethod.name)) {
+      for (const contractMethod2 of contract.methods) {
+        if (!implMethodNames.has(contractMethod2.name)) {
           ctx.addIssue(
             "error",
             "MISSING_IMPLEMENTATION_METHOD",
-            `Implementation "${impl.id}" is missing implementation for contract method "${contractMethod.name}" from interface "${contract.id}".`,
+            `Implementation "${impl.id}" is missing implementation for contract method "${contractMethod2.name}" from interface "${contract.id}".`,
             impl.id,
             isDraftCtx
           );
@@ -19293,8 +20043,8 @@ var narrativeDetailRule = {
       const component = ctx.componentMap.get(contract.component);
       const isDraftCtx = ctx.isImplementationDraft(impl);
       for (const implMethod of impl.methods) {
-        const contractMethod = contract.methods.find((m) => m.name === implMethod.name);
-        if (!contractMethod) continue;
+        const contractMethod2 = contract.methods.find((m) => m.name === implMethod.name);
+        if (!contractMethod2) continue;
         if (implMethod.narrative.length > 0) continue;
         const eff = effectiveDetail(implMethod, impl, component);
         if (eff.level === "full") {
@@ -19307,7 +20057,7 @@ var narrativeDetailRule = {
           );
           continue;
         }
-        const prose = implMethod.intent ?? contractMethod.description;
+        const prose = implMethod.intent ?? contractMethod2.description;
         if (!passesIntentFloor(prose, implMethod.name)) {
           ctx.addIssue(
             eff.explicit ? "error" : "warning",
@@ -19964,18 +20714,47 @@ var dataBlockDepsRule = {
 };
 
 // src/core/rules/doctrine/entrypoint-dependencies.ts
+function maintainedRegistries(ctx) {
+  const maintained = /* @__PURE__ */ new Map();
+  const add2 = (supervisorId, registryId) => {
+    let set = maintained.get(supervisorId);
+    if (!set) maintained.set(supervisorId, set = /* @__PURE__ */ new Set());
+    set.add(registryId);
+  };
+  for (const comp of ctx.components) {
+    if (comp.componentType !== "Supervisor" || isRetired(comp)) continue;
+    for (const memberId of comp.owns) {
+      if (ctx.componentMap.get(memberId)?.componentType === "Registry") add2(comp.id, memberId);
+    }
+  }
+  for (const impl of ctx.implementations) {
+    const contract = ctx.interfaceMap.get(impl.contract);
+    const supervisor = contract ? ctx.componentMap.get(contract.component) : void 0;
+    if (!supervisor || supervisor.componentType !== "Supervisor" || isRetired(supervisor)) continue;
+    for (const implMethod of impl.methods) {
+      for (const step of implMethod.narrative) {
+        if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
+        if (ctx.componentMap.get(step.targetComponent)?.componentType !== "Registry") continue;
+        const called = ctx.interfaceMethodsOf(step.targetComponent).find((m) => m.name === step.targetMethod);
+        if (called?.effect === "lifecycle") add2(supervisor.id, step.targetComponent);
+      }
+    }
+  }
+  return new Map([...maintained].map(([id, set]) => [id, [...set]]));
+}
 var entrypointDepsRule = {
   name: "entrypoint-dependencies",
   judges: "design",
-  description: "Judges the edges at the system's entry points and its process layer. Portals and Observers are top-level entry points and subscribers, so nothing may depend on them \u2014 and that is the edge's one finding, which is why no other matrix rule judges it. Downward, a Portal dispatches to Orchestrators and may READ through Indexes and Repository facades but never reaches Store/Registry/Query or an Adapter, while an Observer forwards to one Orchestrator or Supervisor over a message-bus Adapter. A View stays a passive presenter. A Supervisor reaches data only through workflows, and a component depending on a live Actor must also depend on a Supervisor that supervises it.",
+  description: "Judges the edges at the system's entry points and its process layer. Portals and Observers are top-level entry points and subscribers, so nothing may depend on them \u2014 and that is the edge's one finding, which is why no other matrix rule judges it. Downward, a Portal dispatches to Orchestrators and may READ through Indexes and Repository facades but never reaches Store/Registry/Query or an Adapter, while an Observer forwards to one Orchestrator or Supervisor over a message-bus Adapter. A View stays a passive presenter. A Supervisor stays out of presentation; what it may do to the data it reaches is judged per call (supervisor-shared-data), and what it owns as its supervision state by the ownership rules. A component depending on a live Actor reaches it through the Actor's supervision: by depending on a Supervisor that supervises it, or on a Registry such a Supervisor maintains (owns, or calls with lifecycle-effect methods) \u2014 the lookup hop callers really take.",
   codes: [
     { code: "ARCHITECTURE_VIOLATION_PORTAL_DEP", defaultSeverity: "error", summary: "Component depending on a Portal/Observer" },
     { code: "ARCHITECTURE_VIOLATION_PORTAL_FORBIDDEN_DEP", defaultSeverity: "error", summary: "Portal/Observer reaching the data layer directly" },
     { code: "ARCHITECTURE_VIOLATION_VIEW_DEP", defaultSeverity: "error", summary: "View depending on persistence layers or on logic that is not pure" },
-    { code: "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP", defaultSeverity: "error", summary: "Supervisor depending on anything but Actors, Orchestrators, Adapters or other Supervisors \u2014 it reaches data only through workflows" },
-    { code: "ACTOR_REACHED_WITHOUT_SUPERVISOR", defaultSeverity: "error", summary: "Component depending on a live Actor it does not supervise, without also depending on a Supervisor that supervises it \u2014 a live Actor is reached by id through its Supervisor" }
+    { code: "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP", defaultSeverity: "error", summary: "Supervisor depending on a presentation block (View, FeatureComponent, RouterComponent) \u2014 a Supervisor manages live processes; the data it reaches is judged per call by supervisor-shared-data" },
+    { code: "ACTOR_REACHED_WITHOUT_SUPERVISOR", defaultSeverity: "error", summary: "Component depending on a live Actor it does not supervise, reaching it neither through a Supervisor that supervises it nor through a Registry such a Supervisor maintains \u2014 model the real lookup hop" }
   ],
   check(ctx) {
+    const lookups = maintainedRegistries(ctx);
     for (const edge of ctx.dependencyEdges().matrix) {
       const comp = edge.from;
       const depComp = edge.to;
@@ -20011,27 +20790,32 @@ var entrypointDepsRule = {
           edge.draftContext
         );
       }
-      if (comp.componentType === "Supervisor" && ["Store", "Registry", "Repository", "Index", "Query", "View", "FeatureComponent", "RouterComponent"].includes(depComp.componentType)) {
+      if (comp.componentType === "Supervisor" && ["View", "FeatureComponent", "RouterComponent"].includes(depComp.componentType)) {
         ctx.addIssue(
           "error",
           "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP",
-          `Architectural violation: Supervisor "${comp.id}" cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". A Supervisor reaches data only through workflows \u2014 depend on the Orchestrator, Actor or Adapter that does that work instead.` + storeHint,
+          `Architectural violation: Supervisor "${comp.id}" cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". A Supervisor manages live processes and stays out of presentation \u2014 the UI reaches the system through its Portals and workflows, never through a Supervisor's dependencies.`,
           comp.id,
           edge.draftContext
         );
       }
       if (depComp.componentType === "Actor" && comp.componentType !== "Supervisor") {
-        const reachedThroughSupervisor = comp.dependsOn.some((id) => {
-          const supervisor = ctx.componentMap.get(id);
-          return supervisor?.componentType === "Supervisor" && supervisor.dependsOn.includes(depComp.id);
-        });
-        if (!reachedThroughSupervisor) {
-          const supervisors = ctx.components.filter((c) => c.componentType === "Supervisor" && c.dependsOn.includes(depComp.id)).map((c) => `"${c.id}"`);
-          const remedy = supervisors.length > 0 ? `also depend on ${supervisors.length === 1 ? "its Supervisor" : "one of its Supervisors"} (${supervisors.join(", ")})` : `no Supervisor depends on "${depComp.id}" yet, so give the Actor a Supervisor that depends on it and depend on that Supervisor`;
+        const supervisors = ctx.components.filter((c) => c.componentType === "Supervisor" && c.dependsOn.includes(depComp.id));
+        const registries = supervisors.flatMap((s) => (lookups.get(s.id) ?? []).map((registry) => ({ registry, supervisor: s.id })));
+        const reached = supervisors.some((s) => comp.dependsOn.includes(s.id)) || registries.some((r) => comp.dependsOn.includes(r.registry));
+        if (!reached) {
+          let remedy;
+          if (registries.length > 0) {
+            remedy = `depend on ${registries.length === 1 ? "the Registry" : "one of the Registries"} its Supervisor maintains (${registries.map((r) => `"${r.registry}", kept by "${r.supervisor}"`).join("; ")}) and look the Actor up by id there`;
+          } else if (supervisors.length > 0) {
+            remedy = `${supervisors.length === 1 ? "its Supervisor" : "its Supervisors"} (${supervisors.map((s) => `"${s.id}"`).join(", ")}) maintain no Registry of its live handles yet: model that lookup as a Registry the Supervisor keeps through lifecycle-effect methods (registering and unregistering a live handle), and depend on that Registry`;
+          } else {
+            remedy = `no Supervisor depends on "${depComp.id}" yet: give it a Supervisor that depends on it and maintains a Registry of its live handles through lifecycle-effect methods, and depend on that Registry`;
+          }
           ctx.addIssue(
             "error",
             "ACTOR_REACHED_WITHOUT_SUPERVISOR",
-            `Architectural violation: ${stereotypeOf(comp)} "${comp.id}" depends on the live Actor "${depComp.id}" without a Supervisor that supervises it. A live Actor is reached by id through a Supervisor that supervises it \u2014 ${remedy}.`,
+            `Architectural violation: ${stereotypeOf(comp)} "${comp.id}" depends on the live Actor "${depComp.id}" without reaching it through its supervision. A live Actor is found by id through a Registry its Supervisor maintains, or messaged through that Supervisor \u2014 ${remedy}.`,
             comp.id,
             edge.draftContext
           );
@@ -20045,9 +20829,9 @@ var entrypointDepsRule = {
 var portalWriteShortcutRule = {
   name: "portal-write-shortcut",
   judges: "design",
-  description: "A Portal narrative call step or dispatch-table binding that reaches a write-effect method on a Repository or Index directly is the write shortcut: the Portal\u2192data-facade edge is licensed for reads only, and a write routes through an Orchestrator that owns the workflow. A dispatch step reaches its server only through a table binding, so judging every binding judges each dispatch step that takes it, once, where the route is declared. Methods that carry no effect tag are not judged.",
+  description: "A Portal narrative call step or dispatch-table binding that reaches a write- or lifecycle-effect method on a Repository or Index directly is the write shortcut: the Portal\u2192data-facade edge is licensed for reads only, and a mutation \u2014 a write, or a lifecycle change to what exists \u2014 routes through an Orchestrator that owns the workflow. A dispatch step reaches its server only through a table binding, so judging every binding judges each dispatch step that takes it, once, where the route is declared. Methods that carry no effect tag are not judged.",
   codes: [
-    { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative call or dispatch-table binding reaches a write-effect method on a Repository/Index directly \u2014 reads may shortcut, writes route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" }
+    { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative call or dispatch-table binding reaches a write- or lifecycle-effect method on a Repository/Index directly \u2014 reads may shortcut, mutations route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" }
   ],
   check(ctx) {
     for (const impl of ctx.implementations) {
@@ -20061,11 +20845,11 @@ var portalWriteShortcutRule = {
           const target = ctx.componentMap.get(step.targetComponent);
           if (!target || target.componentType !== "Repository" && target.componentType !== "Index") continue;
           const targetMethod = ctx.interfaceMethodsOf(target.id).find((m) => m.name === step.targetMethod);
-          if (targetMethod?.effect !== "write") continue;
+          if (targetMethod?.effect !== "write" && targetMethod?.effect !== "lifecycle") continue;
           ctx.addIssue(
             "error",
             "PORTAL_WRITE_SHORTCUT",
-            `Portal "${component.id}": step ${step.stepNumber} of "${implMethod.name}" calls write-effect method ${target.id}.${step.targetMethod} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the write through an Orchestrator that owns the workflow.`,
+            `Portal "${component.id}": step ${step.stepNumber} of "${implMethod.name}" calls ${targetMethod.effect}-effect method ${target.id}.${step.targetMethod} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the ${targetMethod.effect === "write" ? "write" : "lifecycle change"} through an Orchestrator that owns the workflow.`,
             impl.id,
             isDraftCtx || ctx.isComponentDraft(target.id)
           );
@@ -20079,11 +20863,11 @@ var portalWriteShortcutRule = {
         const target = ctx.componentMap.get(binding.component);
         if (!target || target.componentType !== "Repository" && target.componentType !== "Index") continue;
         const targetMethod = ctx.interfaceMethodsOf(target.id).find((m) => m.name === binding.method);
-        if (targetMethod?.effect !== "write") continue;
+        if (targetMethod?.effect !== "write" && targetMethod?.effect !== "lifecycle") continue;
         ctx.addIssue(
           "error",
           "PORTAL_WRITE_SHORTCUT",
-          `Portal "${comp.id}": dispatch binding "${binding.capability}" routes to write-effect method ${target.id}.${binding.method} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the write through an Orchestrator that owns the workflow.`,
+          `Portal "${comp.id}": dispatch binding "${binding.capability}" routes to ${targetMethod.effect}-effect method ${target.id}.${binding.method} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the ${targetMethod.effect === "write" ? "write" : "lifecycle change"} through an Orchestrator that owns the workflow.`,
           comp.id,
           isDraftCtx || ctx.isComponentDraft(target.id)
         );
@@ -20092,28 +20876,101 @@ var portalWriteShortcutRule = {
   }
 };
 
+// src/core/rules/doctrine/supervisor-shared-data.ts
+var DATA_COMPONENTS = /* @__PURE__ */ new Set(["Store", "Registry", "Repository", "Index", "Query"]);
+var supervisorSharedDataRule = {
+  name: "supervisor-shared-data",
+  judges: "design",
+  description: "A Supervisor keeps its own supervision state (the Stores and Registries it owns) with full read and write, but data it does not own is shared: a Supervisor narrative call step that reaches a method of a Store, Registry, Repository, Index or Query the Supervisor does not own is legal only when that method declares effect read or lifecycle. A write \u2014 or a method that declares no effect \u2014 goes through a workflow: the Supervisor depends on the Orchestrator that does it. A read on behalf of a request still passes; in practice the paired write is what forces the workflow out, and the read moves with it.",
+  codes: [
+    { code: "SUPERVISOR_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Supervisor narrative call reaches a method of a data component it does not own whose declared effect is neither read nor lifecycle \u2014 writes to shared data route through an Orchestrator" }
+  ],
+  check(ctx) {
+    const ownership = ctx.ownershipIndex();
+    for (const impl of ctx.implementations) {
+      const contract = ctx.interfaceMap.get(impl.contract);
+      const supervisor = contract ? ctx.componentMap.get(contract.component) : void 0;
+      if (!supervisor || supervisor.componentType !== "Supervisor" || isRetired(supervisor)) continue;
+      const isDraftCtx = ctx.isImplementationDraft(impl);
+      for (const implMethod of impl.methods) {
+        for (const step of implMethod.narrative) {
+          if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
+          const target = ctx.componentMap.get(step.targetComponent);
+          if (!target || !DATA_COMPONENTS.has(target.componentType)) continue;
+          if (ownership.ownerOf(target.id) === supervisor.id) continue;
+          const called = ctx.interfaceMethodsOf(target.id).find((m) => m.name === step.targetMethod);
+          if (!called || called.effect === "read" || called.effect === "lifecycle") continue;
+          const what = called.effect === "write" ? "a write-effect method" : "a method that declares no effect";
+          const untaggedHint = called.effect === "write" ? "" : ` If ${target.id}.${called.name} only reads, or only changes what exists, declare its effect (read or lifecycle).`;
+          ctx.addIssue(
+            "error",
+            "SUPERVISOR_WRITE_SHORTCUT",
+            `Supervisor "${supervisor.id}": step ${step.stepNumber} of "${implMethod.name}" calls ${target.id}.${called.name}, ${what} on ${target.componentType} "${target.id}", which the Supervisor does not own. A Supervisor reads shared data and changes what exists in it (read and lifecycle effects); a write to its fields goes through a workflow \u2014 depend on the Orchestrator that does it and call that instead.${untaggedHint}`,
+            impl.id,
+            isDraftCtx || ctx.isComponentDraft(target.id)
+          );
+        }
+      }
+    }
+  }
+};
+
+// src/core/rules/doctrine/lifecycle-effect-closure.ts
+var lifecycleEffectClosureRule = {
+  name: "lifecycle-effect-closure",
+  judges: "design",
+  description: "A lifecycle-effect method may create, destroy, or (un)register an entity's existence or membership, never modify its domain fields \u2014 and the effect is closed under composition: its narrative may call only read- and lifecycle-effect methods besides its construction and local steps. A call step to a write-effect method from a lifecycle-effect method is a declaration error: the method is a write, or the write belongs to a workflow beside it. Called methods that declare no effect are not judged.",
+  codes: [
+    { code: "LIFECYCLE_CALLS_WRITE", defaultSeverity: "error", summary: "Lifecycle-effect method whose narrative calls a write-effect method \u2014 the lifecycle effect is closed under composition" }
+  ],
+  check(ctx) {
+    for (const impl of ctx.implementations) {
+      const contract = ctx.interfaceMap.get(impl.contract);
+      if (!contract) continue;
+      const declared = ctx.interfaceMethodsOf(contract.component);
+      const isDraftCtx = ctx.isImplementationDraft(impl);
+      for (const implMethod of impl.methods) {
+        if (declared.find((m) => m.name === implMethod.name)?.effect !== "lifecycle") continue;
+        for (const step of implMethod.narrative) {
+          if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
+          const called = ctx.interfaceMethodsOf(step.targetComponent).find((m) => m.name === step.targetMethod);
+          if (called?.effect !== "write") continue;
+          ctx.addIssue(
+            "error",
+            "LIFECYCLE_CALLS_WRITE",
+            `"${contract.component}.${implMethod.name}" declares effect lifecycle, but step ${step.stepNumber} calls write-effect method ${step.targetComponent}.${step.targetMethod}. A lifecycle method creates, destroys or (un)registers what exists and never modifies domain fields, and the effect is closed under composition \u2014 it may call only read and lifecycle methods. Declare the method a write, or move the write to a workflow beside it.`,
+            impl.id,
+            isDraftCtx
+          );
+        }
+      }
+    }
+  }
+};
+
 // src/core/rules/doctrine/pattern-membership.ts
 var patternMembershipRule = {
   name: "pattern-membership",
   judges: "design",
-  description: "Only patterns (Repository/FeatureComponent/RouterComponent) own member blocks, and every pattern owns at least one. Each claim must name a component that exists and is itself a building block \u2014 patterns compose at the subsystem (L1) level, never by owning one another \u2014 and a block has exactly one owner, the first pattern to claim it.",
+  description: "Only patterns (Repository/FeatureComponent/RouterComponent) own member blocks, and every pattern owns at least one. The one building block that may own is a Supervisor, which owns its supervision state and may own nothing at all; what it may own is pattern-containment's question. Each claim must name a component that exists and is itself a building block \u2014 patterns compose at the subsystem (L1) level, never by owning one another \u2014 and a block has exactly one owner, the first pattern or Supervisor to claim it.",
   codes: [
     { code: "EMPTY_PATTERN", defaultSeverity: "error", summary: "Pattern with no owned member blocks" },
-    { code: "BLOCK_OWNS_MEMBERS", defaultSeverity: "error", summary: "Building block using owns" },
+    { code: "BLOCK_OWNS_MEMBERS", defaultSeverity: "error", summary: "Building block other than a Supervisor using owns" },
     { code: "INVALID_OWNED_MEMBER", defaultSeverity: "error", summary: "owns names a non-existent component" },
     { code: "PATTERN_OWNS_PATTERN", defaultSeverity: "error", summary: "Pattern owning another pattern" },
-    { code: "SHARED_OWNED_MEMBER", defaultSeverity: "error", summary: "Block owned by two patterns" }
+    { code: "SHARED_OWNED_MEMBER", defaultSeverity: "error", summary: "Block owned by two owners (patterns or Supervisors)" }
   ],
   check(ctx) {
     for (const comp of ctx.components) {
       if (isRetired(comp)) continue;
       const isDraftCtx = ctx.isComponentDraft(comp.id);
       const pattern = isPattern(comp);
+      const supervisor = comp.componentType === "Supervisor";
       if (pattern && comp.owns.length === 0) {
         ctx.addIssue("error", "EMPTY_PATTERN", `Pattern "${comp.id}" (${comp.componentType}) must own member blocks via "owns".`, comp.id, isDraftCtx);
       }
-      if (!pattern && comp.owns.length > 0) {
-        ctx.addIssue("error", "BLOCK_OWNS_MEMBERS", `Building block "${comp.id}" (${comp.componentType}) cannot own members; only patterns (${Array.from(PATTERN_TYPES).join("/")}) use "owns".`, comp.id, isDraftCtx);
+      if (!pattern && !supervisor && comp.owns.length > 0) {
+        ctx.addIssue("error", "BLOCK_OWNS_MEMBERS", `Building block "${comp.id}" (${comp.componentType}) cannot own members; only patterns (${Array.from(PATTERN_TYPES).join("/")}) use "owns", and a Supervisor for its supervision state.`, comp.id, isDraftCtx);
       }
     }
     const ownership = ctx.ownershipIndex();
@@ -20121,15 +20978,18 @@ var patternMembershipRule = {
       if (isRetired(comp)) continue;
       const isDraftCtx = ctx.isComponentDraft(comp.id);
       const pattern = isPattern(comp);
+      const supervisor = comp.componentType === "Supervisor";
       for (const memberId of comp.owns) {
         const member = ctx.componentMap.get(memberId);
         if (!member) {
           ctx.addIssue("error", "INVALID_OWNED_MEMBER", `Component "${comp.id}" owns "${memberId}" which does not exist.`, comp.id, isDraftCtx);
           continue;
         }
-        if (!pattern) continue;
+        if (!pattern && !supervisor) continue;
         if (isPattern(member)) {
-          ctx.addIssue("error", "PATTERN_OWNS_PATTERN", `Pattern "${comp.id}" owns "${memberId}", which is itself a pattern. Patterns own only building blocks \u2014 compose patterns at the subsystem (L1) level.`, comp.id, isDraftCtx);
+          if (pattern) {
+            ctx.addIssue("error", "PATTERN_OWNS_PATTERN", `Pattern "${comp.id}" owns "${memberId}", which is itself a pattern. Patterns own only building blocks \u2014 compose patterns at the subsystem (L1) level.`, comp.id, isDraftCtx);
+          }
           continue;
         }
         const firstOwner = ownership.ownerOf(memberId);
@@ -20143,13 +21003,15 @@ var patternMembershipRule = {
 
 // src/core/rules/doctrine/pattern-containment.ts
 var REPOSITORY_MEMBERS = /* @__PURE__ */ new Set(["Store", "Registry", "Index", "Query", "Adapter"]);
+var SUPERVISION_STATE = /* @__PURE__ */ new Set(["Store", "Registry"]);
 var patternContainmentRule = {
   name: "pattern-containment",
   judges: "design",
-  description: "Holds each pattern to the containment its definition prescribes. A Repository may own only Store, Registry, Index, Query and (optionally) Adapter, judged member by member. A FeatureComponent owns exactly one Orchestrator (the logic side) and one or more Views (its faces \u2014 list, detail, form \u2014 sharing the one logic component), and nothing else. A RouterComponent owns exactly one Portal as its facade and at least one other child to route to. A counting pattern that still owns a retired member is not judged until that member is migrated: its counts change with the migration, and STEREOTYPE_RETIRED is the one finding.",
+  description: "Holds each owner to the containment its definition prescribes. A Repository may own only Store, Registry, Index, Query and (optionally) Adapter, judged member by member. A Supervisor may own only its supervision state \u2014 Stores and Registries that are its own, one hop \u2014 judged member by member too. A FeatureComponent owns exactly one Orchestrator (the logic side) and one or more Views (its faces \u2014 list, detail, form \u2014 sharing the one logic component), and nothing else. A RouterComponent owns exactly one Portal as its facade and at least one other child to route to. A counting pattern that still owns a retired member is not judged until that member is migrated: its counts change with the migration, and STEREOTYPE_RETIRED is the one finding.",
   codes: [
     { code: "REPOSITORY_CONTAINMENT", defaultSeverity: "error", summary: "Repository owning a non Store/Registry/Index/Query/Adapter member" },
     { code: "FEATURE_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "FeatureComponent not owning exactly one Orchestrator + one or more Views" },
+    { code: "SUPERVISOR_CONTAINMENT", defaultSeverity: "error", summary: "Supervisor owning anything but a Store or Registry \u2014 a Supervisor owns only its supervision state" },
     { code: "ROUTER_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "RouterComponent not owning exactly one Portal facade, or owning no children to route to" }
   ],
   check(ctx) {
@@ -20200,6 +21062,15 @@ var patternContainmentRule = {
         }
       }
     }
+    for (const comp of ctx.components) {
+      if (comp.componentType !== "Supervisor" || isRetired(comp)) continue;
+      const isDraftCtx = ctx.isComponentDraft(comp.id);
+      for (const memberId of comp.owns) {
+        const member = ctx.componentMap.get(memberId);
+        if (!member || isRetired(member) || SUPERVISION_STATE.has(member.componentType)) continue;
+        ctx.addIssue("error", "SUPERVISOR_CONTAINMENT", `Supervisor "${comp.id}" owns "${memberId}" of type ${member.componentType}; a Supervisor owns only its supervision state \u2014 Stores and Registries that are its own. Depend on "${memberId}" as a collaborator instead.`, comp.id, isDraftCtx);
+      }
+    }
   }
 };
 
@@ -20207,7 +21078,7 @@ var patternContainmentRule = {
 var unownedBlocksRule = {
   name: "unowned-blocks",
   judges: "design",
-  description: `Judges the data blocks no pattern owns. A Store may stand alone deliberately \u2014 the sanctioned lightweight form for genuinely simple state, acknowledged with a lint.allow \u2014 while the recommended shape stays a Repository; what must never happen is folding the state into a consuming component, where no spec, diagram or conformance check can see it again. A Registry standing alone with no Store to write to is either mistyped (the "file-backed Registry" idiom, a fused persistent store that belongs typed Store) or orphaned. A Query has no standalone form at all: it computes reads over its own Repository's Store.`,
+  description: `Judges the data blocks no owner (a pattern, or a Supervisor keeping its supervision state) owns. A Store may stand alone deliberately \u2014 the sanctioned lightweight form for genuinely simple state, acknowledged with a lint.allow \u2014 while the recommended shape stays a Repository; what must never happen is folding the state into a consuming component, where no spec, diagram or conformance check can see it again. A Registry standing alone with no Store to write to is either mistyped (the "file-backed Registry" idiom, a fused persistent store that belongs typed Store) or orphaned. A Query has no standalone form at all: it computes reads over its own Repository's Store.`,
   codes: [
     { code: "UNOWNED_STORE", defaultSeverity: "warning", summary: "Store not owned by any pattern \u2014 recommended shape is a Repository; a deliberate standalone Store needs a lint.allow" },
     { code: "REGISTRY_WITHOUT_STORE", defaultSeverity: "warning", summary: "Standalone Registry with no Store to write to \u2014 either mistyped (a fused file-backed store belongs typed Store) or orphaned" },
@@ -20253,9 +21124,10 @@ var unownedBlocksRule = {
 var memberVisibilityRule = {
   name: "member-visibility",
   judges: "design",
-  description: "A component may depend on a block within its own group (it is the owning pattern, or a sibling member of the same pattern), on any pattern facade, or on a standalone block \u2014 never on a block privately owned by ANOTHER pattern, which must be reached through that pattern's facade. A retired depending component is skipped, as everywhere in this family.",
+  description: "A component may depend on a block within its own group (it is the owner, or a sibling member of the same owner), on any pattern facade, or on a standalone block \u2014 never on a block privately owned by ANOTHER pattern, which must be reached through that pattern's facade. A Store or Registry a Supervisor owns is that Supervisor's supervision state and nobody else depends on it: a component that does is the intruder, and the finding is reported on it, naming the Supervisor and the state. A retired depending component is skipped, as everywhere in this family.",
   codes: [
-    { code: "VISIBILITY_VIOLATION", defaultSeverity: "error", summary: "Dependency on a block privately owned by another pattern" }
+    { code: "VISIBILITY_VIOLATION", defaultSeverity: "error", summary: "Dependency on a block privately owned by another pattern" },
+    { code: "SUPERVISION_STATE_INTRUSION", defaultSeverity: "error", summary: "Dependency on a Store or Registry a Supervisor owns as its supervision state \u2014 reported on the intruder, naming the Supervisor and the state" }
   ],
   check(ctx) {
     const ownership = ctx.ownershipIndex();
@@ -20266,7 +21138,12 @@ var memberVisibilityRule = {
         if (!owner) continue;
         if (owner === comp.id) continue;
         if (ownership.ownerOf(comp.id) === owner) continue;
-        ctx.addIssue("error", "VISIBILITY_VIOLATION", `Component "${comp.id}" depends on "${depId}", which is privately owned by pattern "${owner}". Depend on the facade "${owner}" instead.`, comp.id, ctx.isComponentDraft(comp.id) || ctx.isComponentDraft(depId));
+        const isDraftCtx = ctx.isComponentDraft(comp.id) || ctx.isComponentDraft(depId);
+        if (ctx.componentMap.get(owner)?.componentType === "Supervisor") {
+          ctx.addIssue("error", "SUPERVISION_STATE_INTRUSION", `"${comp.id}" depends on "${depId}", which Supervisor "${owner}" owns as its supervision state. Supervision state is private to its Supervisor \u2014 nobody else depends on it. If "${comp.id}" needs this data it is shared data: move "${depId}" out of "${owner}"'s owns into a data component both depend on (the Supervisor keeping it through read and lifecycle calls), or reach what "${comp.id}" needs through "${owner}".`, comp.id, isDraftCtx);
+          continue;
+        }
+        ctx.addIssue("error", "VISIBILITY_VIOLATION", `Component "${comp.id}" depends on "${depId}", which is privately owned by pattern "${owner}". Depend on the facade "${owner}" instead.`, comp.id, isDraftCtx);
       }
     }
   }
@@ -21399,9 +22276,9 @@ var durabilityRule = {
   // Stage 8: its verdict needs the whole system's specs, so a part judged alone skips it.
   needsWholeTree: true,
   judges: "design",
-  description: "A durable Store (persisted RAM projection) must carry effect-tagged contract methods, and its writes require a hydration read-back reachable from a lifecycle init entrypoint. read-through is exempt (every read IS the read-back), as are ram-projection (rebuilt not restored) and cache (evictable, loss-safe). The flagship semantic check is opt-out by declaration, never silently absent \u2014 the declaration itself is enforced by durability-declaration.",
+  description: "A durable Store (persisted RAM projection) must carry effect-tagged contract methods, and its mutations \u2014 write-effect methods, and lifecycle-effect methods, which change what exists \u2014 require a hydration read-back reachable from a lifecycle init entrypoint. read-through is exempt (every read IS the read-back), as are ram-projection (rebuilt not restored) and cache (evictable, loss-safe). The flagship semantic check is opt-out by declaration, never silently absent \u2014 the declaration itself is enforced by durability-declaration.",
   codes: [
-    { code: "MISSING_EFFECT_TAG", defaultSeverity: "warning", summary: "Durable Store contract method lacks an effect: read | write tag" },
+    { code: "MISSING_EFFECT_TAG", defaultSeverity: "warning", summary: "Durable Store contract method lacks an effect: read | write | lifecycle tag" },
     { code: "MISSING_HYDRATION", defaultSeverity: "error", summary: "Durable Store is written but no read-back is reachable from any lifecycle init entrypoint" }
   ],
   check(ctx) {
@@ -21429,7 +22306,7 @@ var durabilityRule = {
           isDraftCtx
         );
       }
-      const writes = methods.filter((method) => method.effect === "write");
+      const writes = methods.filter((method) => method.effect === "write" || method.effect === "lifecycle");
       const reads = methods.filter((method) => method.effect === "read");
       if (writes.length === 0) continue;
       const hydrated = initReach !== null && reads.some((method) => initReach.reachesMethod(comp.id, method.name));
@@ -21622,10 +22499,10 @@ function familyAliases(family) {
   }
   return out;
 }
-function typeRefReadings(typeRef, aliases) {
-  const [first, ...rest] = typeRef.split(/::|\./);
-  if (!rest.length) return [typeRef];
-  return [typeRef, ...(aliases.get(first) ?? []).map((key) => `${key}::${rest.join("::")}`)];
+function typeRefReadings(typeRef2, aliases) {
+  const [first, ...rest] = typeRef2.split(/::|\./);
+  if (!rest.length) return [typeRef2];
+  return [typeRef2, ...(aliases.get(first) ?? []).map((key) => `${key}::${rest.join("::")}`)];
 }
 function resolveInvariantRef(ref, types, aliases = /* @__PURE__ */ new Map()) {
   const parts = splitInvariantRef(ref);
@@ -23095,8 +23972,8 @@ var asyncConformanceRule = {
   check(ctx) {
     const code = ctx.codeIndex();
     for (const { implementation, method, sourceFile, draftContext: draftContext4 } of ctx.implementationMethods()) {
-      const contractMethod = ctx.interfaceMap.get(implementation.contract)?.methods.find((m) => m.name === method.name);
-      if (!contractMethod || typeof contractMethod.returns !== "string" || !sourceFile) continue;
+      const contractMethod2 = ctx.interfaceMap.get(implementation.contract)?.methods.find((m) => m.name === method.name);
+      if (!contractMethod2 || typeof contractMethod2.returns !== "string" || !sourceFile) continue;
       const file = pathKey(sourceFile);
       const facts = code.factsAt(file);
       if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
@@ -23105,7 +23982,7 @@ var asyncConformanceRule = {
       if (!signatures || !Object.prototype.hasOwnProperty.call(signatures, symbol)) continue;
       const bodies = signatures[symbol].length;
       if (bodies === 0) continue;
-      const returns = parseTypeExpression(contractMethod.returns, "returns");
+      const returns = parseTypeExpression(contractMethod2.returns, "returns");
       if (!returns.expression) continue;
       const contractAsync = returns.expression.form === "async";
       const asyncBodies = (facts.asyncFunctions ?? []).filter((name) => name === symbol).length;
@@ -23114,7 +23991,7 @@ var asyncConformanceRule = {
         ctx.addIssue(
           "warning",
           "ASYNC_MISMATCH",
-          `Method "${method.name}" of contract "${implementation.contract}" returns "${contractMethod.returns}", which completes later, but ${subject} completes now \u2014 it is neither declared async nor annotated to return a Promise. Every caller is told to await a call that answers at once. Make the code async, or drop \`async\` from the returns.`,
+          `Method "${method.name}" of contract "${implementation.contract}" returns "${contractMethod2.returns}", which completes later, but ${subject} completes now \u2014 it is neither declared async nor annotated to return a Promise. Every caller is told to await a call that answers at once. Make the code async, or drop \`async\` from the returns.`,
           implementation.id,
           draftContext4,
           void 0,
@@ -23124,7 +24001,7 @@ var asyncConformanceRule = {
         ctx.addIssue(
           "warning",
           "ASYNC_MISMATCH",
-          `Method "${method.name}" of contract "${implementation.contract}" returns "${contractMethod.returns}", which completes now, but ${subject} completes later (declared async, or annotated to return a Promise). Every caller built from the contract forgets to await it. Write the returns as "async ${contractMethod.returns}" \u2014 or, if the code is async by accident, make it complete now.`,
+          `Method "${method.name}" of contract "${implementation.contract}" returns "${contractMethod2.returns}", which completes now, but ${subject} completes later (declared async, or annotated to return a Promise). Every caller built from the contract forgets to await it. Write the returns as "async ${contractMethod2.returns}" \u2014 or, if the code is async by accident, make it complete now.`,
           implementation.id,
           draftContext4,
           void 0,
@@ -24669,6 +25546,8 @@ var SDD_RULES = [
   typeExpressionsRule,
   enumTypesRule,
   namedScalarTypesRule,
+  // The rename traces: a former key a consumer resolves must name one element.
+  renameTracesRule,
   // Contracts and the targets narratives name, in four questions with one
   // owner each: does the implementation mirror its contract, does a target
   // inside this tree resolve, does a target that leaves it pin to exactly one
@@ -24722,6 +25601,10 @@ var SDD_RULES = [
   dataBlockDepsRule,
   entrypointDepsRule,
   portalWriteShortcutRule,
+  // The process layer's data reach and the lifecycle effect's closure, both
+  // read from narratives against the callee's declared effect.
+  supervisorSharedDataRule,
+  lifecycleEffectClosureRule,
   // Patterns in four questions: who may own and what a claim must name,
   // what each pattern must contain, which data blocks are left standing
   // alone, and who may see a private member.
@@ -26445,7 +27328,16 @@ function buildRuleContext(opts) {
   const sitesSeen = /* @__PURE__ */ new Map();
   const sitesReported = (specId, code) => {
     const seen = sitesSeen.get(`${specId}\0${code}`);
-    return { sites: [...seen?.sites ?? []], unsited: seen?.unsited ?? false };
+    return { sites: [...seen?.sites ?? []], unsited: seen?.unsited ?? false, errored: seen?.errored ?? false };
+  };
+  const codeDefaults = new Map(opts.issueCodeSeverities ?? []);
+  for (const a of opts.extensions?.assertions ?? []) {
+    if (!codeDefaults.has(a.fullCode)) codeDefaults.set(a.fullCode, a.severity);
+  }
+  const severityOf = (code, specId) => {
+    const defaultSeverity = codeDefaults.get(code);
+    if (!defaultSeverity) return void 0;
+    return getRuleSeverity(code, defaultSeverity, false, subsystemOfSpec.get(specId));
   };
   for (const s of subsystems) collectAllows(s.id, s.lint);
   for (const c of components) collectAllows(c.id, c.lint);
@@ -26488,9 +27380,10 @@ function buildRuleContext(opts) {
     if (specId) {
       const key = `${specId}\0${code}`;
       let seen = sitesSeen.get(key);
-      if (!seen) sitesSeen.set(key, seen = { sites: /* @__PURE__ */ new Set(), unsited: false });
+      if (!seen) sitesSeen.set(key, seen = { sites: /* @__PURE__ */ new Set(), unsited: false, errored: false });
       if (parts) seen.sites.add(parts.at);
       else seen.unsited = true;
+      if (severity === "error") seen.errored = true;
     }
     let allowClaimed = false;
     if (specId) {
@@ -26607,6 +27500,7 @@ function buildRuleContext(opts) {
     roundTripIssues: opts.roundTripIssues,
     lintAllows: lintAllows2,
     sitesReported,
+    severityOf,
     knownIssueCodes: opts.knownIssueCodes,
     carriedFindings,
     carryableIssueCodes: opts.carryableIssueCodes ?? /* @__PURE__ */ new Set(),
@@ -26760,12 +27654,12 @@ function measure(candidate) {
 // src/core/rules/gate-identity.ts
 var crypto4 = __toESM(require("crypto"));
 var GATE_ALGORITHM = "sha256+content+doctrine+inputs+members";
-var byKey = (items, key) => [...items].sort((a, b) => compareOrdinal(key(a), key(b)));
+var byKey2 = (items, key) => [...items].sort((a, b) => compareOrdinal(key(a), key(b)));
 function ruleIdentities(rules) {
-  return byKey(
+  return byKey2(
     rules.map((r) => ({
       name: r.name,
-      codes: byKey(r.codes.map((c) => ({ code: c.code, severity: c.defaultSeverity })), (c) => c.code)
+      codes: byKey2(r.codes.map((c) => ({ code: c.code, severity: c.defaultSeverity })), (c) => c.code)
     })),
     (r) => r.name
   );
@@ -26813,7 +27707,7 @@ function doctrineIdentity(doctrine2, builtinRules, gate) {
      * changed requirement stales the requiring project's lock.
      */
     composition: gate.composition ?? null,
-    packs: byKey(
+    packs: byKey2(
       doctrine2.packs.map((p) => ({ name: p.name, version: p.version ?? null, scope: p.scope })),
       (p) => `${p.name}@${p.version ?? ""}#${p.scope}`
     ),
@@ -26821,13 +27715,13 @@ function doctrineIdentity(doctrine2, builtinRules, gate) {
     // the identity — a load-order change that flips a collision winner shows up here.
     profiles: doctrine2.profiles,
     languages: doctrine2.languages,
-    patterns: byKey(
+    patterns: byKey2(
       doctrine2.patterns.map((p) => ({ id: p.id, version: p.version, pack: p.pack })),
       (p) => `${p.pack}/${p.id}@${p.version}`
     ),
     guarantees: [...doctrine2.guarantees].sort(),
-    assertions: byKey(doctrine2.assertions.map((a) => ({ ...a })), (a) => a.fullCode),
-    rules: byKey(
+    assertions: byKey2(doctrine2.assertions.map((a) => ({ ...a })), (a) => a.fullCode),
+    rules: byKey2(
       doctrine2.rules.map((r) => ({ name: r.name, codes: r.codes.map((c) => c.code).sort() })),
       (r) => r.name
     )
@@ -26838,7 +27732,7 @@ function computeGateIdentity(content, doctrine2, builtinRules, inputs, gate, mem
     content: content.digest,
     doctrine: doctrineIdentity(doctrine2, builtinRules, gate),
     inputs: [...inputs].sort(compareOrdinal),
-    members: byKey(Object.entries(members), ([alias]) => alias).map(([alias, subject]) => ({ alias, subject }))
+    members: byKey2(Object.entries(members), ([alias]) => alias).map(([alias, subject]) => ({ alias, subject }))
   };
   const digest3 = crypto4.createHash("sha256").update(canonicalize(payload)).digest("hex");
   return { algorithm: GATE_ALGORITHM, digest: digest3 };
@@ -27039,6 +27933,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
     const carryableCodes = new Set(
       knownIssueCodes().filter((rc) => rc.carryable).map((rc) => rc.code)
     );
+    const codeSeverities = new Map(knownIssueCodes().map((rc) => [rc.code, rc.defaultSeverity]));
     const family = graph();
     const memberTables = family.nodes.filter((n) => n.namespace !== "").map((n) => resolveProjectExports(n.namespace));
     const producers = new Set(family.references.filter((r) => r.consumer === "").map((r) => r.producer));
@@ -27081,6 +27976,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
       codeModel,
       roundTripIssues,
       knownIssueCodes: knownCodes,
+      issueCodeSeverities: codeSeverities,
       carryableIssueCodes: carryableCodes,
       issues
     });
@@ -27181,8 +28077,8 @@ function judgePartAlone(config, scopeSubsystem) {
     issues.push(issue("warning", "EXTERNAL_CHECK_UNAVAILABLE", `The parent "${parentId}" governs its parts with a pack this machine cannot load at its pinned version, so its rules were not run here: ${failure}`));
   }
   const ownIds = new Set([...own.subsystems, ...own.components, ...own.interfaces, ...own.implementations, ...own.types].map((s) => s.id));
-  const isOwn = (id) => ownIds.has(id);
-  issues.push(...getLoaderIssues().filter((e) => !e.specId || isOwn(e.specId)));
+  const isOwn2 = (id) => ownIds.has(id);
+  issues.push(...getLoaderIssues().filter((e) => !e.specId || isOwn2(e.specId)));
   for (const [key, by] of namedKeys(own)) {
     if (ownIds.has(key) || context.ids.has(key)) continue;
     issues.push(issue("warning", "EXTERNAL_CHECK_UNAVAILABLE", `"${by}" names "${key}", which neither this part nor its pinned excerpt of "${parentId}" holds \u2014 used since the pin: re-pin with \`wairon externals pin\` while the parent is on disk.`, by));
@@ -27190,8 +28086,8 @@ function judgePartAlone(config, scopeSubsystem) {
   const ownSignatures = signatureFacts();
   const ownTypeSpellings = typeSpellingFacts();
   const partTypeSpellings = {
-    respellings: ownTypeSpellings.respellings.filter((r) => isOwn(r.specId)),
-    problems: ownTypeSpellings.problems.filter((p) => p.specId === void 0 || isOwn(p.specId))
+    respellings: ownTypeSpellings.respellings.filter((r) => isOwn2(r.specId)),
+    problems: ownTypeSpellings.problems.filter((p) => p.specId === void 0 || isOwn2(p.specId))
   };
   const resolved = resolveSignatures(
     [...own.interfaces, ...context.interfaces],
@@ -27238,7 +28134,7 @@ function judgePartAlone(config, scopeSubsystem) {
     packRequirements: [],
     surfaceSnapshots: [],
     codeModel,
-    roundTripIssues: dryRunSerializeSpecs(isOwn),
+    roundTripIssues: dryRunSerializeSpecs(isOwn2),
     knownIssueCodes: knownCodes,
     carryableIssueCodes: new Set(knownIssueCodes().filter((rc) => rc.carryable).map((rc) => rc.code)),
     issues
@@ -28271,10 +29167,10 @@ function settle(owner, level, candidates, problems) {
       detail: `"${name}" is bound to ${targets.length} different targets (${targets.join(", ")}) by ${explicit.length ? "explicit entries" : "wildcard re-exports"}; it is left out of the table`
     });
   }
-  const byKey2 = /* @__PURE__ */ new Map();
-  for (const e of entries) byKey2.set(nameKey(e.publicName), [...byKey2.get(nameKey(e.publicName)) ?? [], e]);
+  const byKey3 = /* @__PURE__ */ new Map();
+  for (const e of entries) byKey3.set(nameKey(e.publicName), [...byKey3.get(nameKey(e.publicName)) ?? [], e]);
   const clashing = /* @__PURE__ */ new Set();
-  for (const group of byKey2.values()) {
+  for (const group of byKey3.values()) {
     const targets = [...new Set(group.map((e) => exportTargetKey(e)))];
     if (group.length < 2 || targets.length < 2) continue;
     group.forEach((e) => clashing.add(e));
@@ -28592,7 +29488,7 @@ function pinnedUsageOf(consumer, alias) {
 function emptySignatureFacts() {
   return { sources: [], staleTexts: [] };
 }
-function namespaceOf(key) {
+function namespaceOf2(key) {
   const at = key.lastIndexOf("::");
   return at === -1 ? "" : key.slice(0, at);
 }
@@ -28620,7 +29516,7 @@ function methodReading(tables, intf, value) {
   if (dot <= 0 || dot === value.length - 1) return null;
   const head2 = value.slice(0, dot);
   const tail = value.slice(dot + 1);
-  const ns = namespaceOf(intf.id);
+  const ns = namespaceOf2(intf.id);
   const keys = [head2, ...ns && !head2.startsWith(`${ns}::`) ? [`${ns}::${head2}`] : []];
   for (const key of keys) {
     if (!tables.componentKeys.has(key)) continue;
@@ -28632,8 +29528,8 @@ function methodReading(tables, intf, value) {
 function typeReading(tables, intf, value) {
   const bound2 = value.includes("::") ? tables.boundTypes.get(`${intf.id}|${value}`) : void 0;
   const named2 = bound2 !== void 0 ? tables.types.filter((t) => t.id === bound2) : tables.types.filter((t) => t.id === value || typeMatchesRef(t, value));
-  const ns = namespaceOf(intf.id);
-  const local = (t) => namespaceOf(t.id) === ns ? 0 : 1;
+  const ns = namespaceOf2(intf.id);
+  const local = (t) => namespaceOf2(t.id) === ns ? 0 : 1;
   const ranked = [...named2].sort((a, b) => local(a) - local(b));
   return { signature: ranked.find((t) => t.kind === "signature"), other: ranked.find((t) => t.kind !== "signature") };
 }
@@ -29386,7 +30282,7 @@ function keyedSystem(system, key, subsystems) {
   };
 }
 function resolveFamilyTables(raws) {
-  const byKey2 = new Map(raws.map((r) => [r.record.namespace, r]));
+  const byKey3 = new Map(raws.map((r) => [r.record.namespace, r]));
   const done = /* @__PURE__ */ new Set();
   const resolving = /* @__PURE__ */ new Set();
   const resolve41 = (raw) => {
@@ -29403,7 +30299,7 @@ function resolveFamilyTables(raws) {
         const source = e.from ?? e.subsystem;
         const producerKey = source !== void 0 ? raw.record.aliases.get(source) : void 0;
         if (producerKey === void 0 || producerTables.has(producerKey)) continue;
-        const producer = byKey2.get(producerKey);
+        const producer = byKey3.get(producerKey);
         producerTables.set(producerKey, producer ? resolve41(producer) : null);
         audienceOf.set(producerKey, "project");
       }
@@ -33089,6 +33985,14 @@ var SpecWorkspace = class {
     }
     const receiving = this.moveTargetContract(to, ofTarget);
     if (typeof receiving === "string") return receiving;
+    if (receiving) {
+      for (const name of methods) {
+        const holder2 = receiving.methods.find((m) => (m.previousNames ?? []).includes(`${receiving.id}.${name}`));
+        if (holder2) {
+          return `name-retired: "${receiving.id}" retired the name "${name}" \u2014 its method "${holder2.name}" lists "${receiving.id}.${name}" in its previousNames. Unsetting that previousNames releases the name.`;
+        }
+      }
+    }
     const contractId = receiving?.id ?? `i${to}`;
     const holder = contracts.find((i) => i.id === contractId);
     if (!receiving && holder) {
@@ -33142,7 +34046,7 @@ var SpecWorkspace = class {
     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));
+      arriving.push(...cloneSpec(leaving).map((m) => ({ ...m, previousNames: [...m.previousNames ?? [], `${contract.id}.${m.name}`] })));
       const remaining = cloneSpec(contract);
       remaining.methods = remaining.methods.filter((m) => !methods.includes(m.name));
       this.stageMoveEdit(plan6, "interface", contract.id, contract, remaining);
@@ -33325,9 +34229,9 @@ var SpecWorkspace = class {
     const reports = moveChangeReports(edits, false);
     const written = [];
     try {
-      for (const report2 of reports) {
-        const edit4 = edits.find((e) => e.kind === report2.kind && e.id === report2.id);
-        report2.notices.push(...this.saveMovedSpec(edit4.kind, edit4.after));
+      for (const report3 of reports) {
+        const edit4 = edits.find((e) => e.kind === report3.kind && e.id === report3.id);
+        report3.notices.push(...this.saveMovedSpec(edit4.kind, edit4.after));
         written.push(edit4);
       }
       finish?.();
@@ -33568,6 +34472,9 @@ function getInterfacePath(id, componentId) {
 function getImplementationPath(id, contractId) {
   return current().getImplementationPath(id, contractId);
 }
+function getTypePath(id, subsystemId, group) {
+  return current().getTypePath(id, subsystemId, group);
+}
 function loadSystemSpec() {
   return current().loadSystemSpec();
 }
@@ -35480,6 +36387,11 @@ function renameComponent(componentId, newId) {
   if (taken.length > 0) {
     throw new WaironError(`id-taken: the new id, or an id it implies, is already in use: ${taken.join(", ")}.`);
   }
+  refuseRetiredIds([
+    { kind: "component", id: newId },
+    { kind: "interface", id: interfaceId },
+    { kind: "implementation", id: implementationId }
+  ]);
   const contracts = interfaces.filter((i) => i.component === componentId);
   const movingInterface = contracts.find((i) => i.id === `i${componentId}`);
   const movingImplementation = implementations.find((impl) => impl.id === `${componentId}_impl` && contracts.some((i) => i.id === impl.contract));
@@ -35501,18 +36413,21 @@ function renameComponent(componentId, newId) {
     return ref;
   };
   const specsDir = aiPathsAt(getProjectRoot()).specsDir();
+  const derivesName = (entry) => entry.interface !== void 0 ? movingInterface !== void 0 && entry.interface === movingInterface.id : entry.typeDef === void 0 && entry.component === componentId;
+  const keptDry = keepPublicNames(specsDir, derivesName, true);
   assertSpecsInReach(
-    [...renamed.map(({ kind, from }) => ({ kind, id: from })), ...rewriteRefFields(specsDir, remap, void 0, true), ...rekeyLintAllows(specsDir, rename, true)],
+    [...renamed.map(({ kind, from }) => ({ kind, id: from })), ...keptDry.specs, ...rewriteRefFields(specsDir, remap, void 0, true), ...rekeyLintAllows(specsDir, rename, true)],
     `renaming component "${componentId}"`,
     Array.isArray(registerEdits) && registerEdits.length > 0
   );
-  const rewrittenRefs = rewriteRefFields(specsDir, remap);
+  const kept = keepPublicNames(specsDir, derivesName);
+  const rewrittenRefs = [...kept.specs, ...rewriteRefFields(specsDir, remap)];
   const allowsRekeyed = rekeyLintAllows(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);
   const carried = projectConfigRepository.rekeyCarried(rename);
-  return { renamed, rewritten, carried };
+  return { renamed, rewritten, carried, keptPublicNames: kept.names };
 }
 function moveRenamedSpecs(componentId, newId, component, movingInterface, movingImplementation) {
   const interfaceId = `i${newId}`;
@@ -35520,20 +36435,69 @@ function moveRenamedSpecs(componentId, newId, component, movingInterface, moving
   const movedComponent2 = loadComponentSpec(componentId) ?? component;
   const movedInterface = movingInterface ? loadInterfaceSpec(movingInterface.id) ?? movingInterface : null;
   const movedImplementation = movingImplementation ? loadImplementationSpec(movingImplementation.id) ?? movingImplementation : null;
-  saveComponentSpec({ ...movedComponent2, id: newId });
-  if (movedInterface) saveInterfaceSpec({ ...movedInterface, id: interfaceId, component: newId });
+  saveComponentSpec({ ...movedComponent2, id: newId, previousIds: traced(movedComponent2.previousIds, componentId) });
+  if (movedInterface) {
+    saveInterfaceSpec({ ...movedInterface, id: interfaceId, component: newId, previousIds: traced(movedInterface.previousIds, movedInterface.id) });
+  }
   if (movedImplementation) {
     const oldFile = getImplementationPath(movedImplementation.id);
     if (path25.resolve(getImplementationPath(implementationId, movedImplementation.contract)) === path25.resolve(oldFile)) {
       fs16.unlinkSync(oldFile);
     }
-    saveImplementationSpec({ ...movedImplementation, id: implementationId });
+    saveImplementationSpec({ ...movedImplementation, id: implementationId, previousIds: traced(movedImplementation.previousIds, movedImplementation.id) });
   }
   removeSpecFile2(getComponentPath(componentId), componentId);
   if (movingInterface) removeSpecFile2(getInterfacePath(movingInterface.id), movingInterface.id);
   if (movingImplementation) removeSpecFile2(getImplementationPath(movingImplementation.id), movingImplementation.id);
   invalidateSpecCache();
 }
+function traced(trace, former) {
+  const out = [...trace ?? []];
+  if (!out.includes(former)) out.push(former);
+  return out;
+}
+function refuseRetiredIds(wanted) {
+  const index = scanAllSpecs({ memberDepth: 0 });
+  const retired = wanted.flatMap(({ kind, id }) => {
+    const holder = specIndexRetiredBy(index, kind, id);
+    return holder ? [`${kind} "${id}" is listed in the previousIds of "${holder}"`] : [];
+  });
+  if (retired.length > 0) {
+    throw new WaironError(
+      `id-retired: ${retired.join("; ")}. A consumer holding the old key would read the new spec as the renamed one; unsetting the holder's previousIds (sdd_update_spec unset) releases the id.`
+    );
+  }
+}
+function keepPublicNames(specsDir, derives, dryRun = false) {
+  const names = [];
+  const specs = [];
+  for (const file of listFilesRecursive(specsDir, ".yaml")) {
+    let raw;
+    try {
+      raw = readYamlFile(file);
+    } catch {
+      continue;
+    }
+    if (!raw || typeof raw !== "object") continue;
+    const kind = specKind(raw);
+    if (kind !== "subsystem" && kind !== "system" || !Array.isArray(raw.publicInterfaces)) continue;
+    let changed = false;
+    for (const entry of raw.publicInterfaces) {
+      if (!entry || typeof entry !== "object" || entry.as !== void 0 || entry.id !== void 0) continue;
+      if (!derives(entry)) continue;
+      const source = entry.interface ?? entry.component ?? entry.typeDef;
+      if (typeof source !== "string") continue;
+      const name = source.split("::").pop() ?? source;
+      entry.as = name;
+      names.push(name);
+      changed = true;
+    }
+    if (!changed) continue;
+    if (!dryRun) writeYamlFile(file, raw);
+    specs.push({ kind, id: kind === "system" ? "system" : String(raw.id) });
+  }
+  return { names: [...new Set(names)], specs };
+}
 function removeSpecFile2(file, id) {
   if (!fs16.existsSync(file)) return;
   try {
@@ -35582,6 +36546,12 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   if (taken.length > 0) {
     throw new WaironError(`name-taken: ${taken.join(", ")} already declares a method under the name "${newName}".`);
   }
+  const retiredOn = moving.flatMap((i) => i.methods.filter((m) => (m.previousNames ?? []).includes(`${i.id}.${newName}`)).map((m) => `"${i.id}.${m.name}"`));
+  if (retiredOn.length > 0) {
+    throw new WaironError(
+      `name-retired: ${retiredOn.join(", ")} lists "${newName}" in its previousNames \u2014 the name is retired on that contract. Unsetting that previousNames releases it.`
+    );
+  }
   const implementations = loadImplementationSpecs();
   const movingContracts = new Set(moving.map((i) => i.id));
   const renamed = [];
@@ -35615,6 +36585,7 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
       methods: contract.methods.map((m) => m.name === methodName ? {
         ...m,
         name: newName,
+        previousNames: traced(m.previousNames, `${contract.id}.${methodName}`),
         ...m.params === void 0 && m.signatureFrom === void 0 ? { signature: renameInSignature(m.signature, methodName, newName) } : {}
       } : m)
     });
@@ -35639,6 +36610,7 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   const allowsRekeyed = rekeyLintAllows(specsDir, rename);
   const rewritten = [...new Set([...retargeted, ...allowsRekeyed].map((spec) => spec.id))];
   const mentions = collectMentions(specsDir, methodName, moving);
+  const publishedIn = exportsPublishing(componentId, new Set(moving.map((i) => i.id)));
   const carried = projectConfigRepository.rekeyCarried(rename);
   return {
     component: componentId,
@@ -35648,9 +36620,25 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
     rewritten,
     mentions,
     ...pinnedSymbol ? { pinnedSymbol } : {},
-    carried
+    carried,
+    publishedIn
   };
 }
+function exportsPublishing(componentId, contracts) {
+  const names = /* @__PURE__ */ new Set();
+  const tables = [
+    ...loadSubsystemSpecs().filter((s) => !s.id.includes("::")).map((s) => resolveSubsystemExports(s.id)),
+    resolveProjectExports()
+  ];
+  for (const table of tables) {
+    for (const entry of table.entries) {
+      if (entry.kind !== "component" || entry.component !== componentId) continue;
+      if (entry.interface !== void 0 && !contracts.has(entry.interface)) continue;
+      names.add(entry.publicName);
+    }
+  }
+  return [...names].sort();
+}
 function renameInSignature(signature, from, to) {
   return signature.replace(identifierPattern(from), to);
 }
@@ -35686,6 +36674,150 @@ function collectMentions(specsDir, methodName, moved) {
 function identifierPattern(methodName) {
   return new RegExp(`(?<![A-Za-z0-9_])${methodName}(?![A-Za-z0-9_])`);
 }
+function respellLike(written, oldId, newId) {
+  const words2 = (id) => id.split(/[_-]+/).filter(Boolean);
+  const pascal = (id) => words2(id).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  const camel = (id) => {
+    const p = pascal(id);
+    return p.charAt(0).toLowerCase() + p.slice(1);
+  };
+  const kebab = (id) => words2(id).join("-");
+  if (written === oldId) return newId;
+  if (written === pascal(oldId)) return pascal(newId);
+  if (written === camel(oldId)) return camel(newId);
+  if (written === kebab(oldId)) return kebab(newId);
+  if (written.includes("-")) return kebab(newId);
+  return /^[A-Z]/.test(written) ? pascal(newId) : newId;
+}
+function renameType(typeId, newId) {
+  const all = loadTypeSpecs();
+  const cut = typeId.lastIndexOf("::");
+  const qualifier = cut >= 0 ? typeId.slice(0, cut) : void 0;
+  const ownSubsystem = qualifier !== void 0 && loadSubsystemSpecs().some((s) => s.id === qualifier);
+  if (qualifier !== void 0 && !ownSubsystem) {
+    throw new WaironError(`chained-type: "${typeId}" lives in another project; rename it from that project's own root.`);
+  }
+  const type = qualifier !== void 0 ? all.find((t) => t.id === typeId.slice(cut + 2) && t.subsystem === qualifier) ?? null : loadTypeSpec(typeId);
+  if (!type) throw new WaironError(`type-missing: no type has the id "${typeId}".`);
+  if (type.id.includes("::")) {
+    throw new WaironError(`chained-type: "${type.id}" lives in another project; rename it from that project's own root.`);
+  }
+  const oldId = type.id;
+  if (!SpecIdSchema.safeParse(newId).success) {
+    throw new WaironError(`invalid-id: "${newId}" is not a lowercase identifier with no namespace separator.`);
+  }
+  const sameOwner = (t) => (t.subsystem ?? "") === (type.subsystem ?? "");
+  if (all.some((t) => t !== type && t.id === newId && sameOwner(t))) {
+    throw new WaironError(`id-taken: another type of ${type.subsystem ? `"${type.subsystem}"` : "the system"} already has the id "${newId}".`);
+  }
+  refuseRetiredIds([{ kind: "type", id: qualifiedTypeId({ id: newId, subsystem: type.subsystem }) }]);
+  const rename = { specs: [{ from: oldId, to: newId }] };
+  const registerEdits = projectConfigRepository.rekeyCarried(rename, true);
+  const components = new Map(loadComponentSpecs().map((c) => [c.id, c.subsystem]));
+  const others = all.filter((t) => t !== type);
+  const namesType = (token, owner) => {
+    if (!typeMatchesRef(type, token)) return false;
+    if (!others.some((t) => typeMatchesRef(t, token))) return true;
+    return (owner ?? "") === (type.subsystem ?? "");
+  };
+  const respellText = (text3, owner) => {
+    if (typeof text3 !== "string") return text3;
+    return text3.replace(/[A-Za-z_][A-Za-z0-9_-]*(?:(?:::|\.)[A-Za-z_][A-Za-z0-9_-]*)*/g, (token) => {
+      if (!namesType(token, owner)) return token;
+      const parts = token.split(/(::|\.)/);
+      parts[parts.length - 1] = respellLike(parts[parts.length - 1], oldId, newId);
+      return parts.join("");
+    });
+  };
+  const specsDir = aiPathsAt(getProjectRoot()).specsDir();
+  const derivesName = (entry) => entry.interface === void 0 && entry.component === void 0 && typeof entry.typeDef === "string" && namesType(entry.typeDef, void 0);
+  const respellSpec = (raw) => {
+    const kind = specKind(raw);
+    const before = JSON.stringify(raw);
+    const at = (holder, key, owner) => {
+      if (holder && typeof holder[key] === "string") holder[key] = respellText(holder[key], owner);
+    };
+    const methodPositions = (method, owner, sourced) => {
+      if (!method || typeof method !== "object") return;
+      for (const p of Array.isArray(method.params) ? method.params : []) at(p, "type", owner);
+      at(method, "returns", owner);
+      if (sourced && typeof method.signatureFrom === "string" && namesType(method.signatureFrom, owner)) at(method, "signatureFrom", owner);
+      if (typeof method.signature === "string") {
+        if (Array.isArray(method.params)) method.signature = deriveMethodSignature(method) ?? method.signature;
+        else {
+          const close2 = method.signature.lastIndexOf(")");
+          if (close2 >= 0) method.signature = method.signature.slice(0, close2 + 1) + respellText(method.signature.slice(close2 + 1), owner);
+        }
+      }
+    };
+    if (kind === "interface") {
+      const owner = components.get(String(raw.component));
+      for (const m of Array.isArray(raw.methods) ? raw.methods : []) methodPositions(m, owner, true);
+    } else if (kind === "type") {
+      const owner = typeof raw.subsystem === "string" ? raw.subsystem : void 0;
+      for (const f of Array.isArray(raw.fields) ? raw.fields : []) {
+        at(f, "type", owner);
+        if (typeof f?.references === "string") {
+          const [head2, ...rest] = f.references.split(".");
+          if (namesType(head2, owner)) f.references = [respellText(head2, owner), ...rest].join(".");
+        }
+      }
+      for (const p of Array.isArray(raw.params) ? raw.params : []) at(p, "type", owner);
+      at(raw, "returns", owner);
+      if (typeof raw.linkedEntity === "string" && namesType(raw.linkedEntity, owner)) at(raw, "linkedEntity", owner);
+      for (const m of Array.isArray(raw.methods) ? raw.methods : []) methodPositions(m, owner, false);
+    } else if (kind === "subsystem" || kind === "system") {
+      const owner = kind === "subsystem" ? String(raw.id) : void 0;
+      for (const e of Array.isArray(raw.publicInterfaces) ? raw.publicInterfaces : []) {
+        if (e && typeof e.typeDef === "string" && namesType(e.typeDef, owner)) at(e, "typeDef", owner);
+      }
+    }
+    return JSON.stringify(raw) !== before;
+  };
+  const respellAll = (dryRun) => {
+    const out = [];
+    for (const file of listFilesRecursive(specsDir, ".yaml")) {
+      let raw;
+      try {
+        raw = readYamlFile(file);
+      } catch {
+        continue;
+      }
+      const kind = raw && typeof raw === "object" ? specKind(raw) : void 0;
+      if (!kind || !respellSpec(raw)) continue;
+      if (!dryRun) writeYamlFile(file, raw);
+      out.push({ kind, id: kind === "system" ? "system" : String(raw.id) });
+    }
+    return out;
+  };
+  assertSpecsInReach(
+    [{ kind: "type", id: oldId }, ...keepPublicNames(specsDir, derivesName, true).specs, ...respellAll(true), ...rekeyLintAllows(specsDir, rename, true)],
+    `renaming type "${typeId}"`,
+    Array.isArray(registerEdits) && registerEdits.length > 0
+  );
+  const kept = keepPublicNames(specsDir, derivesName);
+  const respelled = respellAll(false);
+  const allowsRekeyed = rekeyLintAllows(specsDir, rename);
+  const rewritten = [...new Set([...kept.specs, ...respelled, ...allowsRekeyed].filter((spec) => !(spec.kind === "type" && spec.id === oldId)).map((spec) => spec.id))];
+  invalidateSpecCache();
+  const moved = loadTypeSpecs().find((t) => t.id === oldId && (t.subsystem ?? "") === (type.subsystem ?? "")) ?? type;
+  saveSpec("type", { ...moved, id: newId, previousIds: traced(moved.previousIds, oldId) });
+  invalidateSpecCache();
+  removeSpecFile2(typeFileOf(oldId, type), oldId);
+  if (loadTypeSpecs().some((t) => t.id === oldId && (t.subsystem ?? "") === (type.subsystem ?? ""))) deleteSpec("type", oldId);
+  invalidateSpecCache();
+  const carried = projectConfigRepository.rekeyCarried(rename);
+  return {
+    from: qualifiedTypeId(type),
+    to: qualifiedTypeId({ id: newId, subsystem: type.subsystem }),
+    rewritten,
+    keptPublicNames: kept.names,
+    carried
+  };
+}
+function typeFileOf(id, type) {
+  return getTypePath(id, type.subsystem, type.group);
+}
 function moveMountToMembers(alias) {
   const family = graph();
   const member = family.nodes.find((n) => n.parent === "" && n.mountAlias === alias);
@@ -35871,18 +37003,18 @@ function normalizePath(p) {
 var fs18 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
 var path27 = __toESM(require("path"));
-var import_zod10 = require("zod");
-var VariantDefSchema = import_zod10.z.object({
+var import_zod11 = require("zod");
+var VariantDefSchema = import_zod11.z.object({
   /** Variant id referenced by a component's `variant` (e.g. "publisher", "org/external-config-adapter"). */
-  id: import_zod10.z.string().min(1),
+  id: import_zod11.z.string().min(1),
   /** The core stereotype this variant specializes — authoritative for generic semantics (Adapter, Orchestrator, …). */
-  base: import_zod10.z.string().min(1),
+  base: import_zod11.z.string().min(1),
   /** How to implement a component of this variant — the recipe the implementer follows and reuses across same-variant components. */
-  guidance: import_zod10.z.string().min(1),
+  guidance: import_zod11.z.string().min(1),
   /** Optional: this variant only applies for the given target language (else it applies everywhere). */
-  target: import_zod10.z.string().optional(),
+  target: import_zod11.z.string().optional(),
   /** Optional: this variant only applies under the given architectural profile. */
-  profile: import_zod10.z.string().optional()
+  profile: import_zod11.z.string().optional()
 });
 function globalVariantsDir() {
   return process.env.WAIRON_VARIANTS_DIR ?? path27.join(os4.homedir(), ".wairon", "variants");
@@ -37045,19 +38177,19 @@ function retireSpecialists(apply3) {
       if (decision === void 0) return "pending";
       return decision === "unset" ? "neither" : decision;
     }
-    const dependency = byId.get(id);
-    if (dependency?.componentType === "Orchestrator" && dependency.dependencyClass) return dependency.dependencyClass;
-    if (dependency && DATA_FACADES.has(dependency.componentType)) return "facade";
+    const dependency2 = byId.get(id);
+    if (dependency2?.componentType === "Orchestrator" && dependency2.dependencyClass) return dependency2.dependencyClass;
+    if (dependency2 && DATA_FACADES.has(dependency2.componentType)) return "facade";
     return "neither";
   };
   const described = (id) => {
-    const dependency = byId.get(id);
+    const dependency2 = byId.get(id);
     const fit = fitOf(id);
     let what;
-    if (!dependency) what = "missing";
+    if (!dependency2) what = "missing";
     else if (fit === "pure" || fit === "read") what = fit;
-    else if (dependency.componentType === "Orchestrator" || specialistIds.has(id)) what = "workflow";
-    else what = dependency.componentType;
+    else if (dependency2.componentType === "Orchestrator" || specialistIds.has(id)) what = "workflow";
+    else what = dependency2.componentType;
     return `${id} (${what})`;
   };
   const reasonFor = (specialist, decision, settled2) => {
@@ -38242,7 +39374,7 @@ function buildServerInstructions2() {
 // src/mcp/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var import_types12 = require("@modelcontextprotocol/sdk/types.js");
 var path48 = __toESM(require("path"));
 var crypto10 = __toESM(require("crypto"));
@@ -38354,6 +39486,7 @@ function refuseUnknownOwner(kind, merged, storedOwner) {
 }
 var STORE_MANAGED_FIELDS = /* @__PURE__ */ new Set(["status", "updatedAt"]);
 var ALWAYS_CARRIED_FIELDS = /* @__PURE__ */ new Set(["ext"]);
+var TRACED_KINDS = /* @__PURE__ */ new Set(["component", "interface", "implementation", "type"]);
 var STATUS_ORDER = ["draft", "design", "complete"];
 var STATUSED_KINDS = /* @__PURE__ */ new Set(["subsystem", "component", "interface", "implementation"]);
 var MISSING_PARENT = {
@@ -38400,6 +39533,10 @@ function applyRestatement(restatement, loaded, parent) {
   const carried = carryInto(restatement, existing, candidate);
   const cleared = clearedByOmission(existing, candidate, restatement.fields);
   stampLifecycle(candidate, existing, status.status);
+  if (restatement.kind === "interface") {
+    const retired = retiredMethodNames(existing, candidate);
+    if (retired) return refused(restatement, replacedExisting, `${retired} Nothing was written.`);
+  }
   if (restatement.kind === "interface") {
     const restated = restatedSources(candidate.methods);
     if (restated.length) return refused(restatement, replacedExisting, `${restatedSourceRefusal(String(candidate.id), restated)} Nothing was written.`);
@@ -38494,9 +39631,32 @@ function carryInto(restatement, existing, candidate) {
       for (const field of carryUnexpressed(prev, method, restatement.memberFields)) carried.push(`${field} (${String(method.name)})`);
     }
   }
+  if (restatement.kind === "interface" && !restatement.memberFields && Array.isArray(candidate.methods)) {
+    const stored = existing.methods ?? [];
+    for (const method of candidate.methods) {
+      const prev = stored.find((p) => p.name === method.name);
+      if (prev?.previousNames === void 0 || method.previousNames !== void 0) continue;
+      method.previousNames = prev.previousNames;
+      carried.push(`previousNames (${String(method.name)})`);
+    }
+  }
   carried.push(...carryUnexpressed(existing, candidate, [...restatement.fields, "createdAt"]));
   return carried;
 }
+function retiredMethodNames(existing, candidate) {
+  const id = String(candidate.id);
+  const storedNames = new Set((existing?.methods ?? []).map((m) => m.name));
+  const methods = Array.isArray(candidate.methods) ? candidate.methods : [];
+  const holders = [...methods, ...existing?.methods ?? []];
+  for (const method of methods) {
+    if (storedNames.has(method.name)) continue;
+    const holder = holders.find((m) => m !== method && (m.previousNames ?? []).includes(`${id}.${method.name}`));
+    if (holder) {
+      return `Refusing to write interface "${id}": name-retired \u2014 the new method "${method.name}" takes a name this contract retired ("${holder.name}" lists "${id}.${method.name}" in its previousNames). Unsetting that previousNames releases the name.`;
+    }
+  }
+  return void 0;
+}
 function carryUnexpressed(existing, next, expressed) {
   if (!existing) return [];
   const carried = [];
@@ -38603,6 +39763,16 @@ function writeSpec(restatement) {
   const parent = parentRef ? loadSpec(parentRef.kind, parentRef.id) : null;
   const id = restatement.kind === "system" ? "system" : restatement.spec.id;
   const existing = loadSpec(restatement.kind, id);
+  if (!existing && TRACED_KINDS.has(restatement.kind)) {
+    const spec = restatement.spec;
+    const key = restatement.kind === "type" ? qualifiedTypeId(spec) : spec.id;
+    const holder = specIndexRetiredBy(scanAllSpecs({ memberDepth: 0 }), restatement.kind, key);
+    if (holder) {
+      throw new Error(
+        `id-retired: ${restatement.kind} "${spec.id}" is listed in the previousIds of "${holder}", which was renamed from it. Left alone, a consumer holding the old key would read the new spec as the renamed one. Unsetting the holder's previousIds (sdd_update_spec with {"unset": ["previousIds"]}) releases the id, at the cost that such a consumer reads a delete and an add. Nothing was written.`
+      );
+    }
+  }
   const application = applyRestatement(restatement, existing, parent);
   if (application.refusal !== void 0) throw new Error(application.refusal);
   const gateNotices = restatement.kind === "component" ? judgeComponent(application.spec, bound2) : [];
@@ -38672,17 +39842,17 @@ function updateSpecGated(kind, id, delta, dryRun) {
   const testRoots = bound2.rules?.conformance?.testRoots ?? [];
   const stored = loadSpec(kind, id);
   const gate = componentCandidateGate(bound2, stored?.subsystem, stored);
-  const report2 = updateSpec(kind, id, delta, gate, dryRun);
-  const changed = changedMethods(report2);
+  const report3 = updateSpec(kind, id, delta, gate, dryRun);
+  const changed = changedMethods(report3);
   if (changed.length > 0 && testRoots.length > 0) {
     const written = Array.isArray(delta?.methods) ? delta.methods : [];
-    report2.testsToRevisit = testsInvalidatedBy(kind, id, changed, [stored], bound2, written);
+    report3.testsToRevisit = testsInvalidatedBy(kind, id, changed, [stored], bound2, written);
   }
-  return report2;
+  return report3;
 }
-function changedMethods(report2) {
+function changedMethods(report3) {
   const named2 = /* @__PURE__ */ new Set();
-  for (const change of report2.changes) {
+  for (const change of report3.changes) {
     const [field, name] = change.path.split(".");
     if (field === "methods" && name) named2.add(name);
   }
@@ -39473,10 +40643,10 @@ function addPin(ctx, consumer, alias) {
 function planEntry(ctx, producer, ref, table, reason) {
   const target = targetOf(ref);
   if (!target) {
-    return report(ctx, "target-missing", ref, `${ref.specId} names "${ref.target}", but ${label3(producer.namespace)} declares no component, subsystem-owned type or project-level type of that id \u2014 the reference is wrong`);
+    return report2(ctx, "target-missing", ref, `${ref.specId} names "${ref.target}", but ${label3(producer.namespace)} declares no component, subsystem-owned type or project-level type of that id \u2014 the reference is wrong`);
   }
   if (target.kind === "subsystem") {
-    return report(ctx, "subsystem-reference", ref, `${ref.specId} re-exports ${label3(producer.namespace)}'s subsystem "${target.id}" wholesale \u2014 no L0 entry short of exporting it expresses that; rewrite the reference to name the items it uses`);
+    return report2(ctx, "subsystem-reference", ref, `${ref.specId} re-exports ${label3(producer.namespace)}'s subsystem "${target.id}" wholesale \u2014 no L0 entry short of exporting it expresses that; rewrite the reference to name the items it uses`);
   }
   if (target.source === void 0) return decideOwnType(ctx, producer, ref, target, table, reason);
   return decideEntry(ctx, producer, ref, target, table, resolveSubsystemExports(target.source), reason);
@@ -39498,7 +40668,7 @@ function decideOwnType(ctx, producer, ref, target, table, reason) {
   const local = localIn3(producer.namespace, target.id);
   const taken = table.entries.find((e) => e.publicName === local && exportTargetKey(e) !== key) ?? entryOf(ctx, producer).exports.find((e) => e.publicName === local && (e.component ?? e.typeDef) !== local);
   if (taken) {
-    return report(ctx, "name-taken", ref, `"${local}" already names another item in ${label3(producer.namespace)} \u2014 export the type "${target.id}" under a name a person chooses`);
+    return report2(ctx, "name-taken", ref, `"${local}" already names another item in ${label3(producer.namespace)} \u2014 export the type "${target.id}" under a name a person chooses`);
   }
   mergeEntry(entryOf(ctx, producer), target, void 0, local, local, ref, reason);
   return "planned";
@@ -39507,18 +40677,18 @@ function decideEntry(ctx, producer, ref, target, table, published, reason) {
   const key = targetKey(target);
   const at = published.entries.filter((e) => exportTargetKey({ ...e, interface: void 0 }) === key);
   if (at.length === 0) {
-    return report(ctx, "target-unpublished", ref, `"${target.id}" is not in its subsystem's L1 table, so no L0 re-export can follow it \u2014 publish it at L1 first, or the reference is wrong`);
+    return report2(ctx, "target-unpublished", ref, `"${target.id}" is not in its subsystem's L1 table, so no L0 re-export can follow it \u2014 publish it at L1 first, or the reference is wrong`);
   }
   const exported = table.entries.filter((e) => exportTargetKey({ ...e, interface: void 0 }) === key);
   if (exported.length > 0 && reachableThrough(exported, ref)) return "present";
   if (exported.length > 0 || !reachableThrough(at, ref)) {
-    return report(ctx, "narrowed", ref, `"${target.id}" is exported under a narrowing that does not declare "${ref.member ?? "what the reference reaches"}" \u2014 widen the narrowing or reach another member`);
+    return report2(ctx, "narrowed", ref, `"${target.id}" is exported under a narrowing that does not declare "${ref.member ?? "what the reference reaches"}" \u2014 widen the narrowing or reach another member`);
   }
   const local = localIn3(producer.namespace, target.id);
   const publicName = local.split("::").pop();
   const taken = table.entries.find((e) => e.publicName === publicName && exportTargetKey({ ...e, interface: void 0 }) !== key) ?? entryOf(ctx, producer).exports.find((e) => e.publicName === publicName && (e.component ?? e.typeDef) !== local);
   if (taken) {
-    return report(ctx, "name-taken", ref, `"${publicName}" already names another item in ${label3(producer.namespace)} \u2014 export "${target.id}" under a name a person chooses`);
+    return report2(ctx, "name-taken", ref, `"${publicName}" already names another item in ${label3(producer.namespace)} \u2014 export "${target.id}" under a name a person chooses`);
   }
   mergeEntry(entryOf(ctx, producer), target, localIn3(producer.namespace, target.source), local, publicName, ref, reason);
   return "planned";
@@ -39559,7 +40729,7 @@ function addSorted(list, value) {
     list.sort();
   }
 }
-function report(ctx, kind, ref, detail) {
+function report2(ctx, kind, ref, detail) {
   ctx.findings.push({ kind, project: ref.producer, detail, reference: ref, blocking: false });
   return "refused";
 }
@@ -42100,30 +43270,30 @@ function structured(content, data) {
   return { content: [{ type: "text", text: content }], structuredContent: data };
 }
 function migrationTool(request, dryRun) {
-  let report2;
+  let report3;
   try {
-    report2 = run2(request, dryRun);
+    report3 = run2(request, dryRun);
   } catch (e) {
     return errMessage(e);
   }
-  const view = migrationView(report2, dryRun === true);
+  const view = migrationView(report3, dryRun === true);
   const body = JSON.stringify(view, null, 2);
-  if (report2.plan.refusals.length > 0) return errText(`the ${request.verb} migration is refused; nothing was written.
+  if (report3.plan.refusals.length > 0) return errText(`the ${request.verb} migration is refused; nothing was written.
 ${body}`);
-  if (!report2.applied && report2.outcome) {
-    const how = report2.outcome.restored ? "the family was restored exactly as before" : "some files could not be restored: a person must run `wairon doctor --fix` in the project";
-    return errText(`the ${request.verb} migration failed (${report2.outcome.failure ?? "unknown failure"}) and ${how}.
+  if (!report3.applied && report3.outcome) {
+    const how = report3.outcome.restored ? "the family was restored exactly as before" : "some files could not be restored: a person must run `wairon doctor --fix` in the project";
+    return errText(`the ${request.verb} migration failed (${report3.outcome.failure ?? "unknown failure"}) and ${how}.
 ${body}`);
   }
   return structured(body, view);
 }
-function migrationView(report2, dryRun) {
-  const plan6 = report2.plan;
+function migrationView(report3, dryRun) {
+  const plan6 = report3.plan;
   return {
     dryRun,
-    applied: report2.applied,
-    relock: report2.applied ? report2.relock : plan6.relock,
-    ...report2.outcome ? { outcome: { committed: report2.outcome.committed, restored: report2.outcome.restored, unrestored: report2.outcome.unrestored, ...report2.outcome.failure ? { failure: report2.outcome.failure } : {} } } : {},
+    applied: report3.applied,
+    relock: report3.applied ? report3.relock : plan6.relock,
+    ...report3.outcome ? { outcome: { committed: report3.outcome.committed, restored: report3.outcome.restored, unrestored: report3.outcome.unrestored, ...report3.outcome.failure ? { failure: report3.outcome.failure } : {} } } : {},
     plan: {
       verb: plan6.request.verb,
       familyRoot: plan6.familyRoot,
@@ -42139,69 +43309,69 @@ function jsonStructured(value) {
   return structured(JSON.stringify(value, null, 2), value);
 }
 var staleServerOutput = {
-  staleServer: import_zod11.z.boolean().optional().describe(
+  staleServer: import_zod12.z.boolean().optional().describe(
     "True when the wairon build on disk changed after this server started \u2014 the structured twin of the text answer's STALE SERVER banner. When the rebuild left the spec and tool schemas alone, writes still go through; reconnect to run the new code."
   ),
-  writesRefused: import_zod11.z.boolean().optional().describe(
+  writesRefused: import_zod12.z.boolean().optional().describe(
     "True when the rebuild changed a spec or tool schema (or its schemas could not be compared): every spec write through this server is refused and writes nothing, because it would silently drop the fields only the new build knows. The human has to reconnect the server (/mcp reconnect wairon)."
   )
 };
 var externalPinsOutput = {
-  pins: import_zod11.z.array(import_zod11.z.object({
-    alias: import_zod11.z.string(),
-    outcome: import_zod11.z.enum(["pinned", "unchanged", "unresolved", "unreachable"]),
-    project: import_zod11.z.string().optional(),
-    snapshot: import_zod11.z.string().optional(),
-    digest: import_zod11.z.string().optional(),
-    usedNames: import_zod11.z.number(),
-    unexported: import_zod11.z.array(import_zod11.z.record(import_zod11.z.unknown())),
-    detail: import_zod11.z.string().optional()
+  pins: import_zod12.z.array(import_zod12.z.object({
+    alias: import_zod12.z.string(),
+    outcome: import_zod12.z.enum(["pinned", "unchanged", "unresolved", "unreachable"]),
+    project: import_zod12.z.string().optional(),
+    snapshot: import_zod12.z.string().optional(),
+    digest: import_zod12.z.string().optional(),
+    usedNames: import_zod12.z.number(),
+    unexported: import_zod12.z.array(import_zod12.z.record(import_zod12.z.unknown())),
+    detail: import_zod12.z.string().optional()
   })).describe("One outcome per alias pinned, in declaration order, with its unexported references."),
   ...staleServerOutput
 };
 var externalStatusesOutput = {
-  statuses: import_zod11.z.array(import_zod11.z.object({
-    alias: import_zod11.z.string(),
-    project: import_zod11.z.string(),
-    sourceKind: import_zod11.z.string(),
-    pinned: import_zod11.z.boolean(),
-    reachable: import_zod11.z.boolean(),
-    stale: import_zod11.z.boolean(),
-    drifted: import_zod11.z.boolean().optional(),
-    uses: import_zod11.z.array(import_zod11.z.record(import_zod11.z.unknown())),
-    detail: import_zod11.z.string().optional(),
-    outOfReach: import_zod11.z.boolean().optional(),
-    pinnedDigest: import_zod11.z.string().optional().describe("The content digest the lock recorded; provenance, never compared here."),
-    pinnedCommit: import_zod11.z.string().optional().describe("The producer commit the lock recorded, for one in another repository; provenance only.")
+  statuses: import_zod12.z.array(import_zod12.z.object({
+    alias: import_zod12.z.string(),
+    project: import_zod12.z.string(),
+    sourceKind: import_zod12.z.string(),
+    pinned: import_zod12.z.boolean(),
+    reachable: import_zod12.z.boolean(),
+    stale: import_zod12.z.boolean(),
+    drifted: import_zod12.z.boolean().optional(),
+    uses: import_zod12.z.array(import_zod12.z.record(import_zod12.z.unknown())),
+    detail: import_zod12.z.string().optional(),
+    outOfReach: import_zod12.z.boolean().optional(),
+    pinnedDigest: import_zod12.z.string().optional().describe("The content digest the lock recorded; provenance, never compared here."),
+    pinnedCommit: import_zod12.z.string().optional().describe("The producer commit the lock recorded, for one in another repository; provenance only.")
   })).describe("One status per declared external, in declaration order; EXTERNAL_CHECK_UNAVAILABLE marks what could not be compared."),
   ...staleServerOutput
 };
-function renderChangeReport(report2) {
-  const lines = [report2.dryRun ? `DRY RUN \u2014 nothing was written. ${report2.summary}` : report2.summary];
-  for (const change of report2.changes) {
+function renderChangeReport(report3) {
+  const lines = [report3.dryRun ? `DRY RUN \u2014 nothing was written. ${report3.summary}` : report3.summary];
+  for (const change of report3.changes) {
     const to = change.after === void 0 ? "" : `: ${JSON.stringify(change.after)}`;
     const from = change.before === void 0 ? "" : ` (was ${JSON.stringify(change.before)})`;
-    lines.push(`- ${change.path} ${report2.dryRun ? `would be ${change.change}` : change.change}${to}${from}`);
+    lines.push(`- ${change.path} ${report3.dryRun ? `would be ${change.change}` : change.change}${to}${from}`);
   }
-  if (report2.ineffective.length) {
-    lines.push("", "NO EFFECT:", ...report2.ineffective.map((i) => `- ${i}`));
+  if (report3.ineffective.length) {
+    lines.push("", "NO EFFECT:", ...report3.ineffective.map((i) => `- ${i}`));
   }
-  if (report2.notices.length) lines.push("", "NOTICE:", ...report2.notices.map((n) => `- ${n}`));
-  if (report2.strippedKeys?.length) {
-    lines.push("", `DROPPED FROM THE STORED FILE (${report2.dryRun ? "would be " : ""}removed \u2014 the schema does not know them):`, ...report2.strippedKeys.map((k) => `- ${k}`));
+  if (report3.notices.length) lines.push("", "NOTICE:", ...report3.notices.map((n) => `- ${n}`));
+  if (report3.strippedKeys?.length) {
+    lines.push("", `DROPPED FROM THE STORED FILE (${report3.dryRun ? "would be " : ""}removed \u2014 the schema does not know them):`, ...report3.strippedKeys.map((k) => `- ${k}`));
   }
-  lines.push(...renderRespellings(report2.respellings));
-  lines.push(...renderTestsToRevisit(report2.testsToRevisit));
+  lines.push(...renderRespellings(report3.respellings));
+  lines.push(...renderTestsToRevisit(report3.testsToRevisit));
   return lines.join("\n");
 }
 var SPEC_KINDS = ["system", "subsystem", "component", "interface", "implementation", "type"];
 var STATUS_VALUES = ["draft", "design", "complete"];
-var testsToRevisitOutput = import_zod11.z.array(import_zod11.z.object({
-  method: import_zod11.z.string().describe("The contract method this write changed or deleted."),
-  symbol: import_zod11.z.string().describe("The code-level name searched for: the method's `symbol` when it declares one, else its name."),
-  imported: import_zod11.z.array(import_zod11.z.string()).describe("Test files that IMPORT that symbol \u2014 the high-confidence list, because an import is a binding and not a coincidence."),
-  mentioned: import_zod11.z.array(import_zod11.z.string()).describe("Test files that name the symbol without importing it \u2014 usually a test driving it through a portal. Empty when `indiscriminate` is true."),
-  indiscriminate: import_zod11.z.boolean().describe("True when the bare name matched more than a tenth of the test suite, so the mention list was withheld as noise.")
+var testsToRevisitOutput = import_zod12.z.array(import_zod12.z.object({
+  method: import_zod12.z.string().describe("The contract method this write changed or deleted."),
+  symbol: import_zod12.z.string().describe("The code-level name searched for: the method's `symbol` when it declares one, else its name."),
+  imported: import_zod12.z.array(import_zod12.z.string()).describe("Test files that IMPORT that symbol \u2014 the high-confidence list, because an import is a binding and not a coincidence."),
+  mentioned: import_zod12.z.array(import_zod12.z.string()).describe("Test files that name the symbol without importing it \u2014 usually a test driving it through a portal. Empty when `indiscriminate` is true."),
+  indiscriminate: import_zod12.z.boolean().describe("True when the bare name matched more than a tenth of the test suite, so the mention list was withheld as noise.")
 })).describe(
   "The tests that encode a method this write changed or deleted, one entry per such method. Empty when the write touched no method, when the project declares no `rules.conformance.testRoots`, or when nothing references them. Read it before promising that existing tests still pass."
 );
@@ -42218,31 +43388,31 @@ function renderTestsToRevisit(entries) {
   }
   return lines;
 }
-var typeRespellingOutput = import_zod11.z.object({
-  specId: import_zod11.z.string().describe("The interface or type holding the position."),
-  kind: import_zod11.z.enum(["interface", "type"]).describe("interface | type."),
-  path: import_zod11.z.string().describe("Where in the spec: methods.save.params.key, methods.save.returns, fields.createdAt, params.listener."),
-  written: import_zod11.z.string().describe("The text the input (or the stored file) held."),
-  stored: import_zod11.z.string().describe("The canonical spelling, which is what is stored and shown.")
+var typeRespellingOutput = import_zod12.z.object({
+  specId: import_zod12.z.string().describe("The interface or type holding the position."),
+  kind: import_zod12.z.enum(["interface", "type"]).describe("interface | type."),
+  path: import_zod12.z.string().describe("Where in the spec: methods.save.params.key, methods.save.returns, fields.createdAt, params.listener."),
+  written: import_zod12.z.string().describe("The text the input (or the stored file) held."),
+  stored: import_zod12.z.string().describe("The canonical spelling, which is what is stored and shown.")
 });
 function renderRespellings(entries) {
   if (!entries.length) return [];
   return ["", "RESPELLED (stored canonical):", ...entries.map((r) => `- ${r.path}: "${r.written}" \u2192 "${r.stored}"`)];
 }
 var specWriteReceiptOutput = {
-  kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind written."),
-  id: import_zod11.z.string().describe('The id the spec is stored under; "system" for the L0 singleton.'),
-  name: import_zod11.z.string().describe("The spec's display name as written."),
-  replacedExisting: import_zod11.z.boolean().describe(
+  kind: import_zod12.z.enum(SPEC_KINDS).describe("The spec kind written."),
+  id: import_zod12.z.string().describe('The id the spec is stored under; "system" for the L0 singleton.'),
+  name: import_zod12.z.string().describe("The spec's display name as written."),
+  replacedExisting: import_zod12.z.boolean().describe(
     "True when a spec already held this id and the call re-authored it in place rather than adding one. The notices then say what was carried forward, removed or cleared by the restatement."
   ),
-  status: import_zod11.z.enum(STATUS_VALUES).optional().describe(
+  status: import_zod12.z.enum(STATUS_VALUES).optional().describe(
     "The lifecycle status written. Absent for the L0 and a type, which carry none."
   ),
-  notices: import_zod11.z.array(import_zod11.z.string()).describe(
+  notices: import_zod12.z.array(import_zod12.z.string()).describe(
     "The notice lines the text answer lists, one per entry: what was carried forward, what a restatement removed, what an omission cleared, and every gate warning the write raised. Empty for a clean create."
   ),
-  respellings: import_zod11.z.array(typeRespellingOutput).describe(
+  respellings: import_zod12.z.array(typeRespellingOutput).describe(
     "Each type position the write normalised: what the input wrote against the canonical spelling stored. Aliases are accepted, never refused, and this list is how an author learns the canonical form. Empty when every position was already canonical."
   ),
   testsToRevisit: testsToRevisitOutput,
@@ -42260,86 +43430,86 @@ ${respelledBlock}` : ""}${testsBlock ? `
 ${testsBlock}` : ""}`, receipt);
 }
 var specDeletionOutput = {
-  kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind deleted."),
-  id: import_zod11.z.string().describe("The id the spec was stored under."),
-  deleted: import_zod11.z.boolean().describe("True when a spec document was removed."),
+  kind: import_zod12.z.enum(SPEC_KINDS).describe("The spec kind deleted."),
+  id: import_zod12.z.string().describe("The id the spec was stored under."),
+  deleted: import_zod12.z.boolean().describe("True when a spec document was removed."),
   testsToRevisit: testsToRevisitOutput,
   ...staleServerOutput
 };
 var specChangeOutput = {
-  path: import_zod11.z.string().describe("The dotted path the change addresses, with names and indexes."),
-  change: import_zod11.z.enum(["set", "added", "removed", "cleared", "renumbered", "relocated"]).describe(
+  path: import_zod12.z.string().describe("The dotted path the change addresses, with names and indexes."),
+  change: import_zod12.z.enum(["set", "added", "removed", "cleared", "renumbered", "relocated"]).describe(
     "What happened at that path. A narrative is compared by step identity: `renumbered` is a run of unchanged steps shifted by an insert or delete (before/after name the ranges), `relocated` a jump field that followed its target to the target's new number."
   ),
-  before: import_zod11.z.string().optional().describe("The previous value, summarized; absent when there was none."),
-  after: import_zod11.z.string().optional().describe("The new value, summarized; absent when there is none.")
+  before: import_zod12.z.string().optional().describe("The previous value, summarized; absent when there was none."),
+  after: import_zod12.z.string().optional().describe("The new value, summarized; absent when there is none.")
 };
 var specChangeReportOutput = {
-  kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind written."),
-  id: import_zod11.z.string().describe("The stored spec's id."),
-  written: import_zod11.z.boolean().describe("False when the merged spec equals what is stored: nothing reached disk."),
-  dryRun: import_zod11.z.boolean().describe(
+  kind: import_zod12.z.enum(SPEC_KINDS).describe("The spec kind written."),
+  id: import_zod12.z.string().describe("The stored spec's id."),
+  written: import_zod12.z.boolean().describe("False when the merged spec equals what is stored: nothing reached disk."),
+  dryRun: import_zod12.z.boolean().describe(
     "True when the caller asked what the delta WOULD do. `written` is false for a dry run exactly as it is for a delta that changed nothing, and only this field tells the two apart."
   ),
-  changes: import_zod11.z.array(import_zod11.z.object(specChangeOutput)).describe(
+  changes: import_zod12.z.array(import_zod12.z.object(specChangeOutput)).describe(
     "Every change the write made; empty exactly when `written` is false."
   ),
-  ineffective: import_zod11.z.array(import_zod11.z.string()).describe(
+  ineffective: import_zod12.z.array(import_zod12.z.string()).describe(
     "Every path the delta named that the write did not act on, each with why. Read it: a nested typo the permissive delta cannot refuse shows up here and nowhere else."
   ),
-  notices: import_zod11.z.array(import_zod11.z.string()).describe("Store placement notices, gate warnings and delta notices."),
-  respellings: import_zod11.z.array(typeRespellingOutput).describe(
+  notices: import_zod12.z.array(import_zod12.z.string()).describe("Store placement notices, gate warnings and delta notices."),
+  respellings: import_zod12.z.array(typeRespellingOutput).describe(
     "Each type position the write normalised (or, on a dry run, would): what the delta or the stored file wrote against the canonical spelling stored. Aliases are accepted and respelled, never refused \u2014 this is how the canonical form is taught. Empty when every position was already canonical."
   ),
-  summary: import_zod11.z.string().describe("One line for people."),
+  summary: import_zod12.z.string().describe("One line for people."),
   testsToRevisit: testsToRevisitOutput,
-  strippedKeys: import_zod11.z.array(import_zod11.z.string()).optional().describe(
+  strippedKeys: import_zod12.z.array(import_zod12.z.string()).optional().describe(
     "Keys the stored file carries that the level's schema does not know, each as `path: value`, which this write drops (or, on a dry run, would drop). Absent when there are none."
   ),
   ...staleServerOutput
 };
 var validationIssueOutput = {
-  severity: import_zod11.z.enum(["error", "warning", "notice"]).describe("The finding's severity after project overrides."),
-  code: import_zod11.z.string().describe("The rule code, UPPER_SNAKE \u2014 the stable handle to filter and suppress by."),
-  message: import_zod11.z.string().describe("What is wrong, named."),
-  agentId: import_zod11.z.string().optional().describe("The agent the finding concerns, when it concerns one."),
-  specId: import_zod11.z.string().optional().describe("The spec the finding concerns, when it concerns one."),
-  draftContext: import_zod11.z.boolean().optional().describe(
+  severity: import_zod12.z.enum(["error", "warning", "notice"]).describe("The finding's severity after project overrides."),
+  code: import_zod12.z.string().describe("The rule code, UPPER_SNAKE \u2014 the stable handle to filter and suppress by."),
+  message: import_zod12.z.string().describe("What is wrong, named."),
+  agentId: import_zod12.z.string().optional().describe("The agent the finding concerns, when it concerns one."),
+  specId: import_zod12.z.string().optional().describe("The spec the finding concerns, when it concerns one."),
+  draftContext: import_zod12.z.boolean().optional().describe(
     "True when the finding was raised against a draft/design spec \u2014 what the --ci gate waives."
   ),
-  resolution: import_zod11.z.object({
-    outcome: import_zod11.z.enum(["resolved", "missing", "ambiguous", "unavailable", "forbidden"]).describe("How the owner's gate resolved the reference, decided before the severity."),
-    owner: import_zod11.z.string().describe("The referring project's id: the one project whose gate judges the reference."),
-    callSite: import_zod11.z.string().describe("Where the reference is written: the referring spec and the position in it."),
-    canonicalTarget: import_zod11.z.string().optional().describe("The target in producer-id form, `<producer id>::<public name>`."),
-    inputDigest: import_zod11.z.string().optional().describe("The digest of the input the reference was judged against (a pin, or a member's live table)."),
-    reason: import_zod11.z.string().describe("One sentence saying why the outcome is what it is."),
-    importedVia: import_zod11.z.string().optional().describe("For a bare name resolved through a `use` import: the alias that supplied it.")
+  resolution: import_zod12.z.object({
+    outcome: import_zod12.z.enum(["resolved", "missing", "ambiguous", "unavailable", "forbidden"]).describe("How the owner's gate resolved the reference, decided before the severity."),
+    owner: import_zod12.z.string().describe("The referring project's id: the one project whose gate judges the reference."),
+    callSite: import_zod12.z.string().describe("Where the reference is written: the referring spec and the position in it."),
+    canonicalTarget: import_zod12.z.string().optional().describe("The target in producer-id form, `<producer id>::<public name>`."),
+    inputDigest: import_zod12.z.string().optional().describe("The digest of the input the reference was judged against (a pin, or a member's live table)."),
+    reason: import_zod12.z.string().describe("One sentence saying why the outcome is what it is."),
+    importedVia: import_zod12.z.string().optional().describe("For a bare name resolved through a `use` import: the alias that supplied it.")
   }).optional().describe(
     "On a finding about a cross-project reference: how the owner's gate resolved it, decided before the severity."
   ),
-  project: import_zod11.z.string().optional().describe(
+  project: import_zod12.z.string().optional().describe(
     "In a family run: the key of the project whose gate the finding belongs to ('' for the family root)."
   )
 };
 var memberCreationOutput = {
-  configCreated: import_zod11.z.boolean().describe("Whether this call created the member's configuration; only then were the declaring project's required packs scaffolded."),
-  adopted: import_zod11.z.array(import_zod11.z.object({
-    name: import_zod11.z.string(),
-    version: import_zod11.z.string().optional(),
-    integrity: import_zod11.z.string().optional(),
-    source: import_zod11.z.string().optional(),
-    bundle: import_zod11.z.boolean().optional()
+  configCreated: import_zod12.z.boolean().describe("Whether this call created the member's configuration; only then were the declaring project's required packs scaffolded."),
+  adopted: import_zod12.z.array(import_zod12.z.object({
+    name: import_zod12.z.string(),
+    version: import_zod12.z.string().optional(),
+    integrity: import_zod12.z.string().optional(),
+    source: import_zod12.z.string().optional(),
+    bundle: import_zod12.z.boolean().optional()
   })).describe("The selections written into the new member's extensions.packs, each pinned to the highest installed version its requirement admits."),
-  unadopted: import_zod11.z.array(import_zod11.z.object({
-    pack: import_zod11.z.string(),
-    version: import_zod11.z.string(),
-    profile: import_zod11.z.string().optional()
+  unadopted: import_zod12.z.array(import_zod12.z.object({
+    pack: import_zod12.z.string(),
+    version: import_zod12.z.string(),
+    profile: import_zod12.z.string().optional()
   })).describe("Requirements no installed version satisfies: nothing was written for them, and the next family run reports each as POLICY_NOT_ADOPTED."),
-  projectType: import_zod11.z.string().optional().describe("The profile written as the new member's projectType, when exactly one adopted requirement names one."),
-  as: import_zod11.z.string().describe("part | project: what was created (stage 8; a part by default)."),
-  storage: import_zod11.z.string().describe("contained | path | git: where its files live."),
-  commit: import_zod11.z.string().optional().describe("git: the commit the member was pinned at."),
+  projectType: import_zod12.z.string().optional().describe("The profile written as the new member's projectType, when exactly one adopted requirement names one."),
+  as: import_zod12.z.string().describe("part | project: what was created (stage 8; a part by default)."),
+  storage: import_zod12.z.string().describe("contained | path | git: where its files live."),
+  commit: import_zod12.z.string().optional().describe("git: the commit the member was pinned at."),
   ...staleServerOutput
 };
 function describeMemberPacks(creation) {
@@ -42354,36 +43524,36 @@ function describeMemberPacks(creation) {
   }
   return parts.join("");
 }
-var doctrineChangeOutput = import_zod11.z.object({
-  axis: import_zod11.z.enum(["rule", "concept"]),
-  change: import_zod11.z.string().describe("loosened | raised | off | added | depth | inert | redefined | removed | discouraged | licensed | gated \u2014 stated, never judged."),
-  subject: import_zod11.z.string(),
-  profile: import_zod11.z.string().optional(),
-  from: import_zod11.z.string().optional(),
-  to: import_zod11.z.string().optional(),
-  reason: import_zod11.z.string().optional()
+var doctrineChangeOutput = import_zod12.z.object({
+  axis: import_zod12.z.enum(["rule", "concept"]),
+  change: import_zod12.z.string().describe("loosened | raised | off | added | depth | inert | redefined | removed | discouraged | licensed | gated \u2014 stated, never judged."),
+  subject: import_zod12.z.string(),
+  profile: import_zod12.z.string().optional(),
+  from: import_zod12.z.string().optional(),
+  to: import_zod12.z.string().optional(),
+  reason: import_zod12.z.string().optional()
 });
-var impactTotalsOutput = import_zod11.z.object({
-  key: import_zod11.z.string(),
-  id: import_zod11.z.string().optional(),
-  directory: import_zod11.z.string(),
-  valid: import_zod11.z.boolean(),
-  errors: import_zod11.z.number(),
-  warnings: import_zod11.z.number(),
-  notices: import_zod11.z.number()
+var impactTotalsOutput = import_zod12.z.object({
+  key: import_zod12.z.string(),
+  id: import_zod12.z.string().optional(),
+  directory: import_zod12.z.string(),
+  valid: import_zod12.z.boolean(),
+  errors: import_zod12.z.number(),
+  warnings: import_zod12.z.number(),
+  notices: import_zod12.z.number()
 });
 var packImpactOutput = {
-  pack: import_zod11.z.string().describe("The pack measured."),
-  version: import_zod11.z.string().optional().describe("The version the candidate resolves to; absent for an unversioned pack."),
-  replaces: import_zod11.z.string().optional().describe("The version applied now under the same name, when the selection would replace it."),
-  direction: import_zod11.z.enum(["apply", "remove"]).describe("remove when the pack is already applied exactly as asked: the findings then read as what the pack accounts for now."),
-  doctrine: import_zod11.z.array(doctrineChangeOutput).describe("The pack's changes against wairon's defaults. Nothing in it is a finding."),
-  previousDoctrine: import_zod11.z.array(doctrineChangeOutput).optional().describe("On an update: the replaced version's changes against the same defaults."),
-  governing: import_zod11.z.array(import_zod11.z.string()).describe("The pack's profiles that would govern something in this project."),
-  findings: import_zod11.z.object({
-    introduced: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)),
-    resolved: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)),
-    regraded: import_zod11.z.array(import_zod11.z.object({ finding: import_zod11.z.object(validationIssueOutput), from: import_zod11.z.string() }))
+  pack: import_zod12.z.string().describe("The pack measured."),
+  version: import_zod12.z.string().optional().describe("The version the candidate resolves to; absent for an unversioned pack."),
+  replaces: import_zod12.z.string().optional().describe("The version applied now under the same name, when the selection would replace it."),
+  direction: import_zod12.z.enum(["apply", "remove"]).describe("remove when the pack is already applied exactly as asked: the findings then read as what the pack accounts for now."),
+  doctrine: import_zod12.z.array(doctrineChangeOutput).describe("The pack's changes against wairon's defaults. Nothing in it is a finding."),
+  previousDoctrine: import_zod12.z.array(doctrineChangeOutput).optional().describe("On an update: the replaced version's changes against the same defaults."),
+  governing: import_zod12.z.array(import_zod12.z.string()).describe("The pack's profiles that would govern something in this project."),
+  findings: import_zod12.z.object({
+    introduced: import_zod12.z.array(import_zod12.z.object(validationIssueOutput)),
+    resolved: import_zod12.z.array(import_zod12.z.object(validationIssueOutput)),
+    regraded: import_zod12.z.array(import_zod12.z.object({ finding: import_zod12.z.object(validationIssueOutput), from: import_zod12.z.string() }))
   }).describe("The owner's-gate findings that differ between the current and the candidate configuration."),
   before: impactTotalsOutput.describe("The current configuration's totals."),
   after: impactTotalsOutput.describe("The candidate configuration's totals."),
@@ -42417,57 +43587,57 @@ function pendingBanner() {
   }
 }
 var validateTreeOutput = {
-  valid: import_zod11.z.boolean().describe("False when the tree holds at least one error; warnings and notices never make it false."),
-  errors: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)).describe("Every finding of severity error."),
-  warnings: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)).describe("Every finding of severity warning."),
-  notices: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)).describe(
+  valid: import_zod12.z.boolean().describe("False when the tree holds at least one error; warnings and notices never make it false."),
+  errors: import_zod12.z.array(import_zod12.z.object(validationIssueOutput)).describe("Every finding of severity error."),
+  warnings: import_zod12.z.array(import_zod12.z.object(validationIssueOutput)).describe("Every finding of severity warning."),
+  notices: import_zod12.z.array(import_zod12.z.object(validationIssueOutput)).describe(
     "Every finding of severity notice: reported, never a failure \u2014 they never make the tree invalid and never fail `wairon validate --ci`."
   ),
-  hint: import_zod11.z.string().optional().describe(
+  hint: import_zod12.z.string().optional().describe(
     "The owner's gate: present when the project declares externals \u2014 they were judged against their pins alone, and `wairon validate --family` composes them against their live producers. A family run: present when externals were left out because their producers lie outside the run's reach."
   ),
-  projects: import_zod11.z.array(import_zod11.z.object({
-    key: import_zod11.z.string().describe("The project's key in the family root's scan ('' for the root itself)."),
-    id: import_zod11.z.string().optional().describe("The project's effective id."),
-    directory: import_zod11.z.string().describe("The project's root directory."),
-    valid: import_zod11.z.boolean().describe("Whether its own gate found no error."),
-    errors: import_zod11.z.number().describe("Its own gate's error count."),
-    warnings: import_zod11.z.number().describe("Its own gate's warning count."),
-    notices: import_zod11.z.number().describe("Its own gate's notice count.")
+  projects: import_zod12.z.array(import_zod12.z.object({
+    key: import_zod12.z.string().describe("The project's key in the family root's scan ('' for the root itself)."),
+    id: import_zod12.z.string().optional().describe("The project's effective id."),
+    directory: import_zod12.z.string().describe("The project's root directory."),
+    valid: import_zod12.z.boolean().describe("Whether its own gate found no error."),
+    errors: import_zod12.z.number().describe("Its own gate's error count."),
+    warnings: import_zod12.z.number().describe("Its own gate's warning count."),
+    notices: import_zod12.z.number().describe("Its own gate's notice count.")
   })).optional().describe(
     "A family run only: one line per selected project (the root first) with its own gate's totals. Absent on the owner's gate."
   ),
   ...staleServerOutput
 };
 var getSpecOutput = {
-  kind: import_zod11.z.enum(SPEC_KINDS).describe("The kind of spec read."),
-  id: import_zod11.z.string().describe("The id it was read by."),
-  spec: import_zod11.z.record(import_zod11.z.unknown()).describe(
+  kind: import_zod12.z.enum(SPEC_KINDS).describe("The kind of spec read."),
+  id: import_zod12.z.string().describe("The id it was read by."),
+  spec: import_zod12.z.record(import_zod12.z.unknown()).describe(
     "The stored spec, exactly as the text block renders it \u2014 minus the two derived markers below, which the text folds in and this answer keeps separate so nothing derived can be mistaken for stored."
   ),
-  partialResult: import_zod11.z.object({
-    shown: import_zod11.z.array(import_zod11.z.string()).describe("The method names this answer carries."),
-    omitted: import_zod11.z.number().describe("How many of the spec's methods are NOT in it."),
-    warning: import_zod11.z.string().describe("Why it must never be re-authored from.")
+  partialResult: import_zod12.z.object({
+    shown: import_zod12.z.array(import_zod12.z.string()).describe("The method names this answer carries."),
+    omitted: import_zod12.z.number().describe("How many of the spec's methods are NOT in it."),
+    warning: import_zod12.z.string().describe("Why it must never be re-authored from.")
   }).optional().describe(
     "Present only when `methods` filtered the read. A filtered spec is a partial one: sdd_define_interface and sdd_write_narrative REPLACE the method list, so re-authoring from it would delete every method left out."
   ),
-  variantGuidance: import_zod11.z.object({
-    variant: import_zod11.z.string().describe("The variant id the component declares."),
-    base: import_zod11.z.string().describe("The core stereotype it specializes."),
-    guidance: import_zod11.z.string().describe("How to implement a component of this variant."),
-    siblings: import_zod11.z.array(import_zod11.z.string()).describe("Other components of the same variant, to implement alike."),
-    target: import_zod11.z.string().optional().describe("The target language the variant scopes itself to, if any."),
-    profile: import_zod11.z.string().optional().describe("The architectural profile it scopes itself to, if any.")
+  variantGuidance: import_zod12.z.object({
+    variant: import_zod12.z.string().describe("The variant id the component declares."),
+    base: import_zod12.z.string().describe("The core stereotype it specializes."),
+    guidance: import_zod12.z.string().describe("How to implement a component of this variant."),
+    siblings: import_zod12.z.array(import_zod12.z.string()).describe("Other components of the same variant, to implement alike."),
+    target: import_zod12.z.string().optional().describe("The target language the variant scopes itself to, if any."),
+    profile: import_zod12.z.string().optional().describe("The architectural profile it scopes itself to, if any.")
   }).optional().describe(
     "Derived, read-only guidance for a variant-tagged component \u2014 resolved from the variant registry, not part of the spec. Never write it back."
   ),
-  resolvedSignatures: import_zod11.z.array(import_zod11.z.object({
-    method: import_zod11.z.string().describe("The contract method that takes its signature from a source."),
-    signatureFrom: import_zod11.z.string().describe("The source it names, as the spec holds it."),
-    signature: import_zod11.z.string().describe("The text it shows, derived from the resolved params and returns."),
-    params: import_zod11.z.array(import_zod11.z.record(import_zod11.z.unknown())).optional().describe("The params the source supplies; absent when it supplies none (unresolved, ambiguous or chained)."),
-    returns: import_zod11.z.string().describe("The returns the source supplies (`unknown` when it supplies none).")
+  resolvedSignatures: import_zod12.z.array(import_zod12.z.object({
+    method: import_zod12.z.string().describe("The contract method that takes its signature from a source."),
+    signatureFrom: import_zod12.z.string().describe("The source it names, as the spec holds it."),
+    signature: import_zod12.z.string().describe("The text it shows, derived from the resolved params and returns."),
+    params: import_zod12.z.array(import_zod12.z.record(import_zod12.z.unknown())).optional().describe("The params the source supplies; absent when it supplies none (unresolved, ambiguous or chained)."),
+    returns: import_zod12.z.string().describe("The returns the source supplies (`unknown` when it supplies none).")
   })).optional().describe(
     "Derived, read-only: for a contract whose methods take their signature from a source, each such method's RESOLVED params, returns and text. The spec carries those methods in stored form (the signatureFrom alone) so it can be re-authored from as it is; never write these back beside the source."
   ),
@@ -42630,6 +43800,7 @@ var SPEC_WRITE_TOOLS = /* @__PURE__ */ new Set([
   "sdd_rename_member_alias",
   "sdd_rename_component",
   "sdd_rename_method",
+  "sdd_rename_type",
   "sdd_add_component",
   "sdd_define_interface",
   "sdd_set_endpoints",
@@ -42651,10 +43822,10 @@ function reg(server, name, config, cb) {
     if (result.isError !== true && SPEC_WRITE_TOOLS.has(name)) listChangedEmitters.get(server)?.();
     return result;
   };
-  const strictConfig = config.inputSchema ? { ...config, inputSchema: import_zod11.z.object(config.inputSchema).strict() } : config;
+  const strictConfig = config.inputSchema ? { ...config, inputSchema: import_zod12.z.object(config.inputSchema).strict() } : config;
   server.registerTool(name, strictConfig, guarded2);
 }
-var statusInput = import_zod11.z.enum(STATUS_VALUES).optional().describe(
+var statusInput = import_zod12.z.enum(STATUS_VALUES).optional().describe(
   "The spec's lifecycle status. Omitted means draft for a NEW spec and the status already stored for a re-authoring, so a restatement never reopens a frozen spec. State it to author straight at design or complete instead of promoting afterwards. A status that would LOWER the stored one is refused \u2014 reopening a spec for revision is sdd_update_spec's job, which sets the demotion deliberately."
 );
 function createBareMcpServer(options = {}) {
@@ -42681,7 +43852,7 @@ function createBareMcpServer(options = {}) {
     "listAgents",
     {
       description: "List all AI agents registered in this project. Returns id, name, description, domainRoot, template, tags, and status for each agent. Filter by domainId to scope to one domain.",
-      inputSchema: { domainId: import_zod11.z.string().optional() }
+      inputSchema: { domainId: import_zod12.z.string().optional() }
     },
     ({ domainId }) => {
       try {
@@ -42706,7 +43877,7 @@ function createBareMcpServer(options = {}) {
     "getAgent",
     {
       description: "Get full details of a specific agent by id, including ownership rules, context, and output targets.",
-      inputSchema: { id: import_zod11.z.string() }
+      inputSchema: { id: import_zod12.z.string() }
     },
     ({ id }) => {
       try {
@@ -42739,7 +43910,7 @@ function createBareMcpServer(options = {}) {
     {
       description: "Validate the project's agent topology. Returns errors, warnings and notices (duplicate ids, overlapping ownership, missing paths, etc.). Supports optional subsystem scoping.",
       inputSchema: {
-        subsystem: import_zod11.z.string().optional().describe("Only validate topology for agents under the specified subsystem")
+        subsystem: import_zod12.z.string().optional().describe("Only validate topology for agents under the specified subsystem")
       }
     },
     ({ subsystem }) => {
@@ -42782,11 +43953,11 @@ function createBareMcpServer(options = {}) {
     }
   );
   const systemInput = {
-    name: import_zod11.z.string().describe("Overarching name of the project/system"),
-    vision: import_zod11.z.string().describe("Vision, mission, and core goals of the system"),
-    boundaries: import_zod11.z.array(import_zod11.z.union([import_zod11.z.string(), import_zod11.z.object({ name: import_zod11.z.string(), description: import_zod11.z.string().optional() }).strict()])).optional().describe("System boundary rules or scope statements (strings or name/description objects)"),
-    globalRequirements: import_zod11.z.array(import_zod11.z.union([import_zod11.z.string(), import_zod11.z.object({ description: import_zod11.z.string() }).strict()])).optional().describe("Global functional and non-functional requirements (strings or description objects)"),
-    targetLanguage: import_zod11.z.string().optional().describe('Default implementation language for the system (e.g. "typescript", "rust", "python"). Subsystems may override. Enables language-aware validation.')
+    name: import_zod12.z.string().describe("Overarching name of the project/system"),
+    vision: import_zod12.z.string().describe("Vision, mission, and core goals of the system"),
+    boundaries: import_zod12.z.array(import_zod12.z.union([import_zod12.z.string(), import_zod12.z.object({ name: import_zod12.z.string(), description: import_zod12.z.string().optional() }).strict()])).optional().describe("System boundary rules or scope statements (strings or name/description objects)"),
+    globalRequirements: import_zod12.z.array(import_zod12.z.union([import_zod12.z.string(), import_zod12.z.object({ description: import_zod12.z.string() }).strict()])).optional().describe("Global functional and non-functional requirements (strings or description objects)"),
+    targetLanguage: import_zod12.z.string().optional().describe('Default implementation language for the system (e.g. "typescript", "rust", "python"). Subsystems may override. Enables language-aware validation.')
   };
   const systemInputFields = Object.keys(systemInput);
   reg(
@@ -42820,34 +43991,34 @@ function createBareMcpServer(options = {}) {
       }
     }
   );
-  const publicInterfaceItemInput = import_zod11.z.object({
-    type: import_zod11.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]).optional().describe("Transport kind of an own item (required on an own component item); a re-export inherits its target's"),
-    details: import_zod11.z.string().optional().describe("Consumer-facing description of an own item (required on an own component item); a re-export inherits its target's"),
-    component: import_zod11.z.string().optional().describe("For an own item, the L2 component that realizes it (this subsystem's published surface); for a re-export, the component re-exported from `from`"),
-    interface: import_zod11.z.string().optional().describe("Optional L3 interface id the entry narrows to"),
-    consumers: import_zod11.z.array(import_zod11.z.string()).optional().describe("The subsystem ids this surface is published to. Absent, any subsystem may depend on the component; present, only these may \u2014 when every entry publishing the component names consumers, the union of the lists is the whole set, and a dependency from any other subsystem is CROSS_SUBSYSTEM_UNLISTED_CONSUMER. Every id must name a subsystem of the tree (PUBLIC_INTERFACE_UNKNOWN_CONSUMER)."),
-    from: import_zod11.z.string().optional().describe("Re-export source: another subsystem of this project. With neither component nor typeDef, the entry re-exports everything that subsystem exports (a wildcard)"),
-    typeDef: import_zod11.z.string().optional().describe("A type exported as is: owned by this subsystem, or re-exported from `from`"),
-    as: import_zod11.z.string().optional().describe("The public name; defaults to the narrowed interface, then the component or type id. Must fit [a-z0-9-_]+ (EXPORT_INVALID otherwise)")
+  const publicInterfaceItemInput = import_zod12.z.object({
+    type: import_zod12.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]).optional().describe("Transport kind of an own item (required on an own component item); a re-export inherits its target's"),
+    details: import_zod12.z.string().optional().describe("Consumer-facing description of an own item (required on an own component item); a re-export inherits its target's"),
+    component: import_zod12.z.string().optional().describe("For an own item, the L2 component that realizes it (this subsystem's published surface); for a re-export, the component re-exported from `from`"),
+    interface: import_zod12.z.string().optional().describe("Optional L3 interface id the entry narrows to"),
+    consumers: import_zod12.z.array(import_zod12.z.string()).optional().describe("The subsystem ids this surface is published to. Absent, any subsystem may depend on the component; present, only these may \u2014 when every entry publishing the component names consumers, the union of the lists is the whole set, and a dependency from any other subsystem is CROSS_SUBSYSTEM_UNLISTED_CONSUMER. Every id must name a subsystem of the tree (PUBLIC_INTERFACE_UNKNOWN_CONSUMER)."),
+    from: import_zod12.z.string().optional().describe("Re-export source: another subsystem of this project. With neither component nor typeDef, the entry re-exports everything that subsystem exports (a wildcard)"),
+    typeDef: import_zod12.z.string().optional().describe("A type exported as is: owned by this subsystem, or re-exported from `from`"),
+    as: import_zod12.z.string().optional().describe("The public name; defaults to the narrowed interface, then the component or type id. Must fit [a-z0-9-_]+ (EXPORT_INVALID otherwise)")
   }).strict();
   const subsystemInput = {
-    id: import_zod11.z.string().describe("Lowercase identifier for the subsystem"),
-    name: import_zod11.z.string().describe("Human-readable display name"),
-    description: import_zod11.z.string().describe("Purpose and details of the subsystem"),
-    publicInterfaces: import_zod11.z.array(publicInterfaceItemInput).optional().describe("The subsystem's export table: its own entrypoints, each bound to a realizing component, and re-exports of what other subsystems of this project export"),
-    projectPath: import_zod11.z.string().optional().describe("REFUSED: the legacy L1 mount form. A subsystem is never a mount \u2014 declare a member project with sdd_add_member instead"),
-    targetLanguage: import_zod11.z.string().optional().describe("Override of the system-level targetLanguage for this subsystem"),
-    profile: import_zod11.z.string().optional().describe("Architectural profile override for this subsystem (built-ins: backend, frontend-reactive, frontend-controller, lowlevel-os, game-ecs, realtime-embedded, plc-cyclic; extension packs may add more \u2014 unknown names get UNKNOWN_PROFILE)"),
-    designDepth: import_zod11.z.enum(["components", "interfaces", "implementations", "narratives"]).optional().describe("How deep THIS subsystem commits to designing (overrides project rules.designDepth; default narratives = full depth). Expectation checks below the depth are gated \u2014 soundness of authored content always applies."),
-    trustedLinks: import_zod11.z.array(import_zod11.z.object({
-      subsystem: import_zod11.z.string().describe("Peer subsystem id"),
-      reason: import_zod11.z.string().describe('Why the coupling is sanctioned (e.g. "dispatch latency fast lane")')
+    id: import_zod12.z.string().describe("Lowercase identifier for the subsystem"),
+    name: import_zod12.z.string().describe("Human-readable display name"),
+    description: import_zod12.z.string().describe("Purpose and details of the subsystem"),
+    publicInterfaces: import_zod12.z.array(publicInterfaceItemInput).optional().describe("The subsystem's export table: its own entrypoints, each bound to a realizing component, and re-exports of what other subsystems of this project export"),
+    projectPath: import_zod12.z.string().optional().describe("REFUSED: the legacy L1 mount form. A subsystem is never a mount \u2014 declare a member project with sdd_add_member instead"),
+    targetLanguage: import_zod12.z.string().optional().describe("Override of the system-level targetLanguage for this subsystem"),
+    profile: import_zod12.z.string().optional().describe("Architectural profile override for this subsystem (built-ins: backend, frontend-reactive, frontend-controller, lowlevel-os, game-ecs, realtime-embedded, plc-cyclic; extension packs may add more \u2014 unknown names get UNKNOWN_PROFILE)"),
+    designDepth: import_zod12.z.enum(["components", "interfaces", "implementations", "narratives"]).optional().describe("How deep THIS subsystem commits to designing (overrides project rules.designDepth; default narratives = full depth). Expectation checks below the depth are gated \u2014 soundness of authored content always applies."),
+    trustedLinks: import_zod12.z.array(import_zod12.z.object({
+      subsystem: import_zod12.z.string().describe("Peer subsystem id"),
+      reason: import_zod12.z.string().describe('Why the coupling is sanctioned (e.g. "dispatch latency fast lane")')
     }).strict()).optional().describe("Sanctioned tight couplings with peers \u2014 required to acknowledge a mutual subsystem dependency; the Adapter \u2192 published Portal shape still applies."),
-    lifecycle: import_zod11.z.array(import_zod11.z.object({
-      phase: import_zod11.z.enum(["init", "shutdown", "cyclic", "interrupt", "scheduled"]).describe("Which lifecycle/execution flow this roots (cyclic = every scan/tick, interrupt = hardware/OS interrupt, scheduled = timer/cron)"),
-      component: import_zod11.z.string().describe("Component id whose method the runtime invokes at this phase"),
-      method: import_zod11.z.string().describe("Method name on that component's interface"),
-      description: import_zod11.z.string().optional()
+    lifecycle: import_zod12.z.array(import_zod12.z.object({
+      phase: import_zod12.z.enum(["init", "shutdown", "cyclic", "interrupt", "scheduled"]).describe("Which lifecycle/execution flow this roots (cyclic = every scan/tick, interrupt = hardware/OS interrupt, scheduled = timer/cron)"),
+      component: import_zod12.z.string().describe("Component id whose method the runtime invokes at this phase"),
+      method: import_zod12.z.string().describe("Method name on that component's interface"),
+      description: import_zod12.z.string().optional()
     }).strict()).optional().describe("Declared execution-flow roots \u2014 reachability entrypoints alongside Portals/Observers. Only init flows feed the durable-Store hydration check (MISSING_HYDRATION); cyclic/interrupt/scheduled root non-request/response execution models (PLC scan, ISR, cron)."),
     status: statusInput
   };
@@ -42892,8 +44063,8 @@ function createBareMcpServer(options = {}) {
     {
       description: "Set (replace) an existing subsystem's export table (its publicInterfaces). An OWN item binds type + details to the component (and optional interface) that realizes it, or exports a type the subsystem owns (typeDef). A RE-EXPORT names another subsystem of the project in `from` and one component (optionally narrowed with `interface`) or one typeDef from what it exports, optionally renamed with `as` \u2014 `from` alone re-exports everything it exports; type and details are optional on a re-export, which inherits its target's. Use this to backfill bindings once the subsystem's components exist \u2014 cross-subsystem dependencies may only target a component its owning subsystem publishes; a re-export is a name, not a licence. A replacement, not a merge: an entry left out is removed. An own entry's identity is its component and interface, a re-export's its source, item and name, so a list naming one identity twice is refused. Written through the authoring seam as one gated delta, and answered with the change report \u2014 every entry added, changed or removed, or that nothing changed \u2014 as structured content beside the sentence.",
       inputSchema: {
-        subsystem: import_zod11.z.string().describe("The L1 subsystem id to update"),
-        publicInterfaces: import_zod11.z.array(publicInterfaceItemInput).describe("The full replacement list of the subsystem's export table: own items and re-exports")
+        subsystem: import_zod12.z.string().describe("The L1 subsystem id to update"),
+        publicInterfaces: import_zod12.z.array(publicInterfaceItemInput).describe("The full replacement list of the subsystem's export table: own items and re-exports")
       },
       outputSchema: specChangeReportOutput
     },
@@ -42903,11 +44074,11 @@ function createBareMcpServer(options = {}) {
         if (!sub) return errText(`Subsystem "${subsystem}" does not exist.`);
         const delta = publicInterfacesReplacement(subsystem, sub.publicInterfaces ?? [], publicInterfaces);
         if (typeof delta === "string") return errText(delta);
-        const report2 = updateSpecGated("subsystem", subsystem, delta);
+        const report3 = updateSpecGated("subsystem", subsystem, delta);
         return structured(
           `Updated public interfaces for subsystem "${subsystem}" (${publicInterfaces.length} ${publicInterfaces.length === 1 ? "entry" : "entries"}).
-${renderChangeReport(report2)}`,
-          report2
+${renderChangeReport(report3)}`,
+          report3
         );
       } catch (e) {
         return errMessage(e);
@@ -42920,10 +44091,10 @@ ${renderChangeReport(report2)}`,
     {
       description: "Create a member of the bound project at `source`, in the one members grammar: `services/scheduler` (contained), `../admin` (a sibling checkout), `git@host:acme/payments.git` (a git repository, pinned at its default branch head unless `#<commit>` is given). By default a PART (stage 8): a piece of this project stored in another folder or repository, whose subsystems are this project's own (local ids, the ordinary subsystem rules, this project's lock); it gets only a specs folder, plus a configuration naming this project when it is not contained. With `as: project` an independent PROJECT instead: its project content is created \u2014 a project.yaml declaring the alias as its id, its L0, and the bound project's required packs (composition.requirePolicies) once \u2014 and it is reached only as `alias::name` through its L0 exports. What a member is follows from that content. A git member is not scaffolded; the repository's content decides what it is. Boundaries are earned: create a part unless the piece needs its own team, release, approval or public surface; sdd_promote_member makes one later. Idempotent \u2014 the same call again writes nothing; a different member under the alias is refused.",
       inputSchema: {
-        alias: import_zod11.z.string().describe("The member's alias ([a-z0-9-_]+); a project's new id"),
-        source: import_zod11.z.string().describe("A contained path, a `../` sibling path, or a git URL (optionally `#<commit>`)"),
-        description: import_zod11.z.string().optional().describe("What the member is to this project; also the vision of a bootstrapped project L0"),
-        as: import_zod11.z.enum(["part", "project"]).optional().describe("project to create the project content; omitted creates a part")
+        alias: import_zod12.z.string().describe("The member's alias ([a-z0-9-_]+); a project's new id"),
+        source: import_zod12.z.string().describe("A contained path, a `../` sibling path, or a git URL (optionally `#<commit>`)"),
+        description: import_zod12.z.string().optional().describe("What the member is to this project; also the vision of a bootstrapped project L0"),
+        as: import_zod12.z.enum(["part", "project"]).optional().describe("project to create the project content; omitted creates a part")
       },
       outputSchema: memberCreationOutput
     },
@@ -42944,8 +44115,8 @@ ${renderChangeReport(report2)}`,
       {
         description: "What selecting (or updating to) an installed pack would change on the bound project, writing nothing \u2014 the pack's doctrine against wairon's defaults (rules loosened, raised, turned off or added; profiles, stereotype fencing, edge licenses, patterns, guarantees and language tables added, redefined or removed), which of its profiles would govern, and the findings that change here. A pack the project already applies exactly as asked is measured as removed, so the findings read as what it accounts for now. Nothing in it is a finding: packs exist to adjust wairon's checks, and a loosening is stated like any other change. Apply a pack with `wairon pack use`.",
         inputSchema: {
-          pack: import_zod11.z.string().describe("The pack name"),
-          version: import_zod11.z.string().optional().describe("An exact version; omitted, the latest installed")
+          pack: import_zod12.z.string().describe("The pack name"),
+          version: import_zod12.z.string().optional().describe("An exact version; omitted, the latest installed")
         },
         outputSchema: packImpactOutput
       },
@@ -42970,8 +44141,8 @@ ${renderChangeReport(report2)}`,
     {
       description: "Relocate a member's directory on disk and point its `members` entry there in one step (a member still declared in the legacy L1 form is moved into `members` first). Errors if the alias declares no member, or the new path escapes the project or already exists.",
       inputSchema: {
-        alias: import_zod11.z.string().describe("The member's alias"),
-        newPath: import_zod11.z.string().describe("The member's new root, relative to the bound project")
+        alias: import_zod12.z.string().describe("The member's alias"),
+        newPath: import_zod12.z.string().describe("The member's new root, relative to the bound project")
       }
     },
     ({ alias, newPath }) => {
@@ -42983,16 +44154,16 @@ ${renderChangeReport(report2)}`,
       }
     }
   );
-  const dryRunArg = import_zod11.z.boolean().optional().describe("Answer the plan and write nothing \u2014 run this first and show the plan");
+  const dryRunArg = import_zod12.z.boolean().optional().describe("Answer the plan and write nothing \u2014 run this first and show the plan");
   reg(
     server,
     "sdd_externalize_subsystem",
     {
       description: "Move an internal subsystem out to the path. By default (stage 8) into a PART \u2014 a storage move: the subsystem's specs move to that directory (a new part, or the existing part there), and nothing else changes: no reference, export, external or lock entry, the same verdict. With `as: project`, into a member PROJECT instead, family-wide and all-or-nothing \u2014 the move followed by a promote: what crosses the new boundary exported and imported, references respelled `alias::name`, the new member's external for this project pinned, and every other family project's references checked to still resolve (a reference that would need a component made public refuses the plan). Source code is not moved. dryRun answers the plan and writes nothing; run it first and show the plan. Never locks: the answer names the projects to re-lock.",
       inputSchema: {
-        subsystem: import_zod11.z.string().describe("The subsystem to move out"),
-        path: import_zod11.z.string().describe("The part's root, relative to the bound project (a new directory, or an existing part's)"),
-        as: import_zod11.z.enum(["part", "project"]).optional().describe("part (default) or project"),
+        subsystem: import_zod12.z.string().describe("The subsystem to move out"),
+        path: import_zod12.z.string().describe("The part's root, relative to the bound project (a new directory, or an existing part's)"),
+        as: import_zod12.z.enum(["part", "project"]).optional().describe("part (default) or project"),
         dryRun: dryRunArg
       }
     },
@@ -43004,8 +44175,8 @@ ${renderChangeReport(report2)}`,
     {
       description: "Promote a part of the bound project to an independent project in place (stage 8) \u2014 its files stay where they are; it gets an id, an L0 exporting exactly what the rest of the project uses of it, its references across the new boundary respelled `alias::name`, the parent declared as its external, and pins on both sides. Refused (each reason listed) for a part fetched from git, a trusted link that would cross the new boundary, a used component its subsystem does not publish, or an id already taken. All-or-nothing; dryRun answers the plan and writes nothing \u2014 run it first and show the plan. Never locks: the answer names the project to re-lock and the new one to lock.",
       inputSchema: {
-        alias: import_zod11.z.string().describe("The part's alias"),
-        id: import_zod11.z.string().optional().describe("The new project's id (default: the alias)"),
+        alias: import_zod12.z.string().describe("The part's alias"),
+        id: import_zod12.z.string().optional().describe("The new project's id (default: the alias)"),
         dryRun: dryRunArg
       }
     },
@@ -43017,11 +44188,11 @@ ${renderChangeReport(report2)}`,
     {
       description: "Demote a project member of the bound project to a part in place (stage 8) \u2014 sdd_promote_member's inverse: its files stay where they are; its own metadata goes to the homes the destination names (as sdd_internalize_member sends it), its L0, lock and pins end, its references across the old boundary become local ids, and its configuration is reduced to naming its parent. Refused while another family project consumes it (a part has no exports \u2014 each consumer listed), for a member fetched from git, or for internalize's reasons. All-or-nothing; dryRun answers the plan and writes nothing \u2014 run it first and show the plan. Never locks.",
       inputSchema: {
-        alias: import_zod11.z.string().describe("The project member's alias"),
-        destination: import_zod11.z.object({
-          home: import_zod11.z.string().optional().describe("The subsystem that receives the member's L0 vision"),
-          packs: import_zod11.z.enum(["adopt", "drop"]).optional().describe("adopt | drop: packs only the member selects"),
-          exports: import_zod11.z.array(import_zod11.z.string()).optional().describe("Public names of the member the bound project exports afterwards")
+        alias: import_zod12.z.string().describe("The project member's alias"),
+        destination: import_zod12.z.object({
+          home: import_zod12.z.string().optional().describe("The subsystem that receives the member's L0 vision"),
+          packs: import_zod12.z.enum(["adopt", "drop"]).optional().describe("adopt | drop: packs only the member selects"),
+          exports: import_zod12.z.array(import_zod12.z.string()).optional().describe("Public names of the member the bound project exports afterwards")
         }).optional().describe("Where its own metadata goes (its home subsystem, packs to adopt or drop)"),
         dryRun: dryRunArg
       }
@@ -43038,10 +44209,10 @@ ${renderChangeReport(report2)}`,
     {
       description: "Fold a member \u2014 every subsystem of it \u2014 back into the bound project, sending its own metadata to the destination (its L0 vision to the `into` subsystem's description; its requirements, boundaries and databases to the bound L0; its language, profile and depth onto the moved subsystems; its members and externals to the bound project's; its packs adopted or dropped as `packs` says) and re-pointing every other family project that consumed it at the bound project. What has no home \u2014 its lock, pins, derived outputs \u2014 is listed as deleted. Refused for a member carrying conformance debt, a pack only it selects with no `packs` answer, or a name collision. All-or-nothing; dryRun answers the plan and writes nothing; run it first and show the plan. Never locks.",
       inputSchema: {
-        alias: import_zod11.z.string().describe("The member's alias"),
-        into: import_zod11.z.string().optional().describe("The home subsystem for the member's L0 vision; required when it holds several subsystems"),
-        packs: import_zod11.z.enum(["adopt", "drop"]).optional().describe("adopt | drop: packs only the member selects"),
-        exports: import_zod11.z.array(import_zod11.z.string()).optional().describe("Extra public names of the member the bound project exports afterwards"),
+        alias: import_zod12.z.string().describe("The member's alias"),
+        into: import_zod12.z.string().optional().describe("The home subsystem for the member's L0 vision; required when it holds several subsystems"),
+        packs: import_zod12.z.enum(["adopt", "drop"]).optional().describe("adopt | drop: packs only the member selects"),
+        exports: import_zod12.z.array(import_zod12.z.string()).optional().describe("Extra public names of the member the bound project exports afterwards"),
         dryRun: dryRunArg
       }
     },
@@ -43057,9 +44228,9 @@ ${renderChangeReport(report2)}`,
     {
       description: "Make an existing project at the path a member of the bound project, keeping its L0, subsystems, packs and lock (sdd_add_member scaffolds a new one instead). Refused when its id collides with a family project's. All-or-nothing; dryRun answers the plan and writes nothing. Never locks.",
       inputSchema: {
-        alias: import_zod11.z.string().describe("The alias to declare ([a-z0-9-_]+)"),
-        path: import_zod11.z.string().describe("The project's root, relative to the bound project"),
-        description: import_zod11.z.string().optional().describe("What the member is to this project"),
+        alias: import_zod12.z.string().describe("The alias to declare ([a-z0-9-_]+)"),
+        path: import_zod12.z.string().describe("The project's root, relative to the bound project"),
+        description: import_zod12.z.string().optional().describe("What the member is to this project"),
         dryRun: dryRunArg
       }
     },
@@ -43071,8 +44242,8 @@ ${renderChangeReport(report2)}`,
     {
       description: "Move a project's id \u2014 the bound project's, or a member's named by its alias path \u2014 and every reference to the old id across the family (aliases that were the id, their references and re-exports, externals naming it, pins). The whole family must be in reach. Every project it writes must be re-locked; the answer names them. All-or-nothing; dryRun answers the plan and writes nothing; run it first and show the plan.",
       inputSchema: {
-        newId: import_zod11.z.string().describe("The new project id"),
-        project: import_zod11.z.string().optional().describe("The member's alias path from the bound project (e.g. billing/payments); the bound project when omitted"),
+        newId: import_zod12.z.string().describe("The new project id"),
+        project: import_zod12.z.string().optional().describe("The member's alias path from the bound project (e.g. billing/payments); the bound project when omitted"),
         dryRun: dryRunArg
       }
     },
@@ -43084,8 +44255,8 @@ ${renderChangeReport(report2)}`,
     {
       description: "Rename one alias of the bound project (a member or an external) and respell the bound project's references through it; nothing in any member or sibling changes. All-or-nothing; dryRun answers the plan and writes nothing. Never locks.",
       inputSchema: {
-        alias: import_zod11.z.string().describe("The alias as declared now"),
-        newAlias: import_zod11.z.string().describe("The new alias"),
+        alias: import_zod12.z.string().describe("The alias as declared now"),
+        newAlias: import_zod12.z.string().describe("The new alias"),
         dryRun: dryRunArg
       }
     },
@@ -43097,8 +44268,8 @@ ${renderChangeReport(report2)}`,
     {
       description: "Take a member out of the family; the bound project and every family consumer then reach it as an external by path, pinned. No reference text changes. Refused (audience-too-narrow, each export named with its users) while a family project uses an export the member gives the family alone, unless widen is set: then exactly those used exports are widened to the instance audience in the member's L0, each shown in the plan. All-or-nothing; dryRun answers the plan and writes nothing. Never locks.",
       inputSchema: {
-        alias: import_zod11.z.string().describe("The member's alias"),
-        widen: import_zod11.z.boolean().optional().describe("Widen the used family-only exports to the instance audience instead of refusing"),
+        alias: import_zod12.z.string().describe("The member's alias"),
+        widen: import_zod12.z.boolean().optional().describe("Widen the used family-only exports to the instance audience instead of refusing"),
         dryRun: dryRunArg
       }
     },
@@ -43110,8 +44281,8 @@ ${renderChangeReport(report2)}`,
     {
       description: "Make the bound project's external a member \u2014 sdd_detach_member's inverse. Locally the external is found by a path inside the bound project and adopted where it is; on a hosted instance it names a project by source.hosted and `path` says where to adopt it (the hosting server relocates it there). All-or-nothing; dryRun answers the plan and writes nothing. Never locks.",
       inputSchema: {
-        alias: import_zod11.z.string().describe("The external's alias"),
-        path: import_zod11.z.string().optional().describe("Hosted: the member path to adopt a source.hosted external at, relative to the bound project; a source.path external is adopted where it is"),
+        alias: import_zod12.z.string().describe("The external's alias"),
+        path: import_zod12.z.string().optional().describe("Hosted: the member path to adopt a source.hosted external at, relative to the bound project; a source.path external is adopted where it is"),
         dryRun: dryRunArg
       }
     },
@@ -43123,8 +44294,8 @@ ${renderChangeReport(report2)}`,
     {
       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")
+        id: import_zod12.z.string().describe("The component to rename (namespaced if needed)"),
+        newId: import_zod12.z.string().describe("Its new id: a lowercase identifier with no namespace separator")
       }
     },
     ({ id, newId }) => {
@@ -43141,10 +44312,10 @@ ${renderChangeReport(report2)}`,
     {
       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"),
-        newName: import_zod11.z.string().describe("Its new name: a camel-case identifier"),
-        pinSymbol: import_zod11.z.boolean().optional().describe("Whether an implementation that declares no symbol is pinned to the old name so its function still binds; true when omitted")
+        id: import_zod12.z.string().describe("The component whose method is renamed (namespaced if needed)"),
+        method: import_zod12.z.string().describe("The method name as it stands"),
+        newName: import_zod12.z.string().describe("Its new name: a camel-case identifier"),
+        pinSymbol: import_zod12.z.boolean().optional().describe("Whether an implementation that declares no symbol is pinned to the old name so its function still binds; true when omitted")
       }
     },
     ({ id, method, newName, pinSymbol }) => {
@@ -43155,16 +44326,36 @@ ${renderChangeReport(report2)}`,
       }
     }
   );
+  reg(
+    server,
+    "sdd_rename_type",
+    {
+      description: "Rename a type and rewrite every reference to it in the bound tree: every type position naming it (contract and type-method params and returns, fields, signature-type params and returns), a signatureFrom naming it as a signature type, and an L1 or L0 export entry's typeDef. Only the named members of a type expression that name this type are respelled, in the style they were written (`Invoice` \u2192 `Bill`, `invoice` \u2192 `bill`); the rest of the text stays as written. The type moves to the new id and file under the same owner, and its old id joins its rename trace (previousIds) so a consumer of the design export reads the rename as a rename; an export entry that derived its public name from the old id gets `as: <that name>` first, so the published name and every consumer's pin stay. Rename traces are never rewritten. Findings keyed on the type follow it: lint allows naming it, and every debt-register entry anchored on it, rewritten in place (a register that cannot be rewritten that precisely is refused before the first write). The display name is left as it is. Refuses, writing nothing: a type that does not exist (type-missing), one in another project (chained-type), a new id that is not a lowercase identifier (invalid-id), and a new id another type of the same owner holds (id-taken) or retired (id-retired \u2014 unsetting the holder's previousIds releases it). Returns from and to, the specs rewritten, keptPublicNames and `carried`: each register edit.",
+      inputSchema: {
+        id: import_zod12.z.string().describe("The type to rename (qualified by its owning subsystem if needed, `subsystem::id`)"),
+        newId: import_zod12.z.string().describe("Its new id: a lowercase identifier with no namespace separator")
+      }
+    },
+    ({ id, newId }) => {
+      try {
+        const bare = id.startsWith("::") ? id.slice(2) : id;
+        const resolved = loadTypeSpec(bare) ? bare : id;
+        return json(renameType(resolved, newId));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
   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. 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)"),
-        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: import_zod12.z.string().describe("The component the methods belong to (namespaced if needed)"),
+        to: import_zod12.z.string().describe("The component that should receive them (namespaced if needed)"),
+        methods: import_zod12.z.array(import_zod12.z.string()).describe("The method names to move; every one must exist on the source contract"),
+        dryRun: import_zod12.z.boolean().optional().describe("Answer with what the move would do and write nothing")
       }
     },
     ({ from, to, methods, dryRun }) => {
@@ -43180,39 +44371,39 @@ ${renderChangeReport(report2)}`,
     }
   );
   const componentInput = {
-    id: import_zod11.z.string().describe("Lowercase identifier for the component"),
-    name: import_zod11.z.string().describe("Human-readable display name"),
-    description: import_zod11.z.string().describe("Responsibility / internal architecture details"),
-    subsystem: import_zod11.z.string().describe("The L1 subsystem ID this component belongs to"),
-    componentType: import_zod11.z.enum(["Portal", "Orchestrator", "Supervisor", "Actor", "Store", "Index", "Query", "Registry", "Adapter", "Observer", "Repository"]).describe("The building block, or the pattern Repository. Specialist and Gateway are retired and cannot be authored: logic is an Orchestrator with a dependencyClass, a gateway is a Portal with the gateway variant"),
-    owns: import_zod11.z.array(import_zod11.z.string()).optional().describe("Member block ids privately owned by this component (patterns only)"),
-    dependsOn: import_zod11.z.array(import_zod11.z.string()).optional().describe("IDs of other components this collaborates with (facades or standalone blocks)"),
-    portalType: import_zod11.z.enum(["HTTP_API", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "Custom"]).optional().describe("Portal-only, and expected on every Portal. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
-    basePath: import_zod11.z.string().optional().describe("Portal-only: base path/prefix all the portal's endpoints mount under. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
-    dispatch: import_zod11.z.array(import_zod11.z.object({
-      capability: import_zod11.z.string().describe('Capability name exactly as dispatched at runtime (e.g. "shadow_module.get")'),
-      component: import_zod11.z.string().describe("Component id serving this capability (must also appear under dependsOn/owns)"),
-      method: import_zod11.z.string().describe("Method name on the serving component's interface"),
-      description: import_zod11.z.string().optional()
+    id: import_zod12.z.string().describe("Lowercase identifier for the component"),
+    name: import_zod12.z.string().describe("Human-readable display name"),
+    description: import_zod12.z.string().describe("Responsibility / internal architecture details"),
+    subsystem: import_zod12.z.string().describe("The L1 subsystem ID this component belongs to"),
+    componentType: import_zod12.z.enum(["Portal", "Orchestrator", "Supervisor", "Actor", "Store", "Index", "Query", "Registry", "Adapter", "Observer", "Repository"]).describe("The building block, or the pattern Repository. Specialist and Gateway are retired and cannot be authored: logic is an Orchestrator with a dependencyClass, a gateway is a Portal with the gateway variant"),
+    owns: import_zod12.z.array(import_zod12.z.string()).optional().describe("Member block ids privately owned by this component (patterns only)"),
+    dependsOn: import_zod12.z.array(import_zod12.z.string()).optional().describe("IDs of other components this collaborates with (facades or standalone blocks)"),
+    portalType: import_zod12.z.enum(["HTTP_API", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "Custom"]).optional().describe("Portal-only, and expected on every Portal. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
+    basePath: import_zod12.z.string().optional().describe("Portal-only: base path/prefix all the portal's endpoints mount under. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
+    dispatch: import_zod12.z.array(import_zod12.z.object({
+      capability: import_zod12.z.string().describe('Capability name exactly as dispatched at runtime (e.g. "shadow_module.get")'),
+      component: import_zod12.z.string().describe("Component id serving this capability (must also appear under dependsOn/owns)"),
+      method: import_zod12.z.string().describe("Method name on the serving component's interface"),
+      description: import_zod12.z.string().optional()
     }).strict()).optional().describe("Portal-only: capability \u2192 component.method dispatch table for generic-handle portals. Gives the reachability walker real edges and is validated against target interfaces (UNSERVED_CAPABILITY)."),
-    mounts: import_zod11.z.array(import_zod11.z.object({
-      portal: import_zod11.z.string().describe("The mounted Portal's component id"),
-      prefixes: import_zod11.z.array(import_zod11.z.string()).describe('The path prefixes this listener routes to the portal. A path lies under a prefix when it equals it or continues it past a slash, so "/" covers only the root itself'),
-      via: import_zod11.z.string().optional().describe("The router entry the listener calls to hand the portal its request, exported by the PORTAL's own file (held to it: UNREALIZED_EXPORT_HANDLE). Omit when the listener calls the portal's contract methods directly, route by route")
+    mounts: import_zod12.z.array(import_zod12.z.object({
+      portal: import_zod12.z.string().describe("The mounted Portal's component id"),
+      prefixes: import_zod12.z.array(import_zod12.z.string()).describe('The path prefixes this listener routes to the portal. A path lies under a prefix when it equals it or continues it past a slash, so "/" covers only the root itself'),
+      via: import_zod12.z.string().optional().describe("The router entry the listener calls to hand the portal its request, exported by the PORTAL's own file (held to it: UNREALIZED_EXPORT_HANDLE). Omit when the listener calls the portal's contract methods directly, route by route")
     }).strict()).optional().describe("Portal-only: the portals this LISTENER serves, each under its path prefixes and through its router entry. Declaring the field \u2014 even as an empty array \u2014 marks this portal as a listener, the one kind of portal nothing else needs to mount. Checked by portal-mounts: a mount must name a Portal (MOUNT_TARGET_NOT_PORTAL), every HTTP endpoint of a mounted portal must lie under one of its prefixes (ENDPOINT_OUTSIDE_MOUNT), and a portal with HTTP endpoints that is neither a listener nor mounted by one is reported (UNMOUNTED_PORTAL)."),
-    durability: import_zod11.z.enum(["ram-projection", "durable", "read-through", "cache"]).optional().describe("Store-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DURABILITY_ON_NON_STORE) and nothing is saved. Every Store should declare one (MISSING_DURABILITY): durable = persisted RAM projection (hydration read-back from a lifecycle init entrypoint required \u2014 MISSING_HYDRATION); read-through = persisted with no RAM copy (every read is the read-back, hydration exempt); ram-projection = rebuilt not restored; cache = evictable loss-safe memo state."),
-    dependencyClass: import_zod11.z.enum(["pure", "read"]).optional().describe("Orchestrator-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DEPENDENCY_CLASS_ON_NON_ORCHESTRATOR) and nothing is saved. Declares what logic may depend on, enforced as a Store's durability is (DEPENDENCY_CLASS_VIOLATION): pure = depends only on pure Orchestrators (a computation over the values it is handed, e.g. an arbiter or codec); read = also on read Orchestrators, Repositories, Indexes and Adapters, never calling their write methods; unset = a workflow."),
-    emits: import_zod11.z.array(import_zod11.z.object({
-      topic: import_zod11.z.string().describe("Topic/channel name exactly as used on the bus"),
-      event: import_zod11.z.string().optional().describe("Optional event name within the topic (informational; pairing is by topic)"),
-      description: import_zod11.z.string().optional()
+    durability: import_zod12.z.enum(["ram-projection", "durable", "read-through", "cache"]).optional().describe("Store-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DURABILITY_ON_NON_STORE) and nothing is saved. Every Store should declare one (MISSING_DURABILITY): durable = persisted RAM projection (hydration read-back from a lifecycle init entrypoint required \u2014 MISSING_HYDRATION); read-through = persisted with no RAM copy (every read is the read-back, hydration exempt); ram-projection = rebuilt not restored; cache = evictable loss-safe memo state."),
+    dependencyClass: import_zod12.z.enum(["pure", "read"]).optional().describe("Orchestrator-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DEPENDENCY_CLASS_ON_NON_ORCHESTRATOR) and nothing is saved. Declares what logic may depend on, enforced as a Store's durability is (DEPENDENCY_CLASS_VIOLATION): pure = depends only on pure Orchestrators (a computation over the values it is handed, e.g. an arbiter or codec); read = also on read Orchestrators, Repositories, Indexes and Adapters, never calling their write methods; unset = a workflow."),
+    emits: import_zod12.z.array(import_zod12.z.object({
+      topic: import_zod12.z.string().describe("Topic/channel name exactly as used on the bus"),
+      event: import_zod12.z.string().optional().describe("Optional event name within the topic (informational; pairing is by topic)"),
+      description: import_zod12.z.string().optional()
     }).strict()).optional().describe("Topics this component publishes \u2014 every emitted topic needs a subscriber somewhere in the tree (UNCONSUMED_TOPIC)."),
-    subscribesTo: import_zod11.z.array(import_zod11.z.object({
-      topic: import_zod11.z.string().describe("Topic/channel name exactly as used on the bus"),
-      event: import_zod11.z.string().optional(),
-      description: import_zod11.z.string().optional()
+    subscribesTo: import_zod12.z.array(import_zod12.z.object({
+      topic: import_zod12.z.string().describe("Topic/channel name exactly as used on the bus"),
+      event: import_zod12.z.string().optional(),
+      description: import_zod12.z.string().optional()
     }).strict()).optional().describe("Topics this component consumes (typical on Observers) \u2014 every subscription needs an emitter somewhere in the tree (UNSOURCED_SUBSCRIPTION)."),
-    ext: import_zod11.z.record(import_zod11.z.unknown()).optional().describe('Opaque pack/tool extension data (namespaced keys, e.g. "mypack:priority") \u2014 preserved verbatim, never validated or interpreted by the core'),
+    ext: import_zod12.z.record(import_zod12.z.unknown()).optional().describe('Opaque pack/tool extension data (namespaced keys, e.g. "mypack:priority") \u2014 preserved verbatim, never validated or interpreted by the core'),
     status: statusInput
   };
   const componentInputFields = Object.keys(componentInput);
@@ -43260,45 +44451,45 @@ ${renderChangeReport(report2)}`,
       }
     }
   );
-  const methodParamItem = import_zod11.z.object({
-    name: import_zod11.z.string(),
-    type: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The parameter's type")),
-    description: import_zod11.z.string().optional(),
-    optional: import_zod11.z.boolean().optional().describe(
+  const methodParamItem = import_zod12.z.object({
+    name: import_zod12.z.string(),
+    type: import_zod12.z.string().describe(TYPE_REF_GRAMMAR("The parameter's type")),
+    description: import_zod12.z.string().optional(),
+    optional: import_zod12.z.boolean().optional().describe(
       'Whether the parameter may be OMITTED by a caller. It is not nullability: a parameter that must be passed but may be passed as nothing is a required parameter whose type says so \u2014 "ProjectConfig?". Say whichever is true; they are different contracts (both together: may be left out, and may be none).'
     )
   }).strict();
   const interfaceMethodShape = {
-    name: import_zod11.z.string(),
-    description: import_zod11.z.string(),
-    signature: import_zod11.z.string().optional().describe(
+    name: import_zod12.z.string(),
+    description: import_zod12.z.string(),
+    signature: import_zod12.z.string().optional().describe(
       "Prose signature \u2014 only for a method WITHOUT params. With params the server derives and writes the text (`name(a: T, b?: U): R`) and ignores this one (a notice names one that differed); a method with a signatureFrom states none."
     ),
-    returns: import_zod11.z.string().optional().describe(TYPE_REF_GRAMMAR("The type the method answers with. Required unless signatureFrom is set, whose source supplies it")),
-    signatureFrom: import_zod11.z.string().min(1).optional().describe(
+    returns: import_zod12.z.string().optional().describe(TYPE_REF_GRAMMAR("The type the method answers with. Required unless signatureFrom is set, whose source supplies it")),
+    signatureFrom: import_zod12.z.string().min(1).optional().describe(
       "Take this method's params and returns from ONE source instead of stating them: a signature type id (`billing.change_listener`, `alias::name`) or a contract method `component.method` whose component this one names in dependsOn or owns (no chains). State it ALONE \u2014 params or returns beside it are refused (SIGNATURE_SOURCE_RESTATED). A value that names both a method and a signature type is ambiguous: qualify it."
     ),
-    params: import_zod11.z.array(methodParamItem).optional().describe("Structured parameters \u2014 authoritative for type checking, and the signature text is derived from them. Strongly preferred."),
-    guarantees: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe("Semantic guarantees the method promises (combinable); any guarantee a narrative step asserts must be declared here. Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
-    effect: import_zod11.z.enum(["read", "write"]).optional().describe("State-effect direction on the component's held state \u2014 required on a durable Store's contract methods so the durability round-trip rule can pair writes with hydration read-backs"),
-    invokedBy: import_zod11.z.object({
-      kind: import_zod11.z.enum(["runtime", "external", "sibling-subsystem"]).describe("Who owns the out-of-graph invocation: runtime (timer/signal/shutdown hook), external (a system outside this project), sibling-subsystem (a modeled sibling whose edge is not narrated here)"),
-      caller: import_zod11.z.string().optional().describe("WHO invokes it and when, as reviewable prose \u2014 missing or placeholder-thin prose is INVOKED_BY_UNDESCRIBED")
+    params: import_zod12.z.array(methodParamItem).optional().describe("Structured parameters \u2014 authoritative for type checking, and the signature text is derived from them. Strongly preferred."),
+    guarantees: import_zod12.z.array(import_zod12.z.string().min(1)).optional().describe("Semantic guarantees the method promises (combinable); any guarantee a narrative step asserts must be declared here. Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
+    effect: import_zod12.z.enum(["read", "write", "lifecycle"]).optional().describe("What the method does to the component's held state: read observes it; write modifies an entity's domain fields; lifecycle creates, destroys, or (un)registers an entity's existence or membership without modifying its fields, and calls only read and lifecycle methods (LIFECYCLE_CALLS_WRITE). Required on a durable Store's contract methods so the durability round-trip rule can pair mutations with hydration read-backs; a Supervisor may call a data component it does not own only through read and lifecycle methods (SUPERVISOR_WRITE_SHORTCUT)"),
+    invokedBy: import_zod12.z.object({
+      kind: import_zod12.z.enum(["runtime", "external", "sibling-subsystem"]).describe("Who owns the out-of-graph invocation: runtime (timer/signal/shutdown hook), external (a system outside this project), sibling-subsystem (a modeled sibling whose edge is not narrated here)"),
+      caller: import_zod12.z.string().optional().describe("WHO invokes it and when, as reviewable prose \u2014 missing or placeholder-thin prose is INVOKED_BY_UNDESCRIBED")
     }).strict().optional().describe("Typed acknowledgment of a real caller OUTSIDE the modeled narrative graph. Unused-detection seeds the method as an entrypoint so reachability propagates through its narrative (unlike lint.allow); a method the internal walk already reaches is flagged stale (INVOKED_BY_REDUNDANT). Prefer a `register` narrative step when the wiring is internal."),
-    findings: import_zod11.z.array(import_zod11.z.object({
-      code: import_zod11.z.string().describe("UPPER_SNAKE finding code, unique within the method; a pack's codes carry the pack prefix (<PACK>_<CODE>)"),
-      severity: import_zod11.z.enum(["error", "warning", "notice"]).describe("Default severity, before project severity overrides and draft-context downgrades. A notice is reported but never fails the gate"),
-      summary: import_zod11.z.string().describe("One line saying what the finding means")
+    findings: import_zod12.z.array(import_zod12.z.object({
+      code: import_zod12.z.string().describe("UPPER_SNAKE finding code, unique within the method; a pack's codes carry the pack prefix (<PACK>_<CODE>)"),
+      severity: import_zod12.z.enum(["error", "warning", "notice"]).describe("Default severity, before project severity overrides and draft-context downgrades. A notice is reported but never fails the gate"),
+      summary: import_zod12.z.string().describe("One line saying what the finding means")
     }).strict()).optional().describe("The finding codes this method can report, each with its default severity and summary. Each declared code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). A code is declared once per method; sdd_update_spec upserts and deletes findings by code."),
-    ext: import_zod11.z.record(import_zod11.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim")
+    ext: import_zod12.z.record(import_zod12.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim")
   };
   const interfaceMethodInputFields = Object.keys(interfaceMethodShape);
   const interfaceInput = {
-    id: import_zod11.z.string().describe('Lowercase identifier prefixed with "i", e.g. "istorage"'),
-    name: import_zod11.z.string().describe("Human-readable contract name"),
-    description: import_zod11.z.string().describe("Contract description and obligations"),
-    component: import_zod11.z.string().describe("The L2 component ID this interface belongs to"),
-    methods: import_zod11.z.array(import_zod11.z.object(interfaceMethodShape).strict()).optional().describe("List of method signature contracts"),
+    id: import_zod12.z.string().describe('Lowercase identifier prefixed with "i", e.g. "istorage"'),
+    name: import_zod12.z.string().describe("Human-readable contract name"),
+    description: import_zod12.z.string().describe("Contract description and obligations"),
+    component: import_zod12.z.string().describe("The L2 component ID this interface belongs to"),
+    methods: import_zod12.z.array(import_zod12.z.object(interfaceMethodShape).strict()).optional().describe("List of method signature contracts"),
     status: statusInput
   };
   const interfaceInputFields = Object.keys(interfaceInput);
@@ -43335,24 +44526,24 @@ ${renderChangeReport(report2)}`,
     {
       description: "Bind concrete wire endpoints to existing L3 interface methods (required for every Portal). Pick `transport` and fill that transport's address fields. Run after sdd_define_interface. Written through the authoring seam as one gated delta, and answered with the change report \u2014 every binding set or changed, or that nothing changed \u2014 as structured content beside the sentence.",
       inputSchema: {
-        interface: import_zod11.z.string().describe('The L3 interface ID (e.g. "ibilling-gateway")'),
-        endpoints: import_zod11.z.array(import_zod11.z.object({
-          method: import_zod11.z.string().describe("The NAME of the interface method to bind (not the HTTP verb)"),
-          transport: import_zod11.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "NamedPipe", "IPC", "CLI", "Custom"]).describe("Wire protocol; must match the Portal's portalType"),
-          httpMethod: import_zod11.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]).optional().describe("HTTP: verb"),
-          path: import_zod11.z.string().optional().describe('HTTP: route path, e.g. "/v1/checkout"'),
-          service: import_zod11.z.string().optional().describe("gRPC: service name"),
-          rpcMethod: import_zod11.z.string().optional().describe("gRPC: rpc method name"),
-          operation: import_zod11.z.enum(["query", "mutation", "subscription"]).optional().describe("GraphQL: operation kind"),
-          field: import_zod11.z.string().optional().describe("GraphQL: root field name"),
-          topic: import_zod11.z.string().optional().describe("MessageBus: topic"),
-          event: import_zod11.z.string().optional().describe("MessageBus: event name"),
-          queue: import_zod11.z.string().optional().describe("MessageBus: optional queue/consumer group"),
-          direction: import_zod11.z.enum(["subscribe", "publish"]).optional().describe("MessageBus: subscribe (default) or publish"),
-          pipe: import_zod11.z.string().optional().describe('NamedPipe: pipe name, e.g. "\\\\.\\pipe\\gk-events"'),
-          channel: import_zod11.z.string().optional().describe("IPC: channel name"),
-          command: import_zod11.z.string().optional().describe("CLI: command/subcommand"),
-          address: import_zod11.z.string().optional().describe("Custom: free-form address")
+        interface: import_zod12.z.string().describe('The L3 interface ID (e.g. "ibilling-gateway")'),
+        endpoints: import_zod12.z.array(import_zod12.z.object({
+          method: import_zod12.z.string().describe("The NAME of the interface method to bind (not the HTTP verb)"),
+          transport: import_zod12.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "NamedPipe", "IPC", "CLI", "Custom"]).describe("Wire protocol; must match the Portal's portalType"),
+          httpMethod: import_zod12.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]).optional().describe("HTTP: verb"),
+          path: import_zod12.z.string().optional().describe('HTTP: route path, e.g. "/v1/checkout"'),
+          service: import_zod12.z.string().optional().describe("gRPC: service name"),
+          rpcMethod: import_zod12.z.string().optional().describe("gRPC: rpc method name"),
+          operation: import_zod12.z.enum(["query", "mutation", "subscription"]).optional().describe("GraphQL: operation kind"),
+          field: import_zod12.z.string().optional().describe("GraphQL: root field name"),
+          topic: import_zod12.z.string().optional().describe("MessageBus: topic"),
+          event: import_zod12.z.string().optional().describe("MessageBus: event name"),
+          queue: import_zod12.z.string().optional().describe("MessageBus: optional queue/consumer group"),
+          direction: import_zod12.z.enum(["subscribe", "publish"]).optional().describe("MessageBus: subscribe (default) or publish"),
+          pipe: import_zod12.z.string().optional().describe('NamedPipe: pipe name, e.g. "\\\\.\\pipe\\gk-events"'),
+          channel: import_zod12.z.string().optional().describe("IPC: channel name"),
+          command: import_zod12.z.string().optional().describe("CLI: command/subcommand"),
+          address: import_zod12.z.string().optional().describe("Custom: free-form address")
         }).strict()).describe("One binding per method")
       },
       outputSchema: specChangeReportOutput
@@ -43394,80 +44585,80 @@ ${renderChangeReport(report2)}`,
           methods.push({ name: e.method, endpoint: parsed.data });
           bound2.push(`${e.method}\u2192${e.transport}`);
         }
-        const report2 = updateSpecGated("interface", interfaceId, { methods });
+        const report3 = updateSpecGated("interface", interfaceId, { methods });
         return structured(
           `Bound ${bound2.length} endpoint(s) on "${interfaceId}": ${bound2.join(", ")}.
-${renderChangeReport(report2)}`,
-          report2
+${renderChangeReport(report3)}`,
+          report3
         );
       } catch (e) {
         return errMessage(e);
       }
     }
   );
-  const stepNo = () => import_zod11.z.number().int().positive();
-  const labelRef = () => import_zod11.z.string().min(1);
-  const narrativeStepInput = import_zod11.z.object({
+  const stepNo = () => import_zod12.z.number().int().positive();
+  const labelRef = () => import_zod12.z.string().min(1);
+  const narrativeStepInput = import_zod12.z.object({
     stepNumber: stepNo().optional().describe("Defaults to the 1-based array position \u2014 jump fields reference these numbers"),
     label: labelRef().optional().describe("Optional symbolic anchor for this step (unique per narrative). Every jump-by-number field has a *Label twin resolved against these anchors at write time \u2014 prefer labels over hand-counted step numbers"),
-    description: import_zod11.z.string(),
-    type: import_zod11.z.enum(["local", "call", "dispatch", "register", "branch", "switch", "loop", "try", "parallel", "jump", "return", "throw"]),
-    targetComponent: import_zod11.z.string().optional().describe("call/register/dispatch: L2 component id (for dispatch, the Portal routed through)"),
-    targetMethod: import_zod11.z.string().optional().describe("call/register: method name on the target. A register step hands the target method to the runtime as a callback (timer, event listener, shutdown hook): reachability follows the edge, but it is never an invocation \u2014 exempt from call-graph conformance, call-cycle detection, and the durability boot walk"),
-    auth: import_zod11.z.object({ from: import_zod11.z.string(), note: import_zod11.z.string().optional() }).strict().optional().describe("call/dispatch: the credential this step presents to an AUTHED callee Portal and WHERE it loads from (`from`). Opaque form (env:API_KEY, a config key, vault:path) = a design note wairon never resolves; modeled form `component:<id>` references the Adapter/Store that provides the secret and is validated (must resolve, be an Adapter/Store, and be wired to the presenter). Absence on a call into a Portal whose auth \u2260 none warns (PORTAL_AUTH_UNMET). The authenticated call itself should be made by an Adapter (AUTH_PRESENTER_NOT_ADAPTER)."),
-    detach: import_zod11.z.boolean().optional().describe("call/dispatch: fire-and-forget \u2014 issue the call and continue without awaiting the result (no later step consumes it)"),
-    capability: import_zod11.z.string().optional().describe("dispatch: the capability routed through the target Portal's dispatch table (validated against it \u2014 UNSERVED_CAPABILITY)"),
-    assertsGuarantees: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe("Semantic guarantees this step relies on \u2014 each must be declared in the called method's L3 guarantees (NARRATIVE_SEMANTIC_UNBACKED otherwise). Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
-    assertsInvariants: import_zod11.z.array(import_zod11.z.string()).optional().describe(`Declared entity invariants this step upholds, as "<type-id>.<invariant-id>" refs (UNKNOWN_INVARIANT_REF when unresolved); write-effect methods of the entity's componentClass must carry one per declared invariant (UNASSERTED_INVARIANT)`),
-    condition: import_zod11.z.string().optional().describe("branch / while / doWhile"),
+    description: import_zod12.z.string(),
+    type: import_zod12.z.enum(["local", "call", "dispatch", "register", "branch", "switch", "loop", "try", "parallel", "jump", "return", "throw"]),
+    targetComponent: import_zod12.z.string().optional().describe("call/register/dispatch: L2 component id (for dispatch, the Portal routed through)"),
+    targetMethod: import_zod12.z.string().optional().describe("call/register: method name on the target. A register step hands the target method to the runtime as a callback (timer, event listener, shutdown hook): reachability follows the edge, but it is never an invocation \u2014 exempt from call-graph conformance, call-cycle detection, and the durability boot walk"),
+    auth: import_zod12.z.object({ from: import_zod12.z.string(), note: import_zod12.z.string().optional() }).strict().optional().describe("call/dispatch: the credential this step presents to an AUTHED callee Portal and WHERE it loads from (`from`). Opaque form (env:API_KEY, a config key, vault:path) = a design note wairon never resolves; modeled form `component:<id>` references the Adapter/Store that provides the secret and is validated (must resolve, be an Adapter/Store, and be wired to the presenter). Absence on a call into a Portal whose auth \u2260 none warns (PORTAL_AUTH_UNMET). The authenticated call itself should be made by an Adapter (AUTH_PRESENTER_NOT_ADAPTER)."),
+    detach: import_zod12.z.boolean().optional().describe("call/dispatch: fire-and-forget \u2014 issue the call and continue without awaiting the result (no later step consumes it)"),
+    capability: import_zod12.z.string().optional().describe("dispatch: the capability routed through the target Portal's dispatch table (validated against it \u2014 UNSERVED_CAPABILITY)"),
+    assertsGuarantees: import_zod12.z.array(import_zod12.z.string().min(1)).optional().describe("Semantic guarantees this step relies on \u2014 each must be declared in the called method's L3 guarantees (NARRATIVE_SEMANTIC_UNBACKED otherwise). Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
+    assertsInvariants: import_zod12.z.array(import_zod12.z.string()).optional().describe(`Declared entity invariants this step upholds, as "<type-id>.<invariant-id>" refs (UNKNOWN_INVARIANT_REF when unresolved); write-effect methods of the entity's componentClass must carry one per declared invariant (UNASSERTED_INVARIANT)`),
+    condition: import_zod12.z.string().optional().describe("branch / while / doWhile"),
     onTrueStep: stepNo().optional().describe("branch: default = next step"),
     onTrueLabel: labelRef().optional().describe("branch: symbolic alternative to onTrueStep"),
     onFalseStep: stepNo().optional().describe("branch: required (or onFalseLabel)"),
     onFalseLabel: labelRef().optional().describe("branch: symbolic alternative to onFalseStep"),
-    on: import_zod11.z.string().optional().describe("switch: the dispatched value"),
-    cases: import_zod11.z.array(import_zod11.z.object({ value: import_zod11.z.string(), step: stepNo().optional(), label: labelRef().optional() }).strict()).optional().describe("switch: required; each case targets its region by step number or label"),
+    on: import_zod12.z.string().optional().describe("switch: the dispatched value"),
+    cases: import_zod12.z.array(import_zod12.z.object({ value: import_zod12.z.string(), step: stepNo().optional(), label: labelRef().optional() }).strict()).optional().describe("switch: required; each case targets its region by step number or label"),
     defaultStep: stepNo().optional().describe("switch: default = next step"),
     defaultLabel: labelRef().optional().describe("switch: symbolic alternative to defaultStep"),
-    loopKind: import_zod11.z.enum(["forEach", "for", "while", "doWhile"]).optional().describe('loop: default forEach when "over" is set, else while'),
-    over: import_zod11.z.string().optional().describe("loop forEach/for: iteration source"),
+    loopKind: import_zod12.z.enum(["forEach", "for", "while", "doWhile"]).optional().describe('loop: default forEach when "over" is set, else while'),
+    over: import_zod12.z.string().optional().describe("loop forEach/for: iteration source"),
     endStep: stepNo().optional().describe("loop/try: last step of the body region (required, or endLabel)"),
     endLabel: labelRef().optional().describe("loop/try: symbolic alternative to endStep"),
-    catches: import_zod11.z.array(import_zod11.z.object({ error: import_zod11.z.string(), step: stepNo().optional(), label: labelRef().optional() }).strict()).optional().describe("try: handler regions, each targeted by step number or label"),
+    catches: import_zod12.z.array(import_zod12.z.object({ error: import_zod12.z.string(), step: stepNo().optional(), label: labelRef().optional() }).strict()).optional().describe("try: handler regions, each targeted by step number or label"),
     finallyStep: stepNo().optional().describe("try: first step of the always-runs region"),
     finallyLabel: labelRef().optional().describe("try: symbolic alternative to finallyStep"),
-    branches: import_zod11.z.array(import_zod11.z.object({ step: stepNo().optional(), label: labelRef().optional(), name: import_zod11.z.string().optional() }).strict()).optional().describe("parallel: >= 2 arm entries (step number or label), ascending, first = the step after the header; arms are contiguous sub-regions of body next..endStep, joining after endStep once ALL complete"),
+    branches: import_zod12.z.array(import_zod12.z.object({ step: stepNo().optional(), label: labelRef().optional(), name: import_zod12.z.string().optional() }).strict()).optional().describe("parallel: >= 2 arm entries (step number or label), ascending, first = the step after the header; arms are contiguous sub-regions of body next..endStep, joining after endStep once ALL complete"),
     toStep: stepNo().optional().describe("jump: required (break/continue/rejoin), or toLabel"),
     toLabel: labelRef().optional().describe("jump: symbolic alternative to toStep \u2014 resolves to the labeled step at write time"),
-    outcome: import_zod11.z.string().optional().describe('return: e.g. "success", "not found"'),
-    error: import_zod11.z.string().optional().describe("throw: the raised error")
+    outcome: import_zod12.z.string().optional().describe('return: e.g. "success", "not found"'),
+    error: import_zod12.z.string().optional().describe("throw: the raised error")
   }).strict();
-  const detailEnum = import_zod11.z.enum(["full", "calls-only", "intent"]);
-  const conformanceEnum = import_zod11.z.enum(["declared", "anchored", "off"]);
+  const detailEnum = import_zod12.z.enum(["full", "calls-only", "intent"]);
+  const conformanceEnum = import_zod12.z.enum(["declared", "anchored", "off"]);
   const implMethodShape = {
-    name: import_zod11.z.string(),
-    sourcePath: import_zod11.z.string().optional().describe("Optional: the source file realizing THIS method when it is not the implementation's sourcePath (e.g. a command whose body lives in its own file); the implementation's sourcePath is the default. Relative to project root \u2014 for a chained subproject's implementation (qualified id), relative to that subproject's root; a path given relative to this root that lands inside the subproject is re-expressed for you"),
+    name: import_zod12.z.string(),
+    sourcePath: import_zod12.z.string().optional().describe("Optional: the source file realizing THIS method when it is not the implementation's sourcePath (e.g. a command whose body lives in its own file); the implementation's sourcePath is the default. Relative to project root \u2014 for a chained subproject's implementation (qualified id), relative to that subproject's root; a path given relative to this root that lands inside the subproject is re-expressed for you"),
     detail: detailEnum.optional().describe("Detail level for this method (overrides the spec default)"),
-    intent: import_zod11.z.string().optional().describe("detail: intent \u2014 behavioral prose (what it does and how it fails); substitute for a narrative"),
+    intent: import_zod12.z.string().optional().describe("detail: intent \u2014 behavioral prose (what it does and how it fails); substitute for a narrative"),
     conformance: conformanceEnum.optional().describe("Conformance tier for this method (overrides the spec default)"),
-    symbol: import_zod11.z.string().optional().describe("Code-level name realizing this contract method in the sourcePath file, when it legitimately differs from the intent-language contract name (e.g. put realized by saveSnapshot)"),
-    exportedVia: import_zod11.z.string().optional().describe("The exported binding a consumer imports to REACH this method, when the realization is published as a value that composes it rather than exported in its own right (a rule module publishes callConformanceRule, and the method is the check inside it). Not symbol, which names the function itself: this names the route to it, so the surface check reads that export as promised. A handle the method's own source file does not actually export is reported (UNREALIZED_EXPORT_HANDLE) and allows nothing"),
-    ext: import_zod11.z.record(import_zod11.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim"),
-    narrative: import_zod11.z.array(narrativeStepInput).optional(),
-    calls: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe('The calls this method makes, when its narrative does not show them (detail: intent, or calls-only with no steps authored) \u2014 each as "<component>.<method>", the spelling the debt register and lint allows name a unit with. The narrative walk takes exactly these edges and no others, so an undeclared collaborator is NOT reached: this is what keeps unused-detection honest at a lower detail dial. Each entry is validated like a call step (the component resolves, this component declares it, the method is on its contract). Refused beside a non-empty narrative \u2014 add the call step there instead')
+    symbol: import_zod12.z.string().optional().describe("Code-level name realizing this contract method in the sourcePath file, when it legitimately differs from the intent-language contract name (e.g. put realized by saveSnapshot)"),
+    exportedVia: import_zod12.z.string().optional().describe("The exported binding a consumer imports to REACH this method, when the realization is published as a value that composes it rather than exported in its own right (a rule module publishes callConformanceRule, and the method is the check inside it). Not symbol, which names the function itself: this names the route to it, so the surface check reads that export as promised. A handle the method's own source file does not actually export is reported (UNREALIZED_EXPORT_HANDLE) and allows nothing"),
+    ext: import_zod12.z.record(import_zod12.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim"),
+    narrative: import_zod12.z.array(narrativeStepInput).optional(),
+    calls: import_zod12.z.array(import_zod12.z.string().min(1)).optional().describe('The calls this method makes, when its narrative does not show them (detail: intent, or calls-only with no steps authored) \u2014 each as "<component>.<method>", the spelling the debt register and lint allows name a unit with. The narrative walk takes exactly these edges and no others, so an undeclared collaborator is NOT reached: this is what keeps unused-detection honest at a lower detail dial. Each entry is validated like a call step (the component resolves, this component declares it, the method is on its contract). Refused beside a non-empty narrative \u2014 add the call step there instead')
   };
   const implMethodInputFields = Object.keys(implMethodShape);
   const implInput = {
-    id: import_zod11.z.string().describe('Lowercase identifier, e.g. "vfs_storage"'),
-    name: import_zod11.z.string().describe("Human-readable implementation name"),
-    description: import_zod11.z.string().describe("Implementation details"),
-    contract: import_zod11.z.string().describe("The L3 Interface contract ID this implements"),
-    sourcePath: import_zod11.z.string().optional().describe("Optional: target source code file path relative to project root \u2014 for a chained subproject's implementation (qualified id), relative to that subproject's root; a path given relative to this root that lands inside the subproject is re-expressed for you"),
-    simPath: import_zod11.z.string().optional().describe("Optional: the committed integration-sim harness file (project-relative; N:1 sharing allowed). The validator proves it exists and its import graph wires the REAL modules (this component + each direct dependency; technology adapters may stay faked) \u2014 running it is CI's job. Declaring the first simPath in a subsystem activates MISSING_INTEGRATION_SIM for its other complete non-leaf implementations"),
-    technologies: import_zod11.z.array(import_zod11.z.union([import_zod11.z.string(), import_zod11.z.object({ name: import_zod11.z.string(), matches: import_zod11.z.array(import_zod11.z.string()).min(1).describe("The tokens the leakage and contract checks match INSTEAD of the name \u2014 for a technology whose name is also an ordinary word of the tree (the yaml package, the YAML format)") }).strict()])).optional().describe(`External technologies this implementation binds to (e.g. ["mysql"], or [{ "name": "yaml", "matches": ["yaml package", "parseDocument"] }] when the bare name would match a common word) \u2014 declares this component's ownership tree as the technology's home; references outside it are flagged (TECH_LEAKAGE) and contract identifiers must stay intent-language. Only for Adapter/Store/Registry/Index components.`),
-    injectedParams: import_zod11.z.array(import_zod11.z.string()).optional().describe("The parameter names this realization takes BEFORE the ones its contract declares \u2014 a config object, a data root, the transport handles a portal is handed. Supplied by whatever wires the component up, never by the caller the contract describes, which is why they belong here and not to the contract: another realization may hold them as fields instead. Declared rather than guessed, because a leading parameter the contract does not name cannot be told from one it named under a different name (`seed(config)` realized as `bootstrapInstance(cfg)`); a leading parameter this list does not name is reported (UNDECLARED_PARAM). Only a LEADING run is dropped \u2014 one of these names appearing after the contract's own parameters is an argument in the middle of the caller's list, not wiring"),
+    id: import_zod12.z.string().describe('Lowercase identifier, e.g. "vfs_storage"'),
+    name: import_zod12.z.string().describe("Human-readable implementation name"),
+    description: import_zod12.z.string().describe("Implementation details"),
+    contract: import_zod12.z.string().describe("The L3 Interface contract ID this implements"),
+    sourcePath: import_zod12.z.string().optional().describe("Optional: target source code file path relative to project root \u2014 for a chained subproject's implementation (qualified id), relative to that subproject's root; a path given relative to this root that lands inside the subproject is re-expressed for you"),
+    simPath: import_zod12.z.string().optional().describe("Optional: the committed integration-sim harness file (project-relative; N:1 sharing allowed). The validator proves it exists and its import graph wires the REAL modules (this component + each direct dependency; technology adapters may stay faked) \u2014 running it is CI's job. Declaring the first simPath in a subsystem activates MISSING_INTEGRATION_SIM for its other complete non-leaf implementations"),
+    technologies: import_zod12.z.array(import_zod12.z.union([import_zod12.z.string(), import_zod12.z.object({ name: import_zod12.z.string(), matches: import_zod12.z.array(import_zod12.z.string()).min(1).describe("The tokens the leakage and contract checks match INSTEAD of the name \u2014 for a technology whose name is also an ordinary word of the tree (the yaml package, the YAML format)") }).strict()])).optional().describe(`External technologies this implementation binds to (e.g. ["mysql"], or [{ "name": "yaml", "matches": ["yaml package", "parseDocument"] }] when the bare name would match a common word) \u2014 declares this component's ownership tree as the technology's home; references outside it are flagged (TECH_LEAKAGE) and contract identifiers must stay intent-language. Only for Adapter/Store/Registry/Index components.`),
+    injectedParams: import_zod12.z.array(import_zod12.z.string()).optional().describe("The parameter names this realization takes BEFORE the ones its contract declares \u2014 a config object, a data root, the transport handles a portal is handed. Supplied by whatever wires the component up, never by the caller the contract describes, which is why they belong here and not to the contract: another realization may hold them as fields instead. Declared rather than guessed, because a leading parameter the contract does not name cannot be told from one it named under a different name (`seed(config)` realized as `bootstrapInstance(cfg)`); a leading parameter this list does not name is reported (UNDECLARED_PARAM). Only a LEADING run is dropped \u2014 one of these names appearing after the contract's own parameters is an argument in the middle of the caller's list, not wiring"),
     detail: detailEnum.optional().describe("Spec-level narrative detail default for all methods"),
     conformance: conformanceEnum.optional().describe("Spec-level conformance tier default: declared | anchored | off (omitted = stereotype default: Portal \u2192 anchored, else declared)"),
-    methods: import_zod11.z.array(import_zod11.z.object(implMethodShape).strict()).optional().describe("Method implementations containing L5 narratives"),
+    methods: import_zod12.z.array(import_zod12.z.object(implMethodShape).strict()).optional().describe("Method implementations containing L5 narratives"),
     status: statusInput
   };
   const implInputFields = Object.keys(implInput);
@@ -43514,46 +44705,46 @@ ${renderChangeReport(report2)}`,
     }
   );
   const typeInput = {
-    kind: import_zod11.z.enum(["entity", "value-object", "signature", "enum"]).describe("entity (owned by a subsystem), value-object (often system-level shared), signature \u2014 a named function type: params and returns, nothing else \u2014 or enum: a closed, ordered set of named values"),
-    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. 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(),
-      type: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The field's type")),
-      description: import_zod11.z.string().optional(),
-      optional: import_zod11.z.boolean().optional(),
-      key: import_zod11.z.enum(["primary", "unique", "foreign"]).optional().describe("Identity marker (PK/unique/FK) for ERD and database schema derivation"),
-      references: import_zod11.z.string().optional().describe('For foreign keys, the referenced type/table id and optional field, e.g. "invoice.id"')
+    kind: import_zod12.z.enum(["entity", "value-object", "signature", "enum"]).describe("entity (owned by a subsystem), value-object (often system-level shared), signature \u2014 a named function type: params and returns, nothing else \u2014 or enum: a closed, ordered set of named values"),
+    id: import_zod12.z.string().describe("Lowercase identifier"),
+    name: import_zod12.z.string().describe("Human-readable name"),
+    description: import_zod12.z.string().optional(),
+    subsystem: import_zod12.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_zod12.z.string().optional().describe("Optional logical group ID to organize this type in subfolders"),
+    fields: import_zod12.z.array(import_zod12.z.object({
+      name: import_zod12.z.string(),
+      type: import_zod12.z.string().describe(TYPE_REF_GRAMMAR("The field's type")),
+      description: import_zod12.z.string().optional(),
+      optional: import_zod12.z.boolean().optional(),
+      key: import_zod12.z.enum(["primary", "unique", "foreign"]).optional().describe("Identity marker (PK/unique/FK) for ERD and database schema derivation"),
+      references: import_zod12.z.string().optional().describe('For foreign keys, the referenced type/table id and optional field, e.g. "invoice.id"')
     }).strict()).optional().describe('Data fields (type is a primitive or a qualified type id, e.g. "billing.Invoice")'),
-    methods: import_zod11.z.array(import_zod11.z.object({
-      name: import_zod11.z.string(),
-      signature: import_zod11.z.string().optional().describe("Prose signature \u2014 only for a method WITHOUT params; with params the server derives and writes the text"),
-      params: import_zod11.z.array(methodParamItem).optional().describe("Structured parameters \u2014 authoritative for type checking; the signature text is derived from them"),
-      returns: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The type the method answers with")),
-      description: import_zod11.z.string().optional(),
-      sourcePath: import_zod11.z.string().optional().describe("Source file realizing this method when the type's own sourcePath does not hold it \u2014 a pure type method often lives apart from the declaration"),
-      symbol: import_zod11.z.string().optional().describe("Code-level name realizing this method when it differs from the method name, e.g. narrative_step.foreignFields realized by narrativeStepForeignFields")
+    methods: import_zod12.z.array(import_zod12.z.object({
+      name: import_zod12.z.string(),
+      signature: import_zod12.z.string().optional().describe("Prose signature \u2014 only for a method WITHOUT params; with params the server derives and writes the text"),
+      params: import_zod12.z.array(methodParamItem).optional().describe("Structured parameters \u2014 authoritative for type checking; the signature text is derived from them"),
+      returns: import_zod12.z.string().describe(TYPE_REF_GRAMMAR("The type the method answers with")),
+      description: import_zod12.z.string().optional(),
+      sourcePath: import_zod12.z.string().optional().describe("Source file realizing this method when the type's own sourcePath does not hold it \u2014 a pure type method often lives apart from the declaration"),
+      symbol: import_zod12.z.string().optional().describe("Code-level name realizing this method when it differs from the method name, e.g. narrative_step.foreignFields realized by narrativeStepForeignFields")
     }).strict()).optional().describe("Pure intrinsic methods only"),
-    componentClass: import_zod11.z.string().optional().describe("Optional component id that implements or owns this logical entity"),
-    invariants: import_zod11.z.array(import_zod11.z.object({
-      id: import_zod11.z.string().describe("Stable invariant id, unique within the entity"),
-      description: import_zod11.z.string().describe("The property that must hold, stated precisely")
+    componentClass: import_zod12.z.string().optional().describe("Optional component id that implements or owns this logical entity"),
+    invariants: import_zod12.z.array(import_zod12.z.object({
+      id: import_zod12.z.string().describe("Stable invariant id, unique within the entity"),
+      description: import_zod12.z.string().describe("The property that must hold, stated precisely")
     }).strict()).optional().describe("Declared domain invariants (entities): every write-effect method of the componentClass must carry a narrative step asserting each (assertsInvariants) \u2014 declarations checked, enforcement never proven"),
-    database: import_zod11.z.string().optional().describe("Optional database id for table-schema types"),
-    table: import_zod11.z.string().optional().describe("Optional database table name for table-schema types"),
-    linkedEntity: import_zod11.z.string().optional().describe("Optional logical entity id represented by this table-schema type"),
-    sourcePath: import_zod11.z.string().optional().describe("Source file holding the declaration of this type (project-relative). Naming one turns the type into a claim on code: the file must resolve and the declaration must be anchored in it (UNREALIZED_TYPE)"),
-    symbol: import_zod11.z.string().optional().describe('Code-level name realizing the declaration when it differs from name, e.g. a type named "Invoice Line" declared as InvoiceLine'),
-    params: import_zod11.z.array(methodParamItem).optional().describe("kind signature only: the function type's parameters, in declared order (SIGNATURE_TYPE_MEMBERS on any other kind)"),
-    returns: import_zod11.z.string().optional().describe(TYPE_REF_GRAMMAR("kind signature only, and required there: the function type's one output")),
-    values: import_zod11.z.array(import_zod11.z.object({
-      name: import_zod11.z.string().min(1).describe(`The value's name, exactly as data carries it ("stable", "local_only")`),
-      description: import_zod11.z.string().optional().describe("What the value means")
+    database: import_zod12.z.string().optional().describe("Optional database id for table-schema types"),
+    table: import_zod12.z.string().optional().describe("Optional database table name for table-schema types"),
+    linkedEntity: import_zod12.z.string().optional().describe("Optional logical entity id represented by this table-schema type"),
+    sourcePath: import_zod12.z.string().optional().describe("Source file holding the declaration of this type (project-relative). Naming one turns the type into a claim on code: the file must resolve and the declaration must be anchored in it (UNREALIZED_TYPE)"),
+    symbol: import_zod12.z.string().optional().describe('Code-level name realizing the declaration when it differs from name, e.g. a type named "Invoice Line" declared as InvoiceLine'),
+    params: import_zod12.z.array(methodParamItem).optional().describe("kind signature only: the function type's parameters, in declared order (SIGNATURE_TYPE_MEMBERS on any other kind)"),
+    returns: import_zod12.z.string().optional().describe(TYPE_REF_GRAMMAR("kind signature only, and required there: the function type's one output")),
+    values: import_zod12.z.array(import_zod12.z.object({
+      name: import_zod12.z.string().min(1).describe(`The value's name, exactly as data carries it ("stable", "local_only")`),
+      description: import_zod12.z.string().optional().describe("What the value means")
     }).strict()).optional().describe("kind enum only, and required there: the values in declared order \u2014 the order is part of the design (a narrowest-first track list means something). Unique by name ignoring case and separators; no ordinals and no separate wire value"),
-    holds: import_zod11.z.string().optional().describe('kind value-object only: makes it a NAMED SCALAR \u2014 one primitive under a name (string, int, float, bool, bytes, date, datetime or duration), a newtype or type alias in every language (`type PackPath = string`), declared in place of fields. Not a union, not a named type, not any; fields beside it, or holds on another kind, is NAMED_SCALAR_MEMBERS. Aliases are respelled (boolean \u2192 bool) and number is refused ("int or float?")')
+    holds: import_zod12.z.string().optional().describe('kind value-object only: makes it a NAMED SCALAR \u2014 one primitive under a name (string, int, float, bool, bytes, date, datetime or duration), a newtype or type alias in every language (`type PackPath = string`), declared in place of fields. Not a union, not a named type, not any; fields beside it, or holds on another kind, is NAMED_SCALAR_MEMBERS. Aliases are respelled (boolean \u2192 bool) and number is refused ("int or float?")')
   };
   const typeInputFields = Object.keys(typeInput);
   reg(
@@ -43610,9 +44801,9 @@ ${renderChangeReport(report2)}`,
     {
       description: "Validate the SDD spec tree, checking parent references, contract compatibility, narratives, and component type boundaries. Supports scoping and recursion controls. Findings come back as structured content too, under the schema this tool declares \u2014 errors, warnings and notices already split into three lists (a notice never makes the tree invalid and never fails --ci), each with its code, severity, message and the spec it concerns \u2014 so a caller filters them as objects instead of parsing the JSON text block and hoping its shape holds.",
       inputSchema: {
-        subsystem: import_zod11.z.string().optional().describe("Only validate the specified subsystem (granular)"),
-        recursive: import_zod11.z.boolean().optional().describe("At a project that declares members: the family run (true, the default) or the owner's gate alone (false)"),
-        family: import_zod11.z.boolean().optional().describe("Ask for the family run explicitly: every member's own gate, and this project's externals composed against their live producers within the request's reach (`wairon validate --family`)")
+        subsystem: import_zod12.z.string().optional().describe("Only validate the specified subsystem (granular)"),
+        recursive: import_zod12.z.boolean().optional().describe("At a project that declares members: the family run (true, the default) or the owner's gate alone (false)"),
+        family: import_zod12.z.boolean().optional().describe("Ask for the family run explicitly: every member's own gate, and this project's externals composed against their live producers within the request's reach (`wairon validate --family`)")
       },
       outputSchema: validateTreeOutput
     },
@@ -43653,9 +44844,9 @@ ${renderChangeReport(report2)}`,
     {
       description: `Get/read the parsed JSON contents of a specific spec from the spec tree. Returns structural contents without file system path searching. Pass "methods" to read only the named methods of a contract, an implementation or a type \u2014 a 45-method spec fetched whole to look at one of them is the read side of the same waste a restatement is on the write side; the answer then carries a "partialResult" marker naming what was left out, and must never be re-authored from. For a variant-tagged COMPONENT the result also carries a derived, read-only "variantGuidance" (the variant's base, its implementation guidance, and the same-variant sibling components to implement alike) \u2014 it is resolved from the variant registry, not part of the spec, so never write it back. A contract's methods come back in their STORED form \u2014 a method that takes its signature from a source carries its signatureFrom, not the params the loader resolves into it \u2014 so the answer can be re-authored from as it is; the resolved params, returns and text of each such method come back as a derived, read-only "resolvedSignatures" marker. The structured content carries the same answer with the derived markers KEPT SEPARATE from the stored spec ({kind, id, spec, partialResult?, variantGuidance?, resolvedSignatures?}), so nothing derived can be mistaken for something stored; the text block folds them in as it always has.`,
       inputSchema: {
-        kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The kind of specification"),
-        id: import_zod11.z.string().describe('The identifier of the spec to fetch (the L0 system spec is a singleton \u2014 pass the system name or "system")'),
-        methods: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe("Return only these methods by name; every other field of the spec comes back unchanged. Only an interface, an implementation or a type declares methods \u2014 asking for one elsewhere is refused, as is a name the spec does not declare (the answer names the ones it does). Omit it for the whole spec.")
+        kind: import_zod12.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The kind of specification"),
+        id: import_zod12.z.string().describe('The identifier of the spec to fetch (the L0 system spec is a singleton \u2014 pass the system name or "system")'),
+        methods: import_zod12.z.array(import_zod12.z.string().min(1)).optional().describe("Return only these methods by name; every other field of the spec comes back unchanged. Only an interface, an implementation or a type declares methods \u2014 asking for one elsewhere is refused, as is a name the spec does not declare (the answer names the ones it does). Omit it for the whole spec.")
       },
       outputSchema: getSpecOutput
     },
@@ -43740,8 +44931,8 @@ ${renderChangeReport(report2)}`,
     {
       description: "Delete a specification file from the spec tree and clean up any empty parent directories. Answers with a structured deletion beside the sentence: whether a spec was removed, and the tests that encode a method the deletion took away (when the project declares test roots).",
       inputSchema: {
-        kind: import_zod11.z.enum(["subsystem", "component", "interface", "implementation", "type"]).describe("The kind of spec to delete"),
-        id: import_zod11.z.string().describe("The ID of the spec to delete")
+        kind: import_zod12.z.enum(["subsystem", "component", "interface", "implementation", "type"]).describe("The kind of spec to delete"),
+        id: import_zod12.z.string().describe("The ID of the spec to delete")
       },
       outputSchema: specDeletionOutput
     },
@@ -43763,17 +44954,17 @@ ${testsBlock}` : ""}`, deletion);
     {
       description: "Update/patch an existing SDD specification (subsystem, component, interface, implementation, or type) using a granular delta. Updates fields, appends/merges array elements, or inserts/deletes narrative steps. Answers with exactly what changed, and with every path the delta named that the write did not act on. Type positions (the type of a param, a returns, the type of a field, the params and returns of a signature) are written in the neutral type grammar: an alias the delta writes (string[], T | null, boolean, Promise<T>) is stored canonical and listed under `respellings`, and a stored alias at a position the write keeps is respelled with it; a position the delta writes that has no canonical spelling (number \u2014 int or float?, an inline object or function type, a literal union, a union mixing in a primitive) is refused, naming the replacement, while one the stored spec already held is left alone. Pass dryRun to be told what it would do without writing it.",
       inputSchema: {
-        kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project export table, each entry a re-export {from, component, interface, typeDef, as, name, type, details, audience: project|department|instance|partner|external} \u2014 from alone re-exports everything a subsystem exports, and a legacy {id, subsystem} reads as {as, from})"),
-        id: import_zod11.z.string().describe("The ID of the spec to update (namespaced if needed)"),
-        delta: import_zod11.z.record(import_zod11.z.any()).describe(`The partial fields to merge into the spec. ARRAYS UPSERT, they do not replace: an array whose elements carry an identity is merged element-by-element, so a delta naming ONE element leaves the others intact. Identity is "name" or "id" by default, and per field: dispatch by "capability", a listener's mounts by "portal", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", a subsystem's publicInterfaces by component+interface (or type+details for an entry not yet bound to a component, and by from+item+interface+as for a re-export or a type export), invariants and patterns by "id", lint.allow by "code" AND "at" (an allow covers one occurrence, so several may share a code on one spec), an interface method's findings by "code", boundaries by "name", globalRequirements by "description", switch cases by "value", try catches by "error". Identity merging applies at EVERY depth, including an array INSIDE an element (a method's params, a step's catches). Add "action: 'delete'" (or "remove: true") alongside that identity to REMOVE an element \u2014 including a stale lint allow. Arrays of plain STRINGS (owns, dependsOn, guarantees) carry no per-element identity and are replaced wholesale; pass [] to clear any array outright. To REMOVE an optional field entirely, list it in "unset": e.g. {"unset": ["basePath", "variant"]} \u2014 passing null/undefined means "no change" (they are skipped), and writing "" would leave the field present but empty, which is a different and usually wrong spec. Unsetting a required field is refused by schema validation, which names it. For narrative steps, match by "stepNumber" and use "action: 'insert'" (shifts subsequent steps up) or "action: 'delete'" (shifts subsequent steps down and removes it). Step entries apply in ASCENDING stepNumber order, each against the numbering the earlier entries of the SAME delta left behind \u2014 delete step 3 and step 7 becomes step 6 \u2014 so prefer labels, and restate the step's "label" or "description" on a delete to have it checked against the step actually addressed. Renumbering RELOCATES every flow jump field (onTrueStep/onFalseStep/cases.step/defaultStep/endStep/catches.step/finallyStep/toStep) in the same narrative. Only STORED jumps relocate: a jump the delta itself writes (on an inserted, appended or edited step) names its target in the numbering the WHOLE delta leaves behind, after all of its inserts and deletes, and no later step of the same delta moves it. A method the delta ADDS without a narrative is an intent-level method with none ([]). An element the delta NAMES merges field by field: a field it leaves out, or passes as null, keeps its stored value at EVERY depth (a method named without "narrative" keeps its steps, a step named without "catches" keeps them), while "narrative": [] CLEARS that method's steps \u2014 so leave a method you are not editing out of the delta. A delete is REJECTED when the narrative has no such step, when a jump still targets it (retarget the referrers first), when a restated label/description does not match, or when it is a loop/try/parallel header whose body would be left standing (retype the header first to dissolve the region, then delete it). Changing a step's "type" REBUILDS it for the new type: its description and label are kept and every field the new type cannot carry is dropped (returned as a NOTICE); a delta that retypes AND sets such a field is refused. A step delta is also refused when it carries a marker the merge does not recognise: a non-boolean "remove", an "action" that is neither "insert" nor "delete", a "captureJumps" outside an insert, or no "stepNumber" to address. Inserting AT a jump target relocates those jumps past the inserted step by default (a NOTICE is returned) \u2014 add "captureJumps": true on the inserted step to retarget entry jumps onto it (loop/try endStep region tails always relocate with the body and are never captured). Every jump field has a "*Label" twin (toLabel, onFalseLabel, endLabel, \u2026, and "label" on a cases/catches entry) resolved against step labels AFTER the merge, so a delta may anchor on a label only pre-existing steps carry; a label the delta supplies REPLACES the stored number it twins, while setting the number and its label together in one delta is refused as a contradiction. Reference ids in deltas may use LOCAL names \u2014 they are qualified against the spec's namespace exactly as the loader would. Per-spec lint suppression: set "lint: { allow: [{ code, at, covers, reason }] }" to silence a WARNING or NOTICE code on this spec only (errors always surface; stale allows are flagged). An allow covers EXACTLY the occurrence it names: "at" is the site the finding names (a contract method, an import edge "from -> to", a declared edge "component -> target") and is REQUIRED for a code whose findings report one, while a finding that reports no site is covered only by an allow that names none; "covers" lists the units an aggregating finding reports, and the allow silences it only when every one is listed. This delta is deliberately OPEN below its top level \u2014 the shapes nest further than a schema here should restate \u2014 so a key that is not a field at its depth is not refused, it is NAMED BACK under NO EFFECT in the answer, together with any value the spec already held and any "unset" that removed nothing. Read that list: it is where a nested typo shows up.`),
-        dryRun: import_zod11.z.boolean().optional().describe("Ask what this delta WOULD do instead of doing it. The whole write runs, the candidate gate included, and the answer is the change report it would have produced \u2014 marked DRY RUN, with nothing stamped and not one byte of the stored file moved. Use it before a delta that renumbers a long narrative.")
+        kind: import_zod12.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project export table, each entry a re-export {from, component, interface, typeDef, as, name, type, details, audience: project|department|instance|partner|external} \u2014 from alone re-exports everything a subsystem exports, and a legacy {id, subsystem} reads as {as, from})"),
+        id: import_zod12.z.string().describe("The ID of the spec to update (namespaced if needed)"),
+        delta: import_zod12.z.record(import_zod12.z.any()).describe(`The partial fields to merge into the spec. ARRAYS UPSERT, they do not replace: an array whose elements carry an identity is merged element-by-element, so a delta naming ONE element leaves the others intact. Identity is "name" or "id" by default, and per field: dispatch by "capability", a listener's mounts by "portal", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", a subsystem's publicInterfaces by component+interface (or type+details for an entry not yet bound to a component, and by from+item+interface+as for a re-export or a type export), invariants and patterns by "id", lint.allow by "code" AND "at" (an allow covers one occurrence, so several may share a code on one spec), an interface method's findings by "code", boundaries by "name", globalRequirements by "description", switch cases by "value", try catches by "error". Identity merging applies at EVERY depth, including an array INSIDE an element (a method's params, a step's catches). Add "action: 'delete'" (or "remove: true") alongside that identity to REMOVE an element \u2014 including a stale lint allow. Arrays of plain STRINGS (owns, dependsOn, guarantees) carry no per-element identity and are replaced wholesale; pass [] to clear any array outright. To REMOVE an optional field entirely, list it in "unset": e.g. {"unset": ["basePath", "variant"]} \u2014 passing null/undefined means "no change" (they are skipped), and writing "" would leave the field present but empty, which is a different and usually wrong spec. Unsetting a required field is refused by schema validation, which names it. For narrative steps, match by "stepNumber" and use "action: 'insert'" (shifts subsequent steps up) or "action: 'delete'" (shifts subsequent steps down and removes it). Step entries apply in ASCENDING stepNumber order, each against the numbering the earlier entries of the SAME delta left behind \u2014 delete step 3 and step 7 becomes step 6 \u2014 so prefer labels, and restate the step's "label" or "description" on a delete to have it checked against the step actually addressed. Renumbering RELOCATES every flow jump field (onTrueStep/onFalseStep/cases.step/defaultStep/endStep/catches.step/finallyStep/toStep) in the same narrative. Only STORED jumps relocate: a jump the delta itself writes (on an inserted, appended or edited step) names its target in the numbering the WHOLE delta leaves behind, after all of its inserts and deletes, and no later step of the same delta moves it. A method the delta ADDS without a narrative is an intent-level method with none ([]). An element the delta NAMES merges field by field: a field it leaves out, or passes as null, keeps its stored value at EVERY depth (a method named without "narrative" keeps its steps, a step named without "catches" keeps them), while "narrative": [] CLEARS that method's steps \u2014 so leave a method you are not editing out of the delta. A delete is REJECTED when the narrative has no such step, when a jump still targets it (retarget the referrers first), when a restated label/description does not match, or when it is a loop/try/parallel header whose body would be left standing (retype the header first to dissolve the region, then delete it). Changing a step's "type" REBUILDS it for the new type: its description and label are kept and every field the new type cannot carry is dropped (returned as a NOTICE); a delta that retypes AND sets such a field is refused. A step delta is also refused when it carries a marker the merge does not recognise: a non-boolean "remove", an "action" that is neither "insert" nor "delete", a "captureJumps" outside an insert, or no "stepNumber" to address. Inserting AT a jump target relocates those jumps past the inserted step by default (a NOTICE is returned) \u2014 add "captureJumps": true on the inserted step to retarget entry jumps onto it (loop/try endStep region tails always relocate with the body and are never captured). Every jump field has a "*Label" twin (toLabel, onFalseLabel, endLabel, \u2026, and "label" on a cases/catches entry) resolved against step labels AFTER the merge, so a delta may anchor on a label only pre-existing steps carry; a label the delta supplies REPLACES the stored number it twins, while setting the number and its label together in one delta is refused as a contradiction. Reference ids in deltas may use LOCAL names \u2014 they are qualified against the spec's namespace exactly as the loader would. Per-spec lint suppression: set "lint: { allow: [{ code, at, covers, reason }] }" to silence a WARNING or NOTICE code on this spec only (errors always surface; stale allows are flagged). An allow covers EXACTLY the occurrence it names: "at" is the site the finding names (a contract method, an import edge "from -> to", a declared edge "component -> target") and is REQUIRED for a code whose findings report one, while a finding that reports no site is covered only by an allow that names none; "covers" lists the units an aggregating finding reports, and the allow silences it only when every one is listed. This delta is deliberately OPEN below its top level \u2014 the shapes nest further than a schema here should restate \u2014 so a key that is not a field at its depth is not refused, it is NAMED BACK under NO EFFECT in the answer, together with any value the spec already held and any "unset" that removed nothing. Read that list: it is where a nested typo shows up.`),
+        dryRun: import_zod12.z.boolean().optional().describe("Ask what this delta WOULD do instead of doing it. The whole write runs, the candidate gate included, and the answer is the change report it would have produced \u2014 marked DRY RUN, with nothing stamped and not one byte of the stored file moved. Use it before a delta that renumbers a long narrative.")
       },
       outputSchema: specChangeReportOutput
     },
     ({ kind, id, delta, dryRun }) => {
       try {
-        const report2 = updateSpecGated(kind, id, delta, dryRun);
-        return structured(renderChangeReport(report2), report2);
+        const report3 = updateSpecGated(kind, id, delta, dryRun);
+        return structured(renderChangeReport(report3), report3);
       } catch (e) {
         return errText(String(e));
       }
@@ -43785,8 +44976,8 @@ ${testsBlock}` : ""}`, deletion);
     {
       description: "Get the completeness status dashboard of the SDD spec tree. Supports scoping and recursion controls.",
       inputSchema: {
-        subsystem: import_zod11.z.string().optional().describe("Only show status for the specified subsystem"),
-        recursive: import_zod11.z.boolean().optional().describe("Whether to descend into the members this project declares (default: true)")
+        subsystem: import_zod12.z.string().optional().describe("Only show status for the specified subsystem"),
+        recursive: import_zod12.z.boolean().optional().describe("Whether to descend into the members this project declares (default: true)")
       }
     },
     ({ subsystem, recursive }) => {
@@ -43800,14 +44991,14 @@ ${testsBlock}` : ""}`, deletion);
         } catch {
           approvals = void 0;
         }
-        const report2 = getStatusReport({
+        const report3 = getStatusReport({
           subsystem,
           memberDepth,
           approvals
         });
         const family = statusFamilyContext();
         const verdict = approvalVerdict(approvals);
-        return text2(`${banner}${family}${report2.text}${verdict.text}`);
+        return text2(`${banner}${family}${report3.text}${verdict.text}`);
       } catch (e) {
         return errText(`${banner}${String(e)}`);
       }
@@ -43819,7 +45010,7 @@ ${testsBlock}` : ""}`, deletion);
     {
       description: "Pin the bound project's declared externals (.wai/project.yaml `externals`) \u2014 the named aliases, else all \u2014 into .wai/externals/<alias>.yaml and .wai/externals.lock.yaml, recording the signature digest of every member the project's references use. Answers one outcome per alias (pinned, unchanged, unresolved, unreachable) with the references that land on no public name of the producer (export them from its L0 to pin them). A tree-scoped write: a producer the request may not read is reported unreachable, never read.",
       inputSchema: {
-        aliases: import_zod11.z.array(import_zod11.z.string()).optional().describe("The aliases to pin; all declared externals when omitted")
+        aliases: import_zod12.z.array(import_zod12.z.string()).optional().describe("The aliases to pin; all declared externals when omitted")
       },
       outputSchema: externalPinsOutput
     },
@@ -43856,7 +45047,7 @@ ${testsBlock}` : ""}`, deletion);
     {
       description: "Compose the LIVE delegation brief for one resolved agent: the fully rendered instruction body plus the ownedPaths/readPaths scope fence \u2014 the dynamic replacement for generated per-component agent files. Fetch a brief and spawn a generic subagent with it: always fresh after a re-lock, no session restart needed. List agent ids via listAgents or resources/list (the wairon-agent:// entries).",
       inputSchema: {
-        agentId: import_zod11.z.string().describe("The resolved agent id (list via listAgents or resources/list)")
+        agentId: import_zod12.z.string().describe("The resolved agent id (list via listAgents or resources/list)")
       }
     },
     ({ agentId }) => {
@@ -43918,9 +45109,30 @@ function loadProjectConfig3() {
   CustomTargetConfigSchema,
   CustomTargetSchema,
   DEFAULT_TARGET_DIRS,
+  DESIGN_APPROVALS,
+  DESIGN_DEPENDENCY_ROLES,
+  DESIGN_FORMAT,
+  DESIGN_FORMAT_VERSION,
   DatabaseSpecSchema,
   DependencyClassSchema,
+  DesignApprovalSchema,
+  DesignComponentSchema,
+  DesignDependencyRoleSchema,
+  DesignDependencySchema,
   DesignDepthSchema,
+  DesignExportEntrySchema,
+  DesignExportSchema,
+  DesignFieldSchema,
+  DesignImplementationSchema,
+  DesignInterfaceSchema,
+  DesignMethodBodySchema,
+  DesignMethodSchema,
+  DesignParamSchema,
+  DesignProjectSchema,
+  DesignSourceSchema,
+  DesignSubsystemSchema,
+  DesignTypeRefSchema,
+  DesignTypeSchema,
   DiagramConfigSchema,
   DispatchBindingSchema,
   DoctorOptionsError,
@@ -43980,6 +45192,8 @@ function loadProjectConfig3() {
   PortalAuthSchemeSchema,
   PortalMountSchema,
   PortalTypeSchema,
+  PreviousIdsSchema,
+  PreviousNamesSchema,
   ProfileSelectionSubjectSchema,
   ProjectConfigSchema,
   ProjectNotInitializedError,
@@ -44023,6 +45237,7 @@ function loadProjectConfig3() {
   TopologyConfigSchema,
   TransportSchema,
   TrustedLinkSchema,
+  TypeExpressionSchema,
   TypeFieldSchema,
   TypeKindSchema,
   TypeMethodSchema,
@@ -44110,6 +45325,7 @@ function loadProjectConfig3() {
   ensureDir,
   ensureProjectInitialized,
   excerptParent,
+  exportDesign,
   exportSpecTree,
   exportTargetKey,
   exportUsage,
@@ -44259,6 +45475,7 @@ function loadProjectConfig3() {
   renameComponent,
   renameId,
   renameMethod,
+  renameType,
   renderDiagram,
   repairForeignStepFields,
   repairSignatures,
@@ -44298,6 +45515,7 @@ function loadProjectConfig3() {
   settledSpecPaths,
   signatureFacts,
   signatureTypeRefs,
+  specIndexRetiredBy,
   specPathsInScope,
   splitNamespace,
   stepConfigVerdict,