@wairon/cli 5.1.1-dev.94 → 5.1.1-dev.95

package/dist/index.js

@@ -3484,6 +3484,10 @@ __export(src_exports, {
   RETIRED_STEREOTYPES: () => RETIRED_STEREOTYPES,
   RegistrySchema: () => RegistrySchema,
   RequirementItemSchema: () => RequirementItemSchema,
+  ResolvedInterfaceSpecSchema: () => ResolvedInterfaceSpecSchema,
+  ResolvedMethodSignatureSchema: () => ResolvedMethodSignatureSchema,
+  ResolvedTypeMethodSchema: () => ResolvedTypeMethodSchema,
+  ResolvedTypeSpecSchema: () => ResolvedTypeSpecSchema,
   RulesConfigSchema: () => RulesConfigSchema,
   SCAN_EXCLUDE_DIRS: () => SCAN_EXCLUDE_DIRS,
   SDD_RULES: () => SDD_RULES,
@@ -3495,6 +3499,8 @@ __export(src_exports, {
   SURFACE_AUDIENCES: () => SURFACE_AUDIENCES,
   SpecIdSchema: () => SpecIdSchema,
   SpecStatusSchema: () => SpecStatusSchema,
+  StoredMethodSignatureSchema: () => StoredMethodSignatureSchema,
+  StoredTypeMethodSchema: () => StoredTypeMethodSchema,
   SubsystemSpecSchema: () => SubsystemSpecSchema,
   SurfaceAudienceSchema: () => SurfaceAudienceSchema,
   SurfaceContractEntrySchema: () => SurfaceContractEntrySchema,
@@ -3579,6 +3585,8 @@ __export(src_exports, {
   dependencyCycles: () => dependencyCycles,
   deregisterPackRef: () => deregisterPackRef,
   deriveExecutionProfile: () => deriveExecutionProfile,
+  deriveMethodSignature: () => deriveMethodSignature,
+  deriveTypeSignature: () => deriveTypeSignature,
   derivedDocPaths: () => derivedDocPaths,
   describeProject: () => describeProject,
   detectDomainCandidates: () => detectDomainCandidates,
@@ -3738,6 +3746,7 @@ __export(src_exports, {
   renameMethod: () => renameMethod,
   renderDiagram: () => renderDiagram,
   repairForeignStepFields: () => repairForeignStepFields,
+  repairSignatures: () => repairSignatures,
   repointExternal: () => repointExternal,
   requiredPolicies: () => requiredPolicies,
   resolveAgentTopology: () => resolveAgentTopology,
@@ -3749,6 +3758,7 @@ __export(src_exports, {
   resolveImport: () => resolveImport,
   resolveInstalledPack: () => resolveInstalledPack,
   resolveProjectExports: () => resolveProjectExports,
+  resolveSignatures: () => resolveTree,
   resolveSubprojectForNamespace: () => resolveSubprojectForNamespace,
   resolveSubsystemExports: () => resolveSubsystemExports,
   resolveVariantGuidance: () => resolveVariantGuidance,
@@ -3770,11 +3780,15 @@ __export(src_exports, {
   setProjectRoot: () => setProjectRoot,
   setProjectType: () => setProjectType,
   settledSpecPaths: () => settledSpecPaths,
+  signatureFacts: () => signatureFacts,
+  signatureTypeRefs: () => signatureTypeRefs,
   specPathsInScope: () => specPathsInScope,
   splitNamespace: () => splitNamespace,
   stepConfigVerdict: () => stepConfigVerdict,
   stepFieldsFor: () => stepFieldsFor,
   stepGraph: () => stepGraph,
+  storedMethodSignature: () => storedMethodSignature,
+  storedTypeMethod: () => storedTypeMethod,
   syncContextFiles: () => syncContextFiles,
   technologyName: () => technologyName,
   technologyTokens: () => technologyTokens,
@@ -7094,13 +7108,21 @@ var FindingDeclarationSchema = import_zod8.z.object({
 var MethodSignatureSchema = import_zod8.z.object({
   name: import_zod8.z.string().regex(/^[a-zA-Z0-9_]+$/, "Method name must be alphanumeric"),
   description: import_zod8.z.string(),
-  signature: import_zod8.z.string(),
+  signature: import_zod8.z.string().optional(),
   // e.g. "save(key: string, data: Buffer): Promise<void>"
   // e.g. "Promise<void>", or a union: "Invoice | null" — the commonest shape in
   // any real tree. See the grammar on src/models/type-references.ts.
-  returns: import_zod8.z.string(),
+  returns: import_zod8.z.string().optional(),
   /** Structured parameters (authoritative for type checking when present). */
   params: import_zod8.z.array(MethodParamSchema).optional(),
+  /**
+   * Where this method takes its params and returns from instead of stating
+   * them: a signature type (`billing.change_listener`, `alias::name`), or a
+   * contract method `component.method` its component reaches along a
+   * dependsOn/owns edge. Resolved both ways by the loader (signature_resolver);
+   * the writer stores a sourced method with only its source.
+   */
+  signatureFrom: import_zod8.z.string().min(1).optional(),
   /** Concrete wire binding for this method when its component is a Portal (set via sdd_set_endpoints). */
   endpoint: EndpointSchema.optional(),
   /**
@@ -7153,6 +7175,54 @@ var MethodSignatureSchema = import_zod8.z.object({
   /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
   ext: ExtDataSchema.optional()
 });
+function requireStoredSignature(method, ctx) {
+  if (method.signatureFrom !== void 0) return;
+  if (method.returns === void 0) {
+    ctx.addIssue({ code: import_zod8.z.ZodIssueCode.custom, path: ["returns"], message: "Required: a method without a signatureFrom states its returns" });
+  }
+  if (method.params === void 0 && method.signature === void 0) {
+    ctx.addIssue({ code: import_zod8.z.ZodIssueCode.custom, path: ["signature"], message: "Required: a method without params or a signatureFrom states a prose signature" });
+  }
+}
+var StoredMethodSignatureSchema = MethodSignatureSchema.superRefine(requireStoredSignature);
+var ResolvedMethodSignatureSchema = MethodSignatureSchema.extend({
+  signature: import_zod8.z.string(),
+  returns: import_zod8.z.string()
+});
+function paramText(p) {
+  return `${p.name}${p.optional ? "?" : ""}: ${p.type}`;
+}
+function leadingGenericList(name, stored) {
+  if (!stored) return "";
+  const text3 = stored.trimStart();
+  if (!text3.startsWith(name)) return "";
+  let i = name.length;
+  while (text3[i] === " ") i++;
+  if (text3[i] !== "<") return "";
+  let depth = 0;
+  for (let j = i; j < text3.length; j++) {
+    if (text3[j] === "<") depth++;
+    else if (text3[j] === ">") depth--;
+    if (depth === 0) {
+      const rest = text3.slice(j + 1).trimStart();
+      return rest.startsWith("(") ? text3.slice(i, j + 1) : "";
+    }
+  }
+  return "";
+}
+function deriveMethodSignature(method) {
+  if (!method.params) return void 0;
+  const generics = leadingGenericList(method.name, method.signature);
+  return `${method.name}${generics}(${method.params.map(paramText).join(", ")}): ${method.returns ?? "unknown"}`;
+}
+function storedMethodSignature(method) {
+  if (method.signatureFrom !== void 0) {
+    const { params: _params, returns: _returns, signature: _signature, ...rest } = method;
+    return rest;
+  }
+  const derived = deriveMethodSignature(method);
+  return derived === void 0 ? method : { ...method, signature: derived };
+}
 var INTENT_FLOOR_MIN_CHARS = 40;
 function passesIntentFloor(text3, methodName) {
   if (!text3) return false;
@@ -7168,7 +7238,7 @@ var InterfaceSpecSchema = import_zod8.z.object({
   description: import_zod8.z.string(),
   component: import_zod8.z.string(),
   // References L2 Component id
-  methods: import_zod8.z.array(MethodSignatureSchema).default([]),
+  methods: import_zod8.z.array(StoredMethodSignatureSchema).default([]),
   /** Per-spec lint suppressions (see LintConfigSchema). */
   lint: LintConfigSchema.optional(),
   /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
@@ -7177,6 +7247,9 @@ var InterfaceSpecSchema = import_zod8.z.object({
   createdAt: import_zod8.z.string().datetime(),
   updatedAt: import_zod8.z.string().datetime()
 });
+var ResolvedInterfaceSpecSchema = InterfaceSpecSchema.extend({
+  methods: import_zod8.z.array(ResolvedMethodSignatureSchema).default([])
+});
 var NarrativeStepTypeSchema = import_zod8.z.enum([
   "local",
   // in-component work
@@ -7514,7 +7587,7 @@ function implementationSourceFiles(impl) {
   for (const method of impl.methods ?? []) add2(method.sourcePath);
   return files;
 }
-var TypeKindSchema = import_zod8.z.enum(["entity", "value-object"]);
+var TypeKindSchema = import_zod8.z.enum(["entity", "value-object", "signature"]);
 var TypeFieldSchema = import_zod8.z.object({
   name: import_zod8.z.string(),
   // A primitive, or another type id (qualified across subsystems, e.g.
@@ -7538,7 +7611,9 @@ var TypeFieldSchema = import_zod8.z.object({
 });
 var TypeMethodSchema = import_zod8.z.object({
   name: import_zod8.z.string(),
-  signature: import_zod8.z.string(),
+  signature: import_zod8.z.string().optional(),
+  /** Structured parameters in the contract method's param shape — authoritative for type checking when present. */
+  params: import_zod8.z.array(MethodParamSchema).optional(),
   returns: import_zod8.z.string(),
   description: import_zod8.z.string().optional(),
   /**
@@ -7557,6 +7632,14 @@ var TypeMethodSchema = import_zod8.z.object({
    */
   symbol: import_zod8.z.string().optional()
 });
+var ResolvedTypeMethodSchema = TypeMethodSchema.extend({
+  signature: import_zod8.z.string()
+});
+var StoredTypeMethodSchema = TypeMethodSchema.superRefine((method, ctx) => {
+  if (method.params === void 0 && method.signature === void 0) {
+    ctx.addIssue({ code: import_zod8.z.ZodIssueCode.custom, path: ["signature"], message: "Required: a type method without params states a prose signature" });
+  }
+});
 var InvariantSchema = import_zod8.z.object({
   /** Stable invariant id, unique within the entity (referenced as "<type-id>.<invariant-id>"). */
   id: SpecIdSchema,
@@ -7565,7 +7648,7 @@ var InvariantSchema = import_zod8.z.object({
 });
 var TypeSpecSchema = import_zod8.z.object({
   kind: TypeKindSchema,
-  // discriminator — entity | value-object
+  // discriminator — entity | value-object | signature
   id: SpecIdSchema,
   name: import_zod8.z.string(),
   description: import_zod8.z.string().optional(),
@@ -7575,7 +7658,7 @@ var TypeSpecSchema = import_zod8.z.object({
   group: import_zod8.z.string().optional(),
   fields: import_zod8.z.array(TypeFieldSchema).default([]),
   /** Pure intrinsic behaviour only — anything needing a collaborator belongs on a component. */
-  methods: import_zod8.z.array(TypeMethodSchema).default([]),
+  methods: import_zod8.z.array(StoredTypeMethodSchema).default([]),
   /**
    * Linked Component ID if this system entity is implemented as a class Component
    * (e.g., a Store or Registry that owns this entity's lifecycle and methods).
@@ -7621,9 +7704,27 @@ var TypeSpecSchema = import_zod8.z.object({
   lint: LintConfigSchema.optional(),
   /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
   ext: ExtDataSchema.optional(),
+  /**
+   * A signature's parameters, in the contract method's param shape; only on
+   * kind signature (SIGNATURE_TYPE_MEMBERS otherwise).
+   */
+  params: import_zod8.z.array(MethodParamSchema).optional(),
+  /** A signature's one output type; required on kind signature and only there (SIGNATURE_TYPE_MEMBERS). */
+  returns: import_zod8.z.string().optional(),
   createdAt: import_zod8.z.string().datetime(),
   updatedAt: import_zod8.z.string().datetime()
 });
+var ResolvedTypeSpecSchema = TypeSpecSchema.extend({
+  methods: import_zod8.z.array(ResolvedTypeMethodSchema).default([])
+});
+function deriveTypeSignature(type) {
+  if (type.kind !== "signature") return void 0;
+  return `(${(type.params ?? []).map(paramText).join(", ")}): ${type.returns ?? "unknown"}`;
+}
+function storedTypeMethod(method) {
+  const derived = deriveMethodSignature(method);
+  return derived === void 0 ? method : { ...method, signature: derived };
+}
 function typeSourceFiles(type) {
   const files = [];
   const add2 = (file) => {
@@ -7643,7 +7744,16 @@ var SurfaceTypeDefSchema = import_zod8.z.object({
     type: import_zod8.z.string(),
     description: import_zod8.z.string().optional(),
     optional: import_zod8.z.boolean().optional()
-  })).default([])
+  })).default([]),
+  /** A signature's parameters (name, type, optional, description) in declared order; only on kind signature. */
+  params: import_zod8.z.array(import_zod8.z.object({
+    name: import_zod8.z.string(),
+    type: import_zod8.z.string(),
+    description: import_zod8.z.string().optional(),
+    optional: import_zod8.z.boolean().optional()
+  })).optional(),
+  /** A signature's one output type; only on kind signature. */
+  returns: import_zod8.z.string().optional()
 });
 var SurfaceTypeExportSchema = import_zod8.z.object({
   /** The type's public name in the producer's export table. */
@@ -7662,8 +7772,8 @@ var SurfaceContractEntrySchema = import_zod8.z.object({
   type: import_zod8.z.string().default("Custom"),
   /** Local name of the backing Portal in the producing project. */
   component: import_zod8.z.string(),
-  /** Full contract methods (params, returns, guarantees, effect, endpoint). */
-  methods: import_zod8.z.array(MethodSignatureSchema).default([]),
+  /** Full contract methods (params, returns, guarantees, effect, endpoint), resolved: a snapshot names no producer-internal source. */
+  methods: import_zod8.z.array(ResolvedMethodSignatureSchema).default([]),
   /** The backing portal's capability dispatch table, when generic-dispatch. */
   dispatch: import_zod8.z.array(DispatchBindingSchema).optional(),
   details: import_zod8.z.string().default(""),
@@ -7913,13 +8023,18 @@ function methodTypeRefs(m) {
     for (const p of m.params) {
       refs.push(...extractTypeIdentifiers(p.type));
     }
-    refs.push(...extractTypeIdentifiers(m.returns));
+    refs.push(...extractTypeIdentifiers(m.returns ?? ""));
     return Array.from(new Set(refs));
   }
-  return extractTypesFromSignature(m.signature, m.returns);
+  return extractTypesFromSignature(m.signature ?? "", m.returns ?? "");
+}
+function signatureTypeRefs(type) {
+  if (type.kind !== "signature") return [];
+  const refs = [...(type.params ?? []).flatMap((p) => extractTypeIdentifiers(p.type)), ...extractTypeIdentifiers(type.returns ?? "")];
+  return Array.from(new Set(refs));
 }
 function methodGenericParameters(method) {
-  return extractGenericTypeVariables(method.signature);
+  return extractGenericTypeVariables(method.signature ?? "");
 }
 function normalizePart(part) {
   return part.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -8306,9 +8421,21 @@ function typeShape(snapshot, def) {
   return {
     id: def.id,
     kind: def.kind,
-    fields: sortedBy(def.fields, (f) => f.name).map((f) => ({ name: f.name, type: canonicalTypeRef(snapshot, f.type), optional: f.optional === true }))
+    fields: sortedBy(def.fields, (f) => f.name).map((f) => ({ name: f.name, type: canonicalTypeRef(snapshot, f.type), optional: f.optional === true })),
+    // A signature's shape: its params' types and optionality in order (never their names, as a method's), and its returns.
+    ...def.kind === "signature" ? {
+      params: (def.params ?? []).map((p) => ({ type: canonicalTypeRef(snapshot, p.type), optional: p.optional === true })),
+      returns: canonicalTypeRef(snapshot, def.returns ?? "unknown")
+    } : {}
   };
 }
+function typeDefExprs(def) {
+  return [
+    ...def.fields.map((f) => f.type),
+    ...(def.params ?? []).map((p) => p.type),
+    ...def.returns !== void 0 ? [def.returns] : []
+  ];
+}
 function closureShapes(snapshot, exprs) {
   const byId = new Map(snapshot.types.map((def) => [def.id, def]));
   const seen = /* @__PURE__ */ new Map();
@@ -8317,7 +8444,7 @@ function closureShapes(snapshot, exprs) {
     const def = byId.get(queue.shift());
     if (!def || seen.has(def.id)) continue;
     seen.set(def.id, def);
-    for (const field of def.fields) queue.push(...extractTypeIdentifiers(canonicalTypeRef(snapshot, field.type)));
+    for (const expr of typeDefExprs(def)) queue.push(...extractTypeIdentifiers(canonicalTypeRef(snapshot, expr)));
   }
   return [...seen.keys()].sort().map((id) => typeShape(snapshot, seen.get(id)));
 }
@@ -9229,6 +9356,7 @@ function buildCanvasModel(issues = [], relations) {
           signature: m.signature,
           returns: m.returns,
           ...m.params && m.params.length ? { params: m.params } : {},
+          ...m.signatureFrom ? { signatureFrom: m.signatureFrom } : {},
           ...m.endpoint ? { endpoint: m.endpoint } : {},
           ...m.guarantees && m.guarantees.length ? { guarantees: m.guarantees } : {}
         }))
@@ -9294,6 +9422,7 @@ function buildCanvasModel(issues = [], relations) {
       ...f.references ? { references: f.references } : {}
     })),
     methods: t.methods.map((m) => ({ name: m.name, signature: m.signature, returns: m.returns, ...m.description ? { description: m.description } : {} })),
+    ...t.kind === "signature" ? { signature: deriveTypeSignature(t) } : {},
     usedBy: usedByFor(t),
     ...t.componentClass ? { componentClass: t.componentClass } : {},
     ...t.database ? { database: t.database } : {},
@@ -11028,15 +11157,17 @@ var MODEL = __MODEL_JSON__;
     function tableShape(t) {
       var fields = visibleFields(t);
       var meths = det === 'full' ? t.methods : [];
+      // A signature type is drawn with its derived text in place of a field list.
+      var sig = t.signature && det !== 'names' ? t.signature : '';
       var head = t.name + '  \\u00AB' + t.kind + '\\u00BB';
-      var rows = fields.map(function (f) { return rowText(t, f); })
+      var rows = (sig ? [sig] : []).concat(fields.map(function (f) { return rowText(t, f); }))
         .concat(meths.map(function (m) { return '\\u0192 ' + m.name + '(): ' + m.returns; }));
       var longest = head.length + 4;
       rows.forEach(function (r) { if (r.length > longest) longest = r.length; });
       var plain = rows.length === 0;
       var pw = Math.max(170, head.length * 6.8 + 26);
       var W = Math.max(210, Math.min(400, longest * 6.6 + 30));
-      return { fields: fields, meths: meths, head: head, plain: plain, w: plain ? pw : W, h: plain ? 40 : TH_H + fields.length * ROW_H + meths.length * ROW_H };
+      return { fields: fields, meths: meths, sig: sig, head: head, plain: plain, w: plain ? pw : W, h: plain ? 40 : TH_H + (sig ? ROW_H : 0) + fields.length * ROW_H + meths.length * ROW_H };
     }
 
     // Emit one type table with its top-left at (ax, ay); returns its size.
@@ -11060,6 +11191,13 @@ var MODEL = __MODEL_JSON__;
         position: { x: ax + sh.w / 2, y: ay + TH_H / 2 }, classes: 'typeHead ' + kindCls + (dim ? ' dimmed' : ''), grabbable: false,
       });
       var ry = ay + TH_H;
+      if (sh.sig) {
+        eles.push({
+          data: { id: 'TS~' + t.id, parent: 'T~' + t.id, label: sh.sig, w: sh.w, h: ROW_H, tw: sh.w - 14 },
+          position: { x: ax + sh.w / 2, y: ry + ROW_H / 2 }, classes: 'typeRow methRow' + (dim ? ' dimmed' : ''), grabbable: false,
+        });
+        ry += ROW_H;
+      }
       sh.fields.forEach(function (f) {
         var rid = 'TF~' + t.id + '~' + f.name;
         rowIds[rid] = 1;
@@ -13146,7 +13284,7 @@ var MODEL = __MODEL_JSON__;
       var mi = methodInfo(top.comp, top.method);
       var parts = ['<div class="fstep" style="opacity:.7">No step-by-step narrative \\u2014 showing intent / contract:</div>'];
       if (mi) {
-        parts.push('<div class="fstep"><code>' + escText(mi.m.signature) + '</code></div>');
+        parts.push('<div class="fstep"><code>' + escText(mi.m.signature) + '</code>' + (mi.m.signatureFrom ? ' from <code>' + escText(mi.m.signatureFrom) + '</code>' : '') + '</div>');
         parts.push('<div class="fstep">' + escText(mi.m.description) + (mi.m.returns ? ' \\u2014 returns ' + escText(mi.m.returns) : '') + '</div>');
       }
       if (intent) parts.push('<div class="fstep" style="font-style:italic">' + escText(intent) + '</div>');
@@ -13487,6 +13625,7 @@ var MODEL = __MODEL_JSON__;
                   : '<span class="chip" style="opacity:.6">no narrative</span>')
               + '</div>'
               + '<code>' + esc(m.signature) + '</code>'
+              + (m.signatureFrom ? '<div class="mdesc">signature from <code style="display:inline">' + esc(m.signatureFrom) + '</code></div>' : '')
               + '<div class="mdesc">' + esc(m.description) + ' \\u2014 returns ' + typeRefHtml(m.returns) + '</div>'
               + (mIntent && !hasNarr ? '<div class="mdesc" style="font-style:italic">' + esc(mIntent) + '</div>' : '')
               + (m.params ? '<div class="mdesc">params: ' + m.params.map(function (p) { return esc(p.name) + ': ' + typeRefHtml(p.type); }).join(', ') + '</div>' : '')
@@ -13590,7 +13729,11 @@ var MODEL = __MODEL_JSON__;
                 + '</div>';
             }).join('')
           : '<span class="desc">no fields</span>';
-        body += section('Fields', ty.fields.length, fieldsInner, true);
+        if (ty.signature) {
+          body += section('Signature', 1, '<div class="method"><code>' + esc(ty.signature) + '</code></div>', true);
+        } else {
+          body += section('Fields', ty.fields.length, fieldsInner, true);
+        }
         if (ty.usedBy && ty.usedBy.length) {
           body += section('Used by methods', ty.usedBy.length, ty.usedBy.map(function (u) {
             return chip(u.component + '.' + u.method + '()', 'component', u.component);
@@ -13929,21 +14072,30 @@ function computeTypeClosure(entries, types, exported = []) {
     for (const field of spec.fields) {
       for (const ref of extractTypeIdentifiers(field.type)) enqueueRef(ref);
     }
+    for (const param of spec.params ?? []) {
+      for (const ref of extractTypeIdentifiers(param.type)) enqueueRef(ref);
+    }
+    if (spec.returns) {
+      for (const ref of extractTypeIdentifiers(spec.returns)) enqueueRef(ref);
+    }
   }
   const usedIds = /* @__PURE__ */ new Set();
   return [...included.entries()].map(([qualified, t]) => {
     const id = usedIds.has(t.id) ? qualified : t.id;
     usedIds.add(id);
+    const describe2 = (v) => ({
+      name: v.name,
+      type: v.type,
+      ...v.description ? { description: v.description } : {},
+      ...v.optional ? { optional: true } : {}
+    });
     return {
       id,
       name: t.name,
       kind: t.kind,
-      fields: t.fields.map((f) => ({
-        name: f.name,
-        type: f.type,
-        ...f.description ? { description: f.description } : {},
-        ...f.optional ? { optional: true } : {}
-      }))
+      fields: t.fields.map(describe2),
+      // A signature type travels complete: its params and returns with it.
+      ...t.kind === "signature" ? { params: (t.params ?? []).map(describe2), returns: t.returns ?? "unknown" } : {}
     };
   });
 }
@@ -13956,7 +14108,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);
+  const methods = interfaces.filter((i) => i.component === comp.id && (!entry.interface || i.id === entry.interface)).flatMap((i) => i.methods).map(({ signatureFrom: _source, ...method }) => method);
   return {
     id: entry.publicName,
     name: entry.name ?? comp.name,
@@ -14026,7 +14178,12 @@ function canonicalReferences(snapshot) {
         ...m.params ? { params: m.params.map((p) => ({ ...p, type: canon(p.type) })) } : {}
       }))
     })),
-    types: snapshot.types.map((def) => ({ ...def, fields: def.fields.map((f) => ({ ...f, type: canon(f.type) })) }))
+    types: snapshot.types.map((def) => ({
+      ...def,
+      fields: def.fields.map((f) => ({ ...f, type: canon(f.type) })),
+      ...def.params ? { params: def.params.map((p) => ({ ...p, type: canon(p.type) })) } : {},
+      ...def.returns !== void 0 ? { returns: canon(def.returns) } : {}
+    }))
   };
 }
 function listSnapshots() {
@@ -15085,7 +15242,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.94";
+var WAIRON_VERSION = "5.1.1-dev.95";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -16118,7 +16275,7 @@ function buildImplementationMethods(ctx) {
     const component = ctx.componentMap.get(contract.component);
     if (!component) continue;
     if (ctx.isInChainedSubproject(component.subsystem)) continue;
-    const draftContext = ctx.isImplementationDraft(impl);
+    const draftContext3 = ctx.isImplementationDraft(impl);
     for (const method of impl.methods) {
       const sourceFile = methodSourceFile(method, impl.sourcePath);
       out.push({
@@ -16126,7 +16283,7 @@ function buildImplementationMethods(ctx) {
         method,
         component,
         ...sourceFile !== void 0 ? { sourceFile } : {},
-        draftContext
+        draftContext: draftContext3
       });
     }
   }
@@ -16431,7 +16588,7 @@ var fieldTypeReferencesRule = {
 var signatureTypeReferencesRule = {
   name: "signature-type-references",
   judges: "design",
-  description: "Every type identifier an interface method signature names must resolve to a builtin, a generic parameter in scope on the interface or the method, or a defined entity/value-object type.",
+  description: "Every type identifier a method signature names must resolve to a builtin, a generic parameter in scope on the interface or the method, or a defined type: an interface method's params and returns, a type method's params when it has them, and a signature type's params and returns. A method that takes its signature from a source is skipped \u2014 its params are its source's, judged once where the source declares them.",
   codes: [
     { code: "UNDEFINED_TYPE_REFERENCE", defaultSeverity: "error", summary: "Reference to a type that is not defined anywhere" }
   ],
@@ -16442,6 +16599,7 @@ var signatureTypeReferencesRule = {
         Array.from(interfaceGenericParameters(intf)).map((g) => g.toLowerCase())
       );
       for (const m of intf.methods) {
+        if (m.signatureFrom !== void 0) continue;
         const methodGenerics = new Set(
           Array.from(methodGenericParameters(m)).map((g) => g.toLowerCase())
         );
@@ -16461,6 +16619,206 @@ var signatureTypeReferencesRule = {
         }
       }
     }
+    for (const t of ctx.types) {
+      const sub = t.subsystem ? ctx.subsystems.find((s) => s.id === t.subsystem) : void 0;
+      const isDraftCtx = !!sub && (sub.status === "draft" || sub.status === "design");
+      const typeGenerics = new Set(Array.from(typeGenericParameters(t)).map((g) => g.toLowerCase()));
+      const named2 = [
+        ...t.methods.filter((m) => m.params !== void 0).flatMap((m) => methodTypeRefs(m).map((ref) => ({ ref, by: `Method "${m.name}" on type "${t.id}"` }))),
+        ...signatureTypeRefs(t).map((ref) => ({ ref, by: `Signature type "${t.id}"` }))
+      ];
+      for (const { ref, by } of named2) {
+        if (ctx.isTypeResolved(ref, typeGenerics)) continue;
+        const hint = ctx.importHint(ref);
+        ctx.addIssue(
+          "error",
+          "UNDEFINED_TYPE_REFERENCE",
+          `${by} references undefined type "${ref}" in signature.${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}`,
+          t.id,
+          isDraftCtx
+        );
+      }
+    }
+  }
+};
+
+// src/core/rules/integrity/signature-sources.ts
+function draftContext(ctx, interfaceId, component) {
+  const intf = ctx.interfaceMap.get(interfaceId);
+  return ctx.isComponentDraft(component) || intf?.status === "draft" || intf?.status === "design";
+}
+function targetComponent(target) {
+  return target.slice(0, target.lastIndexOf("."));
+}
+var signatureSourcesRule = {
+  name: "signature-sources",
+  judges: "design",
+  description: "Judges every signatureFrom the loader met, from ctx.signatureFacts (the loaded specs are already resolved). The value is read both ways, as a contract method and as a signature type: neither resolving \u2014 or only a type that is an entity or value-object \u2014 is unresolved; both resolving is ambiguous, and the finding names both candidates and asks the author to qualify the reference; a source that itself names a signatureFrom is a chain, which is never followed (when that source's own source is a signature type, the finding names it as the one to take directly); a method source whose component the method's component does not name in dependsOn or owns is off the design's edges; a stored method that names a source and also states params or returns that differ from the source's restates it, and the source's are in force. Every finding sits at the method.",
+  codes: [
+    { code: "SIGNATURE_SOURCE_UNRESOLVED", defaultSeverity: "error", summary: "A method's signatureFrom names no contract method and no signature type" },
+    { code: "SIGNATURE_SOURCE_AMBIGUOUS", defaultSeverity: "error", summary: "A method's signatureFrom resolves both as a contract method and as a signature type; qualify it" },
+    { code: "SIGNATURE_SOURCE_CHAINED", defaultSeverity: "error", summary: "A method's signature source takes its own signature from a source; sources do not chain" },
+    { code: "SIGNATURE_SOURCE_OFF_EDGE", defaultSeverity: "error", summary: "A method takes its signature from a method of a component its own component neither dependsOn nor owns" },
+    { code: "SIGNATURE_SOURCE_RESTATED", defaultSeverity: "error", summary: "A method names a signature source and also states params or returns that differ from the source's" }
+  ],
+  check(ctx) {
+    for (const fact of ctx.signatureFacts?.sources ?? []) {
+      if (!ctx.isSpecInScope(fact.interfaceId)) continue;
+      const isDraft = draftContext(ctx, fact.interfaceId, fact.component);
+      const where = `Method "${fact.method}" on interface "${fact.interfaceId}"`;
+      const at = { at: fact.method };
+      switch (fact.outcome) {
+        case "unresolved":
+          ctx.addIssue(
+            "error",
+            "SIGNATURE_SOURCE_UNRESOLVED",
+            `${where} takes its signature from "${fact.source}", which names ${fact.detail ? `no contract method, and ${fact.detail}` : "no contract method and no signature type"}. A source is a \`component.method\` the component reaches, or a type of kind signature.`,
+            fact.interfaceId,
+            isDraft,
+            void 0,
+            at
+          );
+          continue;
+        case "ambiguous":
+          ctx.addIssue(
+            "error",
+            "SIGNATURE_SOURCE_AMBIGUOUS",
+            `${where} takes its signature from "${fact.source}", which names both the contract method "${fact.candidates?.[0] ?? "?"}" and the signature type "${fact.candidates?.[1] ?? "?"}". Qualify the reference so only one reading matches.`,
+            fact.interfaceId,
+            isDraft,
+            void 0,
+            at
+          );
+          continue;
+        case "chained": {
+          const own = fact.detail ?? "";
+          const direct = ctx.types.some((t) => t.kind === "signature" && (t.id === own || typeMatchesRef(t, own)));
+          ctx.addIssue(
+            "error",
+            "SIGNATURE_SOURCE_CHAINED",
+            `${where} takes its signature from "${fact.target ?? fact.source}", which takes its own from "${own}"; sources do not chain.${direct ? ` "${own}" is a signature type: name it directly as this method's signatureFrom.` : " State this method's params, or name a source that declares its own."}`,
+            fact.interfaceId,
+            isDraft,
+            void 0,
+            at
+          );
+          continue;
+        }
+        case "restated":
+          if (fact.differs) {
+            ctx.addIssue(
+              "error",
+              "SIGNATURE_SOURCE_RESTATED",
+              `${where} takes its signature from "${fact.source}" and also states its own: ${fact.detail ?? "they differ from the source's"}. The source's are in force \u2014 drop the stated params and returns, or drop the signatureFrom.`,
+              fact.interfaceId,
+              isDraft,
+              void 0,
+              at
+            );
+          }
+          continue;
+        default:
+          break;
+      }
+      if (fact.form !== "method" || !fact.target) continue;
+      const source = targetComponent(fact.target);
+      const owner = ctx.componentMap.get(fact.component);
+      const reached = /* @__PURE__ */ new Set([...owner?.dependsOn ?? [], ...owner?.owns ?? []]);
+      if (reached.has(source)) continue;
+      ctx.addIssue(
+        "error",
+        "SIGNATURE_SOURCE_OFF_EDGE",
+        `${where} takes its signature from "${fact.target}", but "${fact.component}" neither dependsOn nor owns "${source}". Add "${source}" to its dependsOn (or owns, for a member), or name a source it reaches.`,
+        fact.interfaceId,
+        isDraft,
+        void 0,
+        at
+      );
+    }
+  }
+};
+
+// src/core/rules/integrity/signature-types.ts
+var signatureTypesRule = {
+  name: "signature-types",
+  judges: "design",
+  description: "A type of kind signature is a named function type and carries params and one returns, nothing else: fields, methods, invariants, componentClass, database, table or linkedEntity on it \u2014 or a returns missing from it \u2014 are reported; so are params or returns on an entity or a value-object, where they mean nothing.",
+  codes: [
+    { code: "SIGNATURE_TYPE_MEMBERS", defaultSeverity: "error", summary: "A signature type carries a member other than params and returns, or lacks returns; or a data type carries params or returns" }
+  ],
+  check(ctx) {
+    for (const t of ctx.types) {
+      if (!ctx.isSpecInScope(t.id)) continue;
+      const sub = t.subsystem ? ctx.subsystems.find((s) => s.id === t.subsystem) : void 0;
+      const isDraft = !!sub && (sub.status === "draft" || sub.status === "design");
+      if (t.kind === "signature") {
+        const members = [
+          ...t.fields.length > 0 ? ["fields"] : [],
+          ...t.methods.length > 0 ? ["methods"] : [],
+          ...(t.invariants?.length ?? 0) > 0 ? ["invariants"] : [],
+          ...t.componentClass !== void 0 ? ["componentClass"] : [],
+          ...t.database !== void 0 ? ["database"] : [],
+          ...t.table !== void 0 ? ["table"] : [],
+          ...t.linkedEntity !== void 0 ? ["linkedEntity"] : []
+        ];
+        const missingReturns = t.returns === void 0;
+        if (members.length === 0 && !missingReturns) continue;
+        const problems = [
+          ...members.length > 0 ? [`carries ${members.join(", ")}`] : [],
+          ...missingReturns ? ["states no returns"] : []
+        ];
+        ctx.addIssue(
+          "error",
+          "SIGNATURE_TYPE_MEMBERS",
+          `Signature type "${t.id}" ${problems.join(" and ")}. A signature is a named function type: params and one returns, nothing else.`,
+          t.id,
+          isDraft
+        );
+        continue;
+      }
+      const stated = [...t.params !== void 0 ? ["params"] : [], ...t.returns !== void 0 ? ["returns"] : []];
+      if (stated.length === 0) continue;
+      ctx.addIssue(
+        "error",
+        "SIGNATURE_TYPE_MEMBERS",
+        `Type "${t.id}" is ${t.kind === "entity" ? "an entity" : `a ${t.kind}`} and carries ${stated.join(" and ")}, which only a signature type has. Make it kind signature, or drop them.`,
+        t.id,
+        isDraft
+      );
+    }
+  }
+};
+
+// src/core/rules/integrity/signature-text.ts
+function draftContext2(ctx, specId, kind) {
+  if (kind === "interface") {
+    const intf = ctx.interfaceMap.get(specId);
+    return !!intf && (ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design");
+  }
+  const type = ctx.types.find((t) => t.id === specId);
+  const sub = type?.subsystem ? ctx.subsystems.find((s) => s.id === type.subsystem) : void 0;
+  return !!sub && (sub.status === "draft" || sub.status === "design");
+}
+var signatureTextRule = {
+  name: "signature-text",
+  judges: "design",
+  description: "A stored signature text that differs from the text its method's params derive is stale: every reader is shown the derived text, but the file says something else, and a file read on its own (a diff, a review, a lock approval) is misled. Reported per method, from ctx.signatureFacts, for contract and type methods alike; `wairon doctor --fix` regenerates the stored text, and any save of the spec writes the derived text too.",
+  codes: [
+    { code: "SIGNATURE_TEXT_STALE", defaultSeverity: "warning", summary: "A stored signature text differs from the text its params derive; doctor --fix regenerates it" }
+  ],
+  check(ctx) {
+    for (const stale of ctx.signatureFacts?.staleTexts ?? []) {
+      if (!ctx.isSpecInScope(stale.specId)) continue;
+      ctx.addIssue(
+        "warning",
+        "SIGNATURE_TEXT_STALE",
+        `Method "${stale.method}" on ${stale.kind} "${stale.specId}" stores the signature "${stale.stored}", but its params derive "${stale.derived}" \u2014 which is what every reader is shown. Run \`wairon doctor --fix\` to regenerate the stored text (any save of the spec writes it too).`,
+        stale.specId,
+        draftContext2(ctx, stale.specId, stale.kind),
+        void 0,
+        { at: stale.method }
+      );
+    }
   }
 };
 
@@ -17892,11 +18250,11 @@ var detailSufficiencyRule = {
       const contract = ctx.interfaceMap.get(impl.contract);
       if (!contract) continue;
       const component = ctx.componentMap.get(contract.component);
-      const draftContext = ctx.isImplementationDraft(impl);
+      const draftContext3 = ctx.isImplementationDraft(impl);
       for (const method of impl.methods) {
         const detail = effectiveDetail(method, impl, component);
         if (contract.methods.some((m) => m.name === method.name) && method.narrative.length === 0 && detail.level !== "full") {
-          dialedDown.push({ implementation: impl, method, component, detail, draftContext });
+          dialedDown.push({ implementation: impl, method, component, detail, draftContext: draftContext3 });
         }
       }
     }
@@ -19863,7 +20221,7 @@ var unusedTypesRule = {
   // Stage 8: its verdict needs the whole system's specs, so a part judged alone skips it.
   needsWholeTree: true,
   judges: "design",
-  description: "Flags types no field of any type, no interface method signature and no other type's method signature references. References are matched through the type-reference grammar (generic arguments, collections, qualified ids), and the declaring type's own generic parameters are left out \u2014 a type parameter is not a reference to a type. A type named only by its OWN methods stays unused, the way a function that only calls itself is.",
+  description: "Flags types no field of any type, no interface method signature, no contract method's signatureFrom and no other type's method signature references. References are matched through the type-reference grammar (generic arguments, collections, qualified ids), and the declaring type's own generic parameters are left out \u2014 a type parameter is not a reference to a type. A signature type is used when a method names it as its signatureFrom or a param is typed by it. A type named only by its OWN methods stays unused, the way a function that only calls itself is.",
   codes: [
     { code: "UNUSED_TYPE", defaultSeverity: "warning", summary: "Type never referenced by fields, signatures or type methods" }
   ],
@@ -19885,6 +20243,7 @@ var unusedTypesRule = {
           markTypeReferenced(ref);
         }
       }
+      for (const ref of signatureTypeRefs(t)) markTypeReferenced(ref, t.id);
     }
     for (const intf of ctx.interfaces) {
       for (const m of intf.methods) {
@@ -19894,6 +20253,13 @@ var unusedTypesRule = {
         }
       }
     }
+    for (const fact of ctx.signatureFacts?.sources ?? []) {
+      const named2 = fact.form === "signature" && fact.target ? fact.target : fact.outcome === "ambiguous" ? fact.candidates?.[1] : void 0;
+      if (!named2) continue;
+      for (const spec of ctx.types) {
+        if (spec.id === named2 || typeMatchesRef(spec, named2)) referencedTypes.add(spec.id);
+      }
+    }
     for (const t of ctx.types) {
       for (const m of t.methods) {
         const refs = methodTypeRefs(m);
@@ -21253,7 +21619,7 @@ function absence(optional) {
 var typeShapeRule = {
   name: "type-shape",
   judges: "code",
-  description: "Code-to-contract for the DATA: a type spec's `fields` are compared, name by name, against the shape its `sourcePath` actually declares. `typeRealization` asks whether a type EXISTS in code; nothing asked whether it is the shape the spec claims, so a type spec could describe two fields of a six-field record \u2014 and call the two that are optional required \u2014 straight through a lock and a CI gate, while the ERD, the agent briefs and every implementer read it as truth. That is the worst of the code-to-spec gaps, because a wrong signature eventually breaks at a call site and a type spec that lies is only ever read by humans and agents. Two origins answer at exact grade: a DECLARED shape, whose members the file lists, and a DERIVED one, an alias followed one hop to the object literal its schema is built from, where the keys are the members. A shape that extends another is judged on what it shows and never on what it omits, since its inherited members are not in this file to count.",
+  description: "Code-to-contract for the DATA: a type spec's `fields` are compared, name by name, against the shape its `sourcePath` actually declares. `typeRealization` asks whether a type EXISTS in code; nothing asked whether it is the shape the spec claims, so a type spec could describe two fields of a six-field record \u2014 and call the two that are optional required \u2014 straight through a lock and a CI gate, while the ERD, the agent briefs and every implementer read it as truth. That is the worst of the code-to-spec gaps, because a wrong signature eventually breaks at a call site and a type spec that lies is only ever read by humans and agents. Two origins answer at exact grade: a DECLARED shape, whose members the file lists, and a DERIVED one, an alias followed one hop to the object literal its schema is built from, where the keys are the members \u2014 and on through a composition the same file writes out (`Base.extend({\u2026})` on a schema constant it declares), the extension's keys laid over the base's. A shape that extends another is judged on what it shows and never on what it omits, since its inherited members are not in this file to count.",
   codes: [
     {
       code: "UNREALIZED_TYPE_FIELD",
@@ -21430,7 +21796,7 @@ var paramConformanceRule = {
       const stated = normalize3(declared.type);
       return stated === realized.type || codeNameOf.get(stated) === realized.type;
     };
-    for (const { implementation, method, sourceFile, draftContext } of ctx.implementationMethods()) {
+    for (const { implementation, method, sourceFile, draftContext: draftContext3 } of ctx.implementationMethods()) {
       const contract = ctx.interfaceMap.get(implementation.contract);
       const declared = contract?.methods.find((m) => m.name === method.name)?.params ?? [];
       if (declared.length === 0 || !sourceFile) continue;
@@ -21453,7 +21819,7 @@ var paramConformanceRule = {
           "UNREALIZED_PARAM",
           `Method "${method.name}" of contract "${implementation.contract}" declares ${unrealized.length} parameter(s) ${subject} does not take \u2014 ${unrealized.map((found) => found.told).join(", ")}. The contract is promising an argument that would go nowhere, and nothing breaks at a call site to correct it: every brief and every caller built from the contract passes one. Take the parameter in the code, or drop it from the contract.`,
           implementation.id,
-          draftContext,
+          draftContext3,
           void 0,
           { at: method.name, covers: unrealized.map((found) => found.unit) }
         );
@@ -21465,7 +21831,7 @@ var paramConformanceRule = {
           "UNDECLARED_PARAM",
           `${opening} realizing method "${method.name}" of contract "${implementation.contract}" takes ${undeclared.length} parameter(s) the contract does not declare and no declared injection accounts for \u2014 ${undeclared.map((found) => found.told).join(", ")}. An argument a caller must supply that the design never mentions is how a credential ends up in a signature nobody has read against its contract. Declare it on the contract, name it in the implementation's \`injectedParams\` when whatever wires this component up supplies it (a LEADING run only), or take it out of the signature.`,
           implementation.id,
-          draftContext,
+          draftContext3,
           void 0,
           { at: method.name, covers: undeclared.map((found) => found.unit) }
         );
@@ -21477,7 +21843,7 @@ var paramConformanceRule = {
           "PARAM_NAME_MISMATCH",
           `Method "${method.name}" of contract "${implementation.contract}" and ${subject} agree on position and type but not on name for ${renamed.length} parameter(s) \u2014 ${renamed.map((f) => f.told).join("; ")}. The contract, the ERD and every brief carry one word and the code answers to another, which is a rename nobody recorded rather than a different argument \u2014 the declared type agreeing is what says so. Rename one side to the other.`,
           implementation.id,
-          draftContext,
+          draftContext3,
           void 0,
           { at: method.name, covers: renamed.map((found) => found.unit) }
         );
@@ -21489,7 +21855,7 @@ var paramConformanceRule = {
           "PARAM_OPTIONALITY",
           `Method "${method.name}" of contract "${implementation.contract}" and ${subject} disagree about whether ${disagreed.length} parameter(s) may be left out \u2014 ${disagreed.map((f) => f.told).join("; ")}. One of them is telling a caller an argument is required when it is not, or the reverse. Omittable is the code's word for it: a default value and a rest parameter make an argument omittable exactly as a question mark does.`,
           implementation.id,
-          draftContext,
+          draftContext3,
           void 0,
           { at: method.name, covers: disagreed.map((found) => found.unit) }
         );
@@ -21566,7 +21932,7 @@ var routeCoverageRule = {
           const routes = code.factsAt(file).functionRoutes;
           return routes && Object.prototype.hasOwnProperty.call(routes, via) ? routes[via] : [];
         });
-        const draftContext = ctx.isComponentDraft(listener.id) || ctx.isComponentDraft(portal.id);
+        const draftContext3 = ctx.isComponentDraft(listener.id) || ctx.isComponentDraft(portal.id);
         const where = holders.map((file) => `"${file}"`).join(", ");
         if (read2.length === 0) {
           ctx.addIssue(
@@ -21574,7 +21940,7 @@ var routeCoverageRule = {
             "UNREADABLE_ROUTER",
             `Listener "${listener.id}" mounts portal "${portal.id}" through "${via}" in ${where}, but no branch of "${via}" reads as a route \u2014 so none of its routes were checked against the contract at all. Only one idiom is read: an \`if\` whose conditions, together with those of every enclosing \`if\`, compare \`<request>.method\` with a string and \`parts[i]\` / \`parts.length\` with literals. Silence here would read as a clean router; it is only one this analysis cannot see. Write the router in that idiom, or carry this finding with the reason it cannot be.`,
             anchor,
-            draftContext,
+            draftContext3,
             void 0,
             { at: via }
           );
@@ -21599,7 +21965,7 @@ var routeCoverageRule = {
             "UNDECLARED_ROUTE",
             `Portal "${portal.id}"'s router "${via}" (${where}), mounted by listener "${listener.id}", answers ${undeclared.length} route(s) no contract endpoint of "${portal.id}" declares \u2014 ${undeclared.map((key) => `"${key}"`).join(", ")}. A surface the code serves and the design never promised is how a write runs with no contract: no brief, no auth review, no rule reading it. Declare each as a contract method with its endpoint, or take the route out of the router.`,
             anchor,
-            draftContext,
+            draftContext3,
             void 0,
             { at: via, covers: undeclared }
           );
@@ -21611,7 +21977,7 @@ var routeCoverageRule = {
             "UNROUTED_ENDPOINT",
             `Portal "${portal.id}" binds ${unrouted.length} HTTP endpoint(s) under listener "${listener.id}"'s mount that no route of its router "${via}" (${where}) answers \u2014 ${unrouted.map((key) => `"${key}"`).join(", ")}. The contract promises a route no request can reach. Route it in the router, or drop the endpoint from the contract.`,
             anchor,
-            draftContext,
+            draftContext3,
             void 0,
             { at: via, covers: unrouted }
           );
@@ -21714,7 +22080,7 @@ var exportConformanceRule = {
         }
       }
     }
-    for (const { implementation, method, sourceFile, draftContext } of ctx.implementationMethods()) {
+    for (const { implementation, method, sourceFile, draftContext: draftContext3 } of ctx.implementationMethods()) {
       const handle = method.exportedVia;
       if (!handle || !sourceFile) continue;
       const file = pathKey(sourceFile);
@@ -21729,7 +22095,7 @@ var exportConformanceRule = {
         "UNREALIZED_EXPORT_HANDLE",
         `Method "${method.name}" in implementation "${implementation.id}" declares exportedVia "${handle}", but "${file}" exports no such name. A handle names the export a consumer imports to REACH the method \u2014 the value that composes it, which \`symbol\` cannot name because \`symbol\` names the function inside \u2014 so one the file does not publish promises a route nobody can import. It allows nothing either: every export of this file is still read against the contracts. Name the binding the file actually exports, export it, or drop the handle.`,
         implementation.id,
-        draftContext
+        draftContext3
       );
     }
     for (const listener of ctx.components) {
@@ -23019,6 +23385,68 @@ var namingDisciplineRule = {
   }
 };
 
+// src/core/rules/heuristic/signature-source-suggestions.ts
+function sameParams(a, b) {
+  if (!b || a.length !== b.length) return false;
+  return a.every((p, i) => p.name === b[i].name && p.type === b[i].type && !!p.optional === !!b[i].optional);
+}
+function localName(id) {
+  return id.split("::").pop();
+}
+var signatureSourceSuggestionsRule = {
+  name: "signature-source-suggestions",
+  judges: "design",
+  description: "A Repository facade method is pure 1:1 forwarding to an owned member by doctrine (facade-forwarding), so its signature IS the member's: where its params (name, type, optional marker, order) and returns equal the owned member method it forwards to, it could name that method as its signatureFrom, and the reference can never be wrong. Suggested only where the adoption would be legal: the member method names no source of its own (no chain). Nothing else is suggested: another forwarder \u2014 a Portal restating an Orchestrator, a client Adapter restating a remote Portal \u2014 is often a public surface that should stay deliberately decoupled from an internal signature, so wairon does not suggest coupling them. Adoption is opt-in, so this is a notice, and ONE per facade contract, the restating methods being the units it covers.",
+  codes: [
+    { code: "SIGNATURE_SOURCE_AVAILABLE", defaultSeverity: "notice", summary: "A Repository facade's methods restate exactly the owned member methods they forward to and could name them as their signatureFrom" }
+  ],
+  check(ctx) {
+    for (const impl of ctx.implementations) {
+      const contract = ctx.interfaceMap.get(impl.contract);
+      if (!contract || !ctx.isSpecInScope(contract.id)) continue;
+      const repository = ctx.componentMap.get(contract.component);
+      if (!repository || repository.componentType !== "Repository") continue;
+      const owned = new Set(repository.owns);
+      const restating = [];
+      for (const realized of impl.methods) {
+        const steps = realized.narrative ?? [];
+        let member;
+        let memberMethod;
+        if (steps.length === 1 && steps[0].type === "call") {
+          member = steps[0].targetComponent;
+          memberMethod = steps[0].targetMethod;
+        } else if (steps.length === 0 && realized.calls?.length === 1) {
+          const entry = realized.calls[0];
+          const dot = entry.lastIndexOf(".");
+          if (dot > 0) {
+            member = entry.slice(0, dot);
+            memberMethod = entry.slice(dot + 1);
+          }
+        }
+        if (!member || !memberMethod) continue;
+        const memberKey = [...owned].find((o) => o === member || localName(o) === localName(member));
+        if (!memberKey) continue;
+        const own = contract.methods.find((m) => m.name === realized.name);
+        if (!own || own.signatureFrom !== void 0 || !own.params) continue;
+        const target = (ctx.interfacesByComponent.get(memberKey) ?? []).flatMap((i) => i.methods).find((m) => m.name === memberMethod);
+        if (!target || target.signatureFrom !== void 0) continue;
+        if (!sameParams(own.params, target.params) || own.returns !== target.returns) continue;
+        restating.push(`${own.name} \u2190 ${localName(memberKey)}.${memberMethod}`);
+      }
+      if (restating.length === 0) continue;
+      ctx.addIssue(
+        "notice",
+        "SIGNATURE_SOURCE_AVAILABLE",
+        `${restating.length === 1 ? "A method" : `${restating.length} methods`} of Repository facade "${contract.id}" restate${restating.length === 1 ? "s" : ""} exactly the owned member method${restating.length === 1 ? "" : "s"} ${restating.length === 1 ? "it forwards" : "they forward"} to: ${restating.map((u) => `"${u}"`).join("; ")}. ${restating.length === 1 ? "It" : "Each"} could name that member method as its signatureFrom (and drop its params and returns), so the signature is stated once. Optional \u2014 a facade's signature is its member's by doctrine.`,
+        contract.id,
+        ctx.isImplementationDraft(impl),
+        void 0,
+        { at: contract.id, covers: restating }
+      );
+    }
+  }
+};
+
 // src/core/rules/repository.ts
 var SDD_RULES = [
   hierarchyRule,
@@ -23038,6 +23466,9 @@ var SDD_RULES = [
   typeDeclarationsRule,
   fieldTypeReferencesRule,
   signatureTypeReferencesRule,
+  signatureSourcesRule,
+  signatureTypesRule,
+  signatureTextRule,
   // 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
@@ -23223,6 +23654,7 @@ var SDD_RULES = [
   narrativeComplexityRule,
   namingDisciplineRule,
   methodCohesionRule,
+  signatureSourceSuggestionsRule,
   // Pack resolution and reproducibility run late: they are about project
   // CONFIGURATION (does the declared pack set resolve, and can it be reproduced
   // elsewhere?) rather than spec content.
@@ -23590,24 +24022,6 @@ function walkExact(ts, sourceText, fileName) {
     if (!argument || !ts.isTypeQueryNode(argument) || !ts.isIdentifier(argument.exprName)) return void 0;
     return argument.exprName.text;
   };
-  const baseObjectLiteral = (expression) => {
-    let node = expression;
-    const walked = /* @__PURE__ */ new Set();
-    while (node && !walked.has(node)) {
-      walked.add(node);
-      if (ts.isCallExpression(node)) {
-        const callee = node.expression;
-        if (ts.isPropertyAccessExpression(callee) && callee.name.text === "object") {
-          const literal = node.arguments.find((argument) => ts.isObjectLiteralExpression(argument));
-          if (literal) return literal;
-        }
-        node = callee;
-      } else if (ts.isPropertyAccessExpression(node)) {
-        node = node.expression;
-      } else break;
-    }
-    return void 0;
-  };
   const chainedCombinators = (expression) => {
     const applied = /* @__PURE__ */ new Set();
     let node = expression;
@@ -23877,13 +24291,48 @@ function walkExact(ts, sourceText, fileName) {
     ts.forEachChild(node, visit);
   };
   visit(sf);
+  const composedMembers = (expression, seen) => {
+    const extensions = [];
+    const compose2 = (members) => {
+      const byName = new Map(members.map((member) => [member.name, member]));
+      for (const extension of [...extensions].reverse()) {
+        for (const member of schemaMembers(extension)) byName.set(member.name, member);
+      }
+      return [...byName.values()];
+    };
+    let node = expression;
+    const walked = /* @__PURE__ */ new Set();
+    while (node && !walked.has(node)) {
+      walked.add(node);
+      if (ts.isCallExpression(node)) {
+        const callee = node.expression;
+        if (ts.isPropertyAccessExpression(callee) && callee.name.text === "object") {
+          const literal = node.arguments.find((argument) => ts.isObjectLiteralExpression(argument));
+          if (literal) return compose2(schemaMembers(literal));
+        } else if (ts.isPropertyAccessExpression(callee) && callee.name.text === "extend") {
+          const extension = node.arguments.find((argument) => ts.isObjectLiteralExpression(argument));
+          if (!extension) return void 0;
+          extensions.push(extension);
+        }
+        node = callee;
+      } else if (ts.isPropertyAccessExpression(node)) {
+        node = node.expression;
+      } else if (ts.isIdentifier(node)) {
+        const base = schemaConstants.get(node.text);
+        if (!base || seen.has(node.text)) return void 0;
+        const members = composedMembers(base, /* @__PURE__ */ new Set([...seen, node.text]));
+        return members ? compose2(members) : void 0;
+      } else break;
+    }
+    return void 0;
+  };
   for (const alias of derivedAliases) {
     if (typeShapes.has(alias.name)) continue;
     const initializer = schemaConstants.get(alias.constant);
     if (!initializer) continue;
-    const literal = baseObjectLiteral(initializer);
-    if (!literal) continue;
-    typeShapes.set(alias.name, { origin: "derived", fields: schemaMembers(literal), methods: [] });
+    const fields = composedMembers(initializer, /* @__PURE__ */ new Set([alias.constant]));
+    if (!fields) continue;
+    typeShapes.set(alias.name, { origin: "derived", fields, methods: [] });
   }
   const reexportOnly = sf.statements.length > 0 && sf.statements.every((st) => ts.isExportDeclaration(st) && !!st.moduleSpecifier);
   return { declared, anchors, exported, imports, reexports, starExports, namedReexports, complexity, calls, importBindings, typeOnlyBindings, fieldTypes, localTypes, typeShapes, functionParams, functionRoutes, mutableBindings, reexportOnly };
@@ -24904,6 +25353,7 @@ function buildRuleContext(opts) {
     ...opts.exportTables ? { exportTables: opts.exportTables } : {},
     ...opts.projectFamily ? { projectFamily: opts.projectFamily } : {},
     ...opts.exportUsages ? { exportUsages: opts.exportUsages } : {},
+    ...opts.signatureFacts ? { signatureFacts: opts.signatureFacts } : {},
     pinnedExternals,
     codeModel: opts.codeModel ?? emptyCodeModel(),
     roundTripIssues: opts.roundTripIssues,
@@ -25345,6 +25795,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
     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));
     const exportUsages = [...producers].map((producer) => exportUsage("", producer));
+    const signatures = signatureFacts();
     const ctx = buildRuleContext({
       system,
       subsystems,
@@ -25366,6 +25817,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
       ],
       projectFamily: family,
       exportUsages,
+      signatureFacts: signatures,
       pinnedExternals,
       // By-name selections only: a legacy path ref pins nothing to check. A dry
       // run supplies its candidate's; otherwise the stored ones.
@@ -25485,12 +25937,26 @@ function judgePartAlone(config, scopeSubsystem) {
     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));
   }
+  const ownSignatures = signatureFacts();
+  const resolved = resolveTree(
+    [...own.interfaces, ...context.interfaces],
+    [...own.components, ...context.components],
+    [...own.types, ...context.types]
+  );
+  const ownInterfaceIds = new Set(own.interfaces.map((i) => i.id));
+  const partSignatures = {
+    sources: [
+      ...resolved.facts.sources.filter((f) => ownInterfaceIds.has(f.interfaceId) && f.outcome !== "restated"),
+      ...ownSignatures.sources.filter((f) => f.outcome === "restated")
+    ],
+    staleTexts: ownSignatures.staleTexts
+  };
   const all = {
     subsystems: [...own.subsystems, ...context.subsystems],
     components: [...own.components, ...context.components],
-    interfaces: [...own.interfaces, ...context.interfaces],
+    interfaces: resolved.interfaces,
     implementations: [...own.implementations, ...context.implementations],
-    types: [...own.types, ...context.types]
+    types: resolved.types
   };
   const system = context.system ?? SystemSpecSchema.parse({ createdAt: EXCERPT_EPOCH, updatedAt: EXCERPT_EPOCH, name: parentId, vision: `The part's parent, "${parentId}" (no L0 pinned).` });
   const codeModel = buildCodeModel(own.implementations, own.types, root, [], []);
@@ -25510,6 +25976,7 @@ function judgePartAlone(config, scopeSubsystem) {
     exportTables: [],
     projectFamily: graph(),
     exportUsages: [],
+    signatureFacts: partSignatures,
     pinnedExternals: [],
     packSelections: packs.filter((p) => typeof p !== "string"),
     packRequirements: [],
@@ -26364,7 +26831,7 @@ function projectFamilyGraph() {
 
 // src/core/exports.ts
 var CONSUMABLE = /* @__PURE__ */ new Set(["Portal", "Observer"]);
-function localName(id) {
+function localName2(id) {
   return id.split("::").pop() ?? id;
 }
 function ownedBy(subsystemId, declaringSubsystem) {
@@ -26411,7 +26878,7 @@ function findInSource(world, source, table, request) {
   if (request.typeDef) {
     const type = lookupType(world, request.typeDef, source.id);
     if (!type) return {};
-    const item2 = { publicName: localName(type.id), kind: "type", source: type.subsystem ?? source.id, typeDef: type.id, via: [] };
+    const item2 = { publicName: localName2(type.id), kind: "type", source: type.subsystem ?? source.id, typeDef: type.id, via: [] };
     return { item: item2, found: table.entries.find((e) => e.kind === "type" && e.typeDef === type.id && e.source === item2.source) };
   }
   const intf = lookup(world.interfaces, request.interface, source.id);
@@ -26419,7 +26886,7 @@ function findInSource(world, source, table, request) {
   if (!comp) return {};
   const narrowed2 = intf?.id ?? request.interface;
   const item = {
-    publicName: localName(narrowed2 ?? comp.id),
+    publicName: localName2(narrowed2 ?? comp.id),
     kind: "component",
     source: comp.subsystem,
     component: comp.id,
@@ -26459,7 +26926,7 @@ function bindOwn(world, sub, pi, problems) {
       problems.push({ kind: "invalid", owner: sub.id, detail: `exports type "${pi.typeDef}" as its own, but ${type ? `it belongs to "${type.subsystem ?? "the system"}"` : "no such type exists"}` });
       return void 0;
     }
-    const name2 = pi.as ?? localName(type.id);
+    const name2 = pi.as ?? localName2(type.id);
     checkPublicName(name2, sub.id, problems);
     return { publicName: name2, kind: "type", source: type.subsystem ?? sub.id, typeDef: type.id, via: [] };
   }
@@ -26467,7 +26934,7 @@ function bindOwn(world, sub, pi, problems) {
   if (!comp || !ownedBy(sub.id, comp.subsystem)) return void 0;
   const intf = lookup(world.interfaces, pi.interface, sub.id);
   const narrowed2 = intf?.id ?? pi.interface;
-  const name = pi.as ?? localName(narrowed2 ?? comp.id);
+  const name = pi.as ?? localName2(narrowed2 ?? comp.id);
   checkPublicName(name, sub.id, problems);
   return {
     publicName: name,
@@ -26502,7 +26969,7 @@ function subsystemCandidates(world, sub, tables, group, problems) {
         source,
         sourceTable,
         { component: pi.component, interface: pi.interface, typeDef: pi.typeDef },
-        (item) => pi.as ?? localName(pi.interface ?? item.typeDef ?? item.component ?? ""),
+        (item) => pi.as ?? localName2(pi.interface ?? item.typeDef ?? item.component ?? ""),
         group.has(source.id),
         problems
       );
@@ -26678,16 +27145,16 @@ function classifySource(world, sourceId, label7, sources) {
 function bindOwnType(world, owner, e, problems) {
   const type = (world.types.get(e.typeDef) ?? []).find((t) => !t.subsystem);
   if (!type) {
-    problems.push({ kind: "invalid", owner, publicName: e.as ?? e.id ?? localName(e.typeDef), detail: `exports type "${e.typeDef}" as its own, but the project owns no project-level type of that id` });
+    problems.push({ kind: "invalid", owner, publicName: e.as ?? e.id ?? localName2(e.typeDef), detail: `exports type "${e.typeDef}" as its own, but the project owns no project-level type of that id` });
     return void 0;
   }
-  const name = e.as ?? e.id ?? localName(type.id);
+  const name = e.as ?? e.id ?? localName2(type.id);
   checkPublicName(name, owner, problems);
   return { publicName: name, kind: "type", source: owner, typeDef: type.id, via: [] };
 }
 function bindFromProject(owner, e, source, table, index, problems) {
   const named2 = e.component !== void 0 || e.typeDef !== void 0 || e.interface !== void 0;
-  const requested = named2 ? localName(e.interface ?? e.component ?? e.typeDef) : void 0;
+  const requested = named2 ? localName2(e.interface ?? e.component ?? e.typeDef) : void 0;
   const picked = named2 ? table.entries.filter((x) => x.publicName === requested) : table.entries;
   if (named2 && picked.length === 0) {
     problems.push({ kind: "invalid", owner, publicName: e.as ?? e.id ?? requested, detail: `re-exports "${requested}" from ${source.label}, whose export table has no such public name \u2014 another project is reached only through its L0 exports` });
@@ -26724,7 +27191,7 @@ function bindFromSubsystem(world, owner, e, subsystem, subsystemTables, index, p
       // The default public name is the item's own LOCAL id: a member's L0 is
       // read with its ids keyed under its project, and its entry names the
       // item as the member wrote it.
-      () => e.as ?? e.id ?? localName(e.interface ?? e.component ?? e.typeDef),
+      () => e.as ?? e.id ?? localName2(e.interface ?? e.component ?? e.typeDef),
       false,
       problems
     );
@@ -26865,6 +27332,124 @@ function pinnedUsageOf(consumer, alias) {
   };
 }
 
+// src/core/signature-sources.ts
+function emptySignatureFacts() {
+  return { sources: [], staleTexts: [] };
+}
+function namespaceOf(key) {
+  const at = key.lastIndexOf("::");
+  return at === -1 ? "" : key.slice(0, at);
+}
+function unresolvedMethod(method) {
+  const { params: _params, ...rest } = method;
+  return { ...rest, returns: "unknown", signature: `${method.name}(...): unknown` };
+}
+function sameParams2(a, b) {
+  const left = a ?? [];
+  const right = b ?? [];
+  return left.length === right.length && left.every((p, i) => p.name === right[i].name && p.type === right[i].type && !!p.optional === !!right[i].optional);
+}
+function tablesOf(interfaces, components, types, references) {
+  const methodsOf = /* @__PURE__ */ new Map();
+  for (const intf of interfaces) methodsOf.set(intf.component, [...methodsOf.get(intf.component) ?? [], ...intf.methods]);
+  const boundTypes = /* @__PURE__ */ new Map();
+  for (const ref of references) {
+    if (ref.position !== "type" || ref.binding === "outside" || ref.binding === "unresolved") continue;
+    boundTypes.set(`${ref.specId}|${ref.authored}`, ref.resolved);
+  }
+  return { methodsOf, componentKeys: new Set(components.map((c) => c.id)), types, boundTypes };
+}
+function methodReading(tables, intf, value) {
+  const dot = value.lastIndexOf(".");
+  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 keys = [head2, ...ns && !head2.startsWith(`${ns}::`) ? [`${ns}::${head2}`] : []];
+  for (const key of keys) {
+    if (!tables.componentKeys.has(key)) continue;
+    const method = (tables.methodsOf.get(key) ?? []).find((m) => m.name === tail);
+    if (method) return { target: `${key}.${tail}`, method };
+  }
+  return null;
+}
+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 ranked = [...named2].sort((a, b) => local(a) - local(b));
+  return { signature: ranked.find((t) => t.kind === "signature"), other: ranked.find((t) => t.kind !== "signature") };
+}
+function typeTarget(type) {
+  return type.subsystem && !type.id.includes("::") ? `${type.subsystem}::${type.id}` : type.id;
+}
+function restatedFact(base, stored, params, returns) {
+  const statesParams = stored.params !== void 0;
+  const statesReturns = stored.returns !== void 0;
+  if (!statesParams && !statesReturns) return null;
+  const paramsDiffer = statesParams && !sameParams2(stored.params, params);
+  const returnsDiffer = statesReturns && stored.returns !== returns;
+  const differs = paramsDiffer || returnsDiffer;
+  const detail = !differs ? "restates its source exactly" : [paramsDiffer ? "its params differ from the source's" : "", returnsDiffer ? `its returns "${stored.returns}" differ from the source's "${returns}"` : ""].filter(Boolean).join("; ");
+  return { ...base, outcome: "restated", differs, detail };
+}
+function resolveSourced(tables, intf, stored, facts) {
+  const source = stored.signatureFrom;
+  const base = { interfaceId: intf.id, component: intf.component, method: stored.name, source };
+  const hit = methodReading(tables, intf, source);
+  const { signature, other } = typeReading(tables, intf, source);
+  if (hit && signature) {
+    facts.sources.push({ ...base, outcome: "ambiguous", candidates: [hit.target, typeTarget(signature)] });
+    return unresolvedMethod(stored);
+  }
+  if (!hit && !signature) {
+    facts.sources.push({ ...base, outcome: "unresolved", ...other ? { detail: `"${typeTarget(other)}" is a type of kind ${other.kind}, not a signature` } : {} });
+    return unresolvedMethod(stored);
+  }
+  if (hit && hit.method.signatureFrom !== void 0) {
+    facts.sources.push({ ...base, form: "method", target: hit.target, outcome: "chained", detail: hit.method.signatureFrom });
+    return unresolvedMethod(stored);
+  }
+  const form = hit ? "method" : "signature";
+  const target = hit ? hit.target : typeTarget(signature);
+  const params = hit ? hit.method.params : signature.params;
+  const returns = hit ? hit.method.returns : signature.returns ?? "unknown";
+  const restated = restatedFact({ ...base, form, target }, stored, params, returns);
+  if (restated) facts.sources.push(restated);
+  facts.sources.push({ ...base, form, target, outcome: "resolved" });
+  const resolved = { ...stored, returns };
+  if (params) resolved.params = params.map((p) => ({ ...p }));
+  else delete resolved.params;
+  if (!params && hit) resolved.signature = hit.method.signature.replace(new RegExp(`^\\s*${hit.method.name}\\b`), stored.name);
+  return resolved;
+}
+function withDerivedText(method, stored, specId, kind, facts) {
+  const derived = deriveMethodSignature({ ...method, signature: stored ?? method.signature });
+  if (derived === void 0) return method;
+  if (stored !== void 0 && stored !== derived) facts.staleTexts.push({ specId, kind, method: method.name, stored, derived });
+  return { ...method, signature: derived };
+}
+function resolveTree(interfaces, components, types, references = []) {
+  const intfs = interfaces.map((i) => ({ ...i, methods: i.methods.map((m) => ({ ...m })) }));
+  const typeCopies = types.map((t) => ({ ...t, methods: t.methods.map((m) => ({ ...m })) }));
+  const tables = tablesOf(intfs, [...components], typeCopies, references);
+  const facts = emptySignatureFacts();
+  const sourced = intfs.map((intf) => ({
+    ...intf,
+    methods: intf.methods.map((m) => m.signatureFrom !== void 0 ? resolveSourced(tables, intf, m, facts) : m)
+  }));
+  const resolvedInterfaces = sourced.map((intf, i) => ({
+    ...intf,
+    methods: intf.methods.map((m, j) => withDerivedText(m, intfs[i].methods[j].signature, intf.id, "interface", facts))
+  }));
+  const resolvedTypes = typeCopies.map((t) => ({
+    ...t,
+    methods: t.methods.map((m) => withDerivedText(m, m.signature, t.id, "type", facts))
+  }));
+  return { interfaces: resolvedInterfaces, types: resolvedTypes, facts };
+}
+
 // src/core/specs.ts
 var PartReadOnly = class extends WaironError {
   constructor(message) {
@@ -26931,7 +27516,8 @@ function emptyIndex() {
       implementation: {},
       type: {},
       group: {}
-    }
+    },
+    signatures: { sources: [], staleTexts: [] }
   };
 }
 function isWithin(dir, file) {
@@ -27164,6 +27750,17 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
   walk2(root, "", /* @__PURE__ */ new Set([chainDirKey(root)]), 0);
   return inspection;
 }
+function signatureSourceParts(value) {
+  const dot = value.lastIndexOf(".");
+  if (dot <= 0 || dot === value.length - 1) return null;
+  return { head: value.slice(0, dot), tail: value.slice(dot + 1) };
+}
+function mapSignatureSource(value, map) {
+  const parts = signatureSourceParts(value);
+  if (!parts) return value;
+  const head2 = map("signatureFrom", parts.head);
+  return head2 === parts.head ? value : `${head2}.${parts.tail}`;
+}
 function mapSpecReferences(kind, spec, map) {
   switch (kind) {
     case "subsystem": {
@@ -27194,7 +27791,15 @@ function mapSpecReferences(kind, spec, map) {
     }
     case "interface": {
       const i = spec;
-      return { ...i, component: map("contract", i.component) };
+      return {
+        ...i,
+        component: map("contract", i.component),
+        // A method source's head is a component reference; a value with no
+        // head is a raw type position the mapper is never asked about.
+        ...i.methods?.some((m) => m.signatureFrom !== void 0) ? {
+          methods: i.methods.map((m) => m.signatureFrom !== void 0 ? { ...m, signatureFrom: mapSignatureSource(m.signatureFrom, map) } : m)
+        } : {}
+      };
     }
     case "implementation": {
       const impl = spec;
@@ -27239,6 +27844,7 @@ function rawReferences(kind, spec) {
       for (const m of spec.methods) {
         qualifiedTypeNames(m.returns).forEach((t) => add2("type", t));
         m.params?.forEach((p) => qualifiedTypeNames(p.type).forEach((t) => add2("type", t)));
+        if (m.signatureFrom !== void 0 && !signatureSourceParts(m.signatureFrom)) add2("type", m.signatureFrom);
       }
       break;
     case "implementation":
@@ -27250,9 +27856,14 @@ function rawReferences(kind, spec) {
         }
       }
       break;
-    case "type":
-      for (const f of spec.fields) qualifiedTypeNames(f.type).forEach((t) => add2("type", t));
+    case "type": {
+      const t = spec;
+      for (const f of t.fields) qualifiedTypeNames(f.type).forEach((n) => add2("type", n));
+      t.params?.forEach((p) => qualifiedTypeNames(p.type).forEach((n) => add2("type", n)));
+      qualifiedTypeNames(t.returns).forEach((n) => add2("type", n));
+      for (const m of t.methods ?? []) m.params?.forEach((p) => qualifiedTypeNames(p.type).forEach((n) => add2("type", n)));
       break;
+    }
     default:
       break;
   }
@@ -27283,6 +27894,8 @@ function bareRawReferences(kind, spec) {
     case "type": {
       const t = spec;
       for (const f of t.fields) for (const ref of fieldTypeRefs(t, f.type)) add2("type", ref);
+      for (const ref of signatureTypeRefs(t)) add2("type", ref);
+      for (const m of t.methods ?? []) for (const p of m.params ?? []) for (const ref of fieldTypeRefs(t, p.type)) add2("type", ref);
       break;
     }
     case "implementation":
@@ -27349,6 +27962,9 @@ function respellStoredReferences(kind, doc, map) {
         typed(m, "signature");
         typed(m, "returns");
         for (const p of list(m.params)) typed(p, "type");
+        if (typeof m.signatureFrom === "string") {
+          m.signatureFrom = signatureSourceParts(m.signatureFrom) ? mapSignatureSource(m.signatureFrom, map) : mapTypeNames(m.signatureFrom, map);
+        }
       }
       break;
     case "implementation":
@@ -27374,6 +27990,9 @@ function respellStoredReferences(kind, doc, map) {
       at(doc, "subsystem", "subsystem");
       at(doc, "group", "group");
       for (const f of list(doc.fields)) typed(f, "type");
+      for (const p of list(doc.params)) typed(p, "type");
+      typed(doc, "returns");
+      for (const m of list(doc.methods)) for (const p of list(m.params)) typed(p, "type");
       break;
     default:
       break;
@@ -27393,7 +28012,9 @@ function mapRawReferences(kind, spec, map) {
           ...m,
           ...m.signature !== void 0 ? { signature: mapTypeNames(m.signature, map) } : {},
           ...m.returns !== void 0 ? { returns: mapTypeNames(m.returns, map) } : {},
-          ...m.params ? { params: m.params.map((p) => ({ ...p, type: mapTypeNames(p.type, map) })) } : {}
+          ...m.params ? { params: m.params.map((p) => ({ ...p, type: mapTypeNames(p.type, map) })) } : {},
+          // A type source is a raw type position; a method source's head is bound, never raw.
+          ...m.signatureFrom !== void 0 && !signatureSourceParts(m.signatureFrom) ? { signatureFrom: mapTypeNames(m.signatureFrom, map) } : {}
         }))
       };
     }
@@ -27421,7 +28042,14 @@ function mapRawReferences(kind, spec, map) {
     }
     case "type": {
       const t = spec;
-      return { ...t, fields: t.fields.map((f) => ({ ...f, type: mapTypeNames(f.type, map) })) };
+      const typedParams = (params) => params ? { params: params.map((p) => ({ ...p, type: mapTypeNames(p.type, map) })) } : {};
+      return {
+        ...t,
+        fields: t.fields.map((f) => ({ ...f, type: mapTypeNames(f.type, map) })),
+        ...typedParams(t.params),
+        ...t.returns !== void 0 ? { returns: mapTypeNames(t.returns, map) } : {},
+        methods: (t.methods ?? []).map((m) => ({ ...m, ...typedParams(m.params) }))
+      };
     }
     default:
       return spec;
@@ -27760,6 +28388,7 @@ function specKind(raw) {
   if ("component" in raw && Array.isArray(raw.methods)) return "interface";
   if ("contract" in raw && Array.isArray(raw.methods)) return "implementation";
   if ("kind" in raw && Array.isArray(raw.fields)) return "type";
+  if (raw.kind === "signature") return "type";
   return void 0;
 }
 function rewriteSpecRefs(raw, remap) {
@@ -27814,6 +28443,16 @@ function rewriteSpecRefs(raw, remap) {
     rewrite(raw, "component", "component");
     for (const method of entries(raw.methods)) {
       for (const param of entries(method?.params)) rewrite(param, "type", "type");
+      const source = method?.signatureFrom;
+      if (typeof source !== "string") continue;
+      const parts = signatureSourceParts(source);
+      const name = parts ? remap(parts.tail, "method", parts.head) : void 0;
+      const component = parts ? remap(parts.head, "component", parts.tail) : void 0;
+      const next = parts && (component !== parts.head || name !== parts.tail) ? `${component}.${name}` : remap(source, "type");
+      if (next !== source) {
+        method.signatureFrom = next;
+        changed = true;
+      }
     }
   } else if (kind === "implementation") {
     rewrite(raw, "contract", "interface");
@@ -27844,6 +28483,11 @@ function rewriteSpecRefs(raw, remap) {
   } else if (kind === "type") {
     rewrite(raw, "componentClass", "entity-class");
     for (const field of entries(raw.fields)) rewrite(field, "type", "type");
+    for (const param of entries(raw.params)) rewrite(param, "type", "type");
+    rewrite(raw, "returns", "type");
+    for (const method of entries(raw.methods)) {
+      for (const param of entries(method?.params)) rewrite(param, "type", "type");
+    }
   }
   return changed;
 }
@@ -28362,6 +29006,10 @@ var SpecWorkspace = class {
       index.groups.push(...raw.index.groups);
       for (const kind of Object.keys(index.paths)) Object.assign(index.paths[kind], raw.index.paths[kind]);
     }
+    const signatures = resolveTree(index.interfaces, index.components, index.types, raws.flatMap((r) => r.record.authoredReferences));
+    index.interfaces = signatures.interfaces;
+    index.types = signatures.types;
+    index.signatures = signatures.facts;
     return { index, raws, readables };
   }
   /**
@@ -28787,7 +29435,9 @@ var SpecWorkspace = class {
         rewrite: local
       });
     };
+    const localComponents = new Set(index.components.map((c) => nameKey(c.id.split("::").pop())));
     const bindLocal = (kind, specKey) => (position, value) => {
+      if (position === "signatureFrom" && !value.includes("::") && !localComponents.has(nameKey(value))) return value;
       if (value.includes("::")) {
         raw.pending.push({ kind, specKey, position, authored: value, raw: false });
         return value;
@@ -29122,7 +29772,8 @@ var SpecWorkspace = class {
     this.scanAll();
     const from = this.getSubprojectPrefix(spec.id) ?? "";
     const carrying = carry && !this.carryDisabled ? /* @__PURE__ */ new Map() : null;
-    const mapped = mapSpecReferences(kind, spec, (position, value) => this.writeReference(from, spec.id, position, value, carrying));
+    const components = new Set(this.scanAll().components.map((c) => c.id));
+    const mapped = mapSpecReferences(kind, spec, (position, value) => position === "signatureFrom" && !components.has(value) ? value : this.writeReference(from, spec.id, position, value, carrying));
     return { ...mapped, id: localOf(from, spec.id).split("::").pop() };
   }
   // -------------------------------------------------------------------------
@@ -29218,8 +29869,8 @@ var SpecWorkspace = class {
     if (pathExists(this.paths.specsInterfacesDir()) && listFiles(this.paths.specsInterfacesDir(), ".yaml").length > 0) {
       return path21.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
     }
-    const targetComponent = componentId || "default";
-    return path21.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
+    const targetComponent2 = componentId || "default";
+    return path21.join(this.paths.specsDir(), "default", targetComponent2, ".interface.yaml");
   }
   getImplementationPath(id, contractId) {
     const index = this.scanAll();
@@ -29415,8 +30066,15 @@ var SpecWorkspace = class {
   prepareComponentForWrite(spec) {
     return this.relativizeSpec("component", spec);
   }
+  /**
+   * spec_registry.saveInterfaceSpec steps 1-2: every method in its stored form
+   * (method_signature.storedForm — the text a method's params derive, nothing
+   * a signatureFrom supplies), then every reference written back relative to
+   * the owning project.
+   */
   prepareInterfaceForWrite(spec) {
-    return this.relativizeSpec("interface", spec);
+    const stored = { ...spec, methods: (spec.methods ?? []).map((m) => storedMethodSignature(m)) };
+    return this.relativizeSpec("interface", stored);
   }
   prepareImplementationForWrite(spec, carry = true) {
     const relative19 = this.relativizeSpec("implementation", spec, carry);
@@ -29426,8 +30084,10 @@ var SpecWorkspace = class {
     const partDir = this.partHolding(this.getImplementationPath(spec.id, spec.contract))?.part.directory;
     return partDir ? partRelativeFilePaths(relative19, this.rootDir, partDir) : relative19;
   }
+  /** A type written in its stored form — every params-bearing method's text derived — relative to the owning project. */
   prepareTypeForWrite(spec) {
-    return this.relativizeSpec("type", spec);
+    const stored = { ...spec, methods: (spec.methods ?? []).map((m) => storedTypeMethod(m)) };
+    return this.relativizeSpec("type", stored);
   }
   prepareGroupForWrite(spec) {
     return this.relativizeSpec("group", spec);
@@ -29637,7 +30297,7 @@ var SpecWorkspace = class {
     if (!pathExists(p)) return null;
     try {
       const raw = readSpecFile(p);
-      return InterfaceSpecSchema.parse(raw);
+      return resolveTree([InterfaceSpecSchema.parse(raw)], index.components, index.types).interfaces[0];
     } catch (e) {
       this.loaderIssues.push({
         severity: "error",
@@ -30202,6 +30862,17 @@ var SpecWorkspace = class {
    * dry-run a promotion (write 'complete' → validate → restore) without leaving
    * any change behind if validation fails or the user cancels.
    */
+  /**
+   * ispec_index.signatureFacts — what the current scan's signature resolution
+   * recorded: every signatureFrom met and how it resolved, and every stored
+   * text its params contradict. Read from the cached scan, rescanning first
+   * when the tree changed.
+   */
+  signatureFacts() {
+    const index = this;
+    index.listProjectRoots();
+    return this.cachedIndex.signatures;
+  }
   snapshotSpecFiles() {
     const index = this.scanAll();
     const snapshot = /* @__PURE__ */ new Map();
@@ -30299,7 +30970,7 @@ var SpecWorkspace = class {
    */
   updateSpec(kind, id, delta, hooks, dryRun = false) {
     const notices = [];
-    const result = this.load(kind, id);
+    const result = storedFormOf(kind, this.load(kind, id));
     if (!result) {
       throw new Error(`Spec of kind "${kind}" with ID "${id}" does not exist. Define it first.`);
     }
@@ -30812,6 +31483,7 @@ var SpecWorkspace = class {
     const qualifiedDelta = qualifyDeltaRefs(mergeableDelta);
     const mergedResult = mergeDelta(result, qualifiedDelta);
     for (const field of unsetFields) delete mergedResult[field];
+    deriveMergedTexts(kind, mergedResult);
     const withDefaults = deltaSchema.safeParse(mergedResult);
     if (withDefaults.success) {
       for (const [key, value] of Object.entries(withDefaults.data)) {
@@ -31348,6 +32020,26 @@ var PROSE_FIELDS = /* @__PURE__ */ new Set([
   "caller"
 ]);
 var DELTA_JUMP_PINS = /* @__PURE__ */ Symbol("jumps written by this delta");
+function storedFormOf(kind, spec) {
+  if (!spec) return spec;
+  if (kind === "interface") {
+    const intf = spec;
+    return { ...intf, methods: intf.methods.map((m) => storedMethodSignature(m)) };
+  }
+  if (kind === "type") {
+    const type = spec;
+    return { ...type, methods: type.methods.map((m) => storedTypeMethod(m)) };
+  }
+  return spec;
+}
+function deriveMergedTexts(kind, merged) {
+  if (kind !== "interface" && kind !== "type" || !Array.isArray(merged.methods)) return;
+  merged.methods = merged.methods.map((m) => {
+    if (!m || typeof m !== "object" || m.signatureFrom !== void 0 || !Array.isArray(m.params)) return m;
+    const derived = deriveMethodSignature(m);
+    return derived === void 0 ? m : { ...m, signature: derived };
+  });
+}
 function cloneSpec(spec) {
   return JSON.parse(JSON.stringify(spec));
 }
@@ -31714,6 +32406,9 @@ function specPathsInScope(scopeSubsystem) {
 function snapshotSpecFiles() {
   return current().snapshotSpecFiles();
 }
+function signatureFacts() {
+  return current().signatureFacts();
+}
 function findLegacySpecFiles() {
   return current().findLegacySpecFiles();
 }
@@ -31982,7 +32677,7 @@ function referencedKeys(part, types) {
   }
   for (const i of loadInterfaceSpecs().filter((x) => own.has(x.id))) {
     add2(i.component);
-    for (const m of i.methods) addTypes(methodTypeRefs(m));
+    for (const m of i.methods) addTypes(sourcedMethodTypeRefs(m));
   }
   for (const impl of loadImplementationSpecs().filter((x) => own.has(x.id))) {
     add2(impl.contract);
@@ -31995,10 +32690,20 @@ function referencedKeys(part, types) {
   }
   for (const t of types.filter((x) => own.has(x.id))) {
     add2(t.subsystem);
-    for (const f of t.fields ?? []) addTypes(fieldTypeRefs(t, f.type));
+    addTypes(typeSpecTypeRefs(t));
   }
   return out;
 }
+function sourcedMethodTypeRefs(m) {
+  return [...methodTypeRefs(m), ...m.signatureFrom !== void 0 ? [m.signatureFrom] : []];
+}
+function typeSpecTypeRefs(t) {
+  return [
+    ...(t.fields ?? []).flatMap((f) => fieldTypeRefs(t, f.type)),
+    ...(t.methods ?? []).filter((m) => m.params !== void 0).flatMap((m) => methodTypeRefs(m)),
+    ...signatureTypeRefs(t)
+  ];
+}
 var KINDS = ["component", "interface", "subsystem", "type", "implementation"];
 function closeOver(keys, types) {
   const out = /* @__PURE__ */ new Map();
@@ -32018,10 +32723,9 @@ function closeOver(keys, types) {
       queue.push(comp.subsystem);
       for (const contract of interfaces.filter((i) => i.component === comp.id)) queue.push(contract.id);
     } else if (found.kind === "interface") {
-      for (const m of found.spec.methods) addTypes(methodTypeRefs(m));
+      for (const m of found.spec.methods) addTypes(sourcedMethodTypeRefs(m));
     } else if (found.kind === "type") {
-      const type = found.spec;
-      for (const f of type.fields ?? []) addTypes(fieldTypeRefs(type, f.type));
+      addTypes(typeSpecTypeRefs(found.spec));
     } else if (found.kind === "implementation") {
       queue.push(found.spec.contract);
     }
@@ -33561,7 +34265,11 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   for (const contract of moving) {
     saveInterfaceSpec({
       ...contract,
-      methods: contract.methods.map((m) => m.name === methodName ? { ...m, name: newName, signature: renameInSignature(m.signature, methodName, newName) } : m)
+      methods: contract.methods.map((m) => m.name === methodName ? {
+        ...m,
+        name: newName,
+        ...m.params === void 0 && m.signatureFrom === void 0 ? { signature: renameInSignature(m.signature, methodName, newName) } : {}
+      } : m)
     });
     renamed.push(contract.id);
   }
@@ -35076,6 +35784,46 @@ function repairForeignStepFields(apply3) {
   return repairs;
 }
 
+// src/core/signature-repair.ts
+function repairSignatures(apply3) {
+  const facts = signatureFacts();
+  const repairs = /* @__PURE__ */ new Map();
+  const repairOf = (specId, kind) => {
+    const key = `${kind}:${specId}`;
+    let repair = repairs.get(key);
+    if (!repair) {
+      repair = { specId, kind, regenerated: [], dropped: [] };
+      repairs.set(key, repair);
+    }
+    return repair;
+  };
+  const held = new Set(facts.sources.filter((f) => f.outcome === "restated" && f.differs).map((f) => f.interfaceId));
+  const own = (specId, kind) => !specId.includes("::") && !(kind === "interface" && held.has(specId));
+  for (const stale of facts.staleTexts) {
+    if (own(stale.specId, stale.kind)) repairOf(stale.specId, stale.kind).regenerated.push(stale);
+  }
+  for (const fact of facts.sources) {
+    if (fact.outcome !== "restated" || fact.differs || !own(fact.interfaceId, "interface")) continue;
+    repairOf(fact.interfaceId, "interface").dropped.push(fact.method);
+  }
+  const planned = [...repairs.values()];
+  if (apply3 && planned.length > 0) {
+    const interfaces = new Map(loadInterfaceSpecs().map((i) => [i.id, i]));
+    const types = new Map(loadTypeSpecs().map((t) => [t.id, t]));
+    for (const repair of planned) {
+      if (repair.kind === "interface") {
+        const intf = interfaces.get(repair.specId);
+        if (intf) saveInterfaceSpec(intf);
+        continue;
+      }
+      const type = types.get(repair.specId);
+      if (type) saveSpec("type", type);
+    }
+    invalidateSpecCache();
+  }
+  return planned;
+}
+
 // src/core/approval.ts
 var crypto7 = __toESM(require("crypto"));
 var path35 = __toESM(require("path"));
@@ -36103,6 +36851,8 @@ function componentCandidateGate(options = candidateOptions(), storedOwner) {
   return {
     gate: (kind, merged) => {
       refuseUnknownOwner(kind, merged, storedOwner);
+      const restated = kind === "interface" ? restatedSources(merged.methods) : [];
+      if (restated.length) throw new Error(`${restatedSourceRefusal(String(merged.id), restated)} Nothing was written.`);
       if (kind !== "component") return;
       const verdict = validateComponentCandidate(merged, options);
       if (verdict.errors.length) throw new Error(formatCandidateRefusal(verdict));
@@ -36110,6 +36860,43 @@ function componentCandidateGate(options = candidateOptions(), storedOwner) {
     }
   };
 }
+function restatedSources(methods) {
+  if (!Array.isArray(methods)) return [];
+  return methods.filter((m) => m && typeof m === "object" && m.signatureFrom !== void 0 && (m.params !== void 0 || m.returns !== void 0)).map((m) => String(m.name));
+}
+function restatedSourceRefusal(id, methods) {
+  return `SIGNATURE_SOURCE_RESTATED: interface "${id}" \u2014 ${methods.map((n) => `"${n}"`).join(", ")} ${methods.length === 1 ? "names" : "name"} a signatureFrom and also ${methods.length === 1 ? "states" : "state"} params or returns. The source supplies them: state the signatureFrom alone, or the params and returns alone. To adopt a source on a method that states its own, unset its params and returns in the same delta.`;
+}
+function unsignedMethods(methods) {
+  if (!Array.isArray(methods)) return [];
+  return methods.filter((m) => m && typeof m === "object" && m.signatureFrom === void 0 && m.params === void 0 && (typeof m.signature !== "string" || m.signature.trim() === "")).map((m) => String(m.name));
+}
+function deriveStatedTexts(kind, candidate) {
+  if (kind !== "interface" && kind !== "type" || !Array.isArray(candidate.methods)) return [];
+  const differed = [];
+  candidate.methods = candidate.methods.map((m) => {
+    if (!m || typeof m !== "object" || m.signatureFrom !== void 0 || !Array.isArray(m.params)) return m;
+    const derived = deriveMethodSignature(m);
+    if (derived === void 0) return m;
+    if (typeof m.signature === "string" && m.signature !== derived) differed.push(`"${m.name}": stated "${m.signature}", written "${derived}"`);
+    return { ...m, signature: derived };
+  });
+  return differed.length === 0 ? [] : [
+    `Signature text derived from params, not taken as stated \u2014 ${differed.join("; ")}. A method with params shows the text its params derive.`
+  ];
+}
+function storedForm(kind, spec) {
+  if (!spec) return spec;
+  if (kind === "interface") {
+    const intf = spec;
+    return { ...intf, methods: intf.methods.map((m) => storedMethodSignature(m)) };
+  }
+  if (kind === "type") {
+    const type = spec;
+    return { ...type, methods: type.methods.map((m) => storedTypeMethod(m)) };
+  }
+  return spec;
+}
 function refuseUnknownOwner(kind, merged, storedOwner) {
   if (kind !== "component" && kind !== "type") return;
   const owner = merged.subsystem;
@@ -36154,7 +36941,8 @@ function restatementParent(restatement) {
       return null;
   }
 }
-function applyRestatement(restatement, existing, parent) {
+function applyRestatement(restatement, loaded, parent) {
+  const existing = storedForm(restatement.kind, loaded);
   const replacedExisting = existing !== null;
   const parentRef = restatementParent(restatement);
   if (parentRef && !parent) return refused(restatement, replacedExisting, MISSING_PARENT[restatement.kind](parentRef.id));
@@ -36165,6 +36953,19 @@ function applyRestatement(restatement, existing, parent) {
   const carried = carryInto(restatement, existing, candidate);
   const cleared = clearedByOmission(existing, candidate, restatement.fields);
   stampLifecycle(candidate, existing, status.status);
+  if (restatement.kind === "interface") {
+    const restated = restatedSources(candidate.methods);
+    if (restated.length) return refused(restatement, replacedExisting, `${restatedSourceRefusal(String(candidate.id), restated)} Nothing was written.`);
+  }
+  const unsigned = restatement.kind === "interface" || restatement.kind === "type" ? unsignedMethods(candidate.methods) : [];
+  if (unsigned.length) {
+    return refused(
+      restatement,
+      replacedExisting,
+      `Refusing to write ${restatement.kind} "${String(candidate.id)}": ${unsigned.map((n) => `"${n}"`).join(", ")} ${unsigned.length === 1 ? "states" : "state"} neither params${restatement.kind === "interface" ? ", a signatureFrom" : ""} nor a prose signature, so nothing says what the method takes. Nothing was written.`
+    );
+  }
+  const derivedNotices = deriveStatedTexts(restatement.kind, candidate);
   const labelErrors = resolveLabelsOf(restatement.kind, candidate);
   if (labelErrors.length) {
     return refused(restatement, replacedExisting, `Unresolved narrative label references \u2014 nothing was saved:
@@ -36176,7 +36977,7 @@ function applyRestatement(restatement, existing, parent) {
     spec: parsed.spec,
     ...status.status ? { status: status.status } : {},
     replacedExisting,
-    notices: existing ? rewriteNotices(restatement.kind, existing, candidate, carried, cleared) : [],
+    notices: [...existing ? rewriteNotices(restatement.kind, existing, candidate, carried, cleared) : [], ...derivedNotices],
     changedMethods: changedMethodsOf(restatement.kind, existing, candidate)
   };
 }
@@ -40187,8 +40988,27 @@ var getSpecOutput = {
   }).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).")
+  })).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."
+  ),
   ...staleServerOutput
 };
+function storedContractAnswer(loaded) {
+  const resolvedSignatures = loaded.methods.filter((m) => m.signatureFrom !== void 0).map((m) => ({
+    method: m.name,
+    signatureFrom: m.signatureFrom,
+    signature: m.signature,
+    ...m.params ? { params: m.params } : {},
+    returns: m.returns
+  }));
+  return { spec: { ...loaded, methods: loaded.methods.map((m) => storedMethodSignature(m)) }, resolvedSignatures };
+}
 var FINGERPRINT_VERSION = 1;
 function schemaShape(schema, seen = /* @__PURE__ */ new Map()) {
   const def = schema?._def;
@@ -40966,19 +41786,25 @@ ${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(
+      '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 is a union \u2014 "ProjectConfig | null". Say whichever is true; they are different contracts.'
+    )
+  }).strict();
   const interfaceMethodShape = {
     name: import_zod11.z.string(),
     description: import_zod11.z.string(),
-    signature: import_zod11.z.string(),
-    returns: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The type the method answers with")),
-    params: import_zod11.z.array(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(
-        '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 is a union \u2014 "ProjectConfig | null". Say whichever is true; they are different contracts.'
-      )
-    }).strict()).optional().describe("Structured parameters \u2014 authoritative for type checking (the prose signature becomes display-only). Strongly preferred."),
+    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 (`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(
+      "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({
@@ -41006,7 +41832,7 @@ ${renderChangeReport(report2)}`,
     server,
     "sdd_define_interface",
     {
-      description: "Define an L3 Contract / Interface with method signatures for a component. Prefer supplying structured `params` per method \u2014 they are the authoritative source for type checking (the free-form signature string then becomes display-only and is never heuristically parsed). A method declares the finding codes it reports in `findings` ({code, severity, summary}); each code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). Re-defining an existing id REPLACES the method list: a method left out of the input is REMOVED (and reported); spec-level lint/ext and each method's endpoint binding are carried forward, and the stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and the notices a restatement raised, each as its own entry.",
+      description: "Define an L3 Contract / Interface with method signatures for a component. Each method states its signature ONE of three ways: structured `params` with `returns` (strongly preferred \u2014 authoritative for type checking, and the signature text is then DERIVED and written by the server; a text you pass is ignored and a notice names one that differed), a `signatureFrom` naming its source \u2014 a signature type, or `component.method` along a dependsOn/owns edge \u2014 with neither params nor returns (both together are refused, SIGNATURE_SOURCE_RESTATED), or, for a method without params, a prose `signature` with `returns`. A method declares the finding codes it reports in `findings` ({code, severity, summary}); each code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). Re-defining an existing id REPLACES the method list: a method left out of the input is REMOVED (and reported); spec-level lint/ext and each method's endpoint binding are carried forward, and the stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and the notices a restatement raised, each as its own entry.",
       inputSchema: interfaceInput,
       outputSchema: specWriteReceiptOutput
     },
@@ -41214,7 +42040,7 @@ ${renderChangeReport(report2)}`,
     }
   );
   const typeInput = {
-    kind: import_zod11.z.enum(["entity", "value-object"]).describe("entity (owned by a subsystem) or value-object (often system-level shared)"),
+    kind: import_zod11.z.enum(["entity", "value-object", "signature"]).describe("entity (owned by a subsystem), value-object (often system-level shared), or signature \u2014 a named function type: params and returns, nothing else"),
     id: import_zod11.z.string().describe("Lowercase identifier"),
     name: import_zod11.z.string().describe("Human-readable name"),
     description: import_zod11.z.string().optional(),
@@ -41230,7 +42056,8 @@ ${renderChangeReport(report2)}`,
     }).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(),
+      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"),
@@ -41245,18 +42072,20 @@ ${renderChangeReport(report2)}`,
     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')
+    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"))
   };
   const typeInputFields = Object.keys(typeInput);
   reg(
     server,
     "sdd_add_type",
     {
-      description: "Define an entity or value-object type (the data components operate on). Entities are owned by a subsystem; shared value objects omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument. A type may also CLAIM code: sourcePath names the file holding its declaration (and each method may name its own), symbol binds the code-level name when it differs \u2014 the file must then resolve and the declaration must be anchored in it. An owning subsystem the tree does not have is refused, writing nothing, exactly as a component under an unknown subsystem is. Re-defining an existing id REPLACES fields/methods/invariants and restates sourcePath/symbol (an omitted list or path is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
+      description: "Define a type: an entity or value-object (the data components operate on), or a signature \u2014 a named function type. Entities are owned by a subsystem; shared value objects and signatures omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument \u2014 and a type method may carry structured params, which then derive its signature text as a contract method's do. A signature carries top-level params and returns and nothing else (no fields, methods or invariants \u2014 SIGNATURE_TYPE_MEMBERS); a contract method takes it by naming it as its signatureFrom, and a param may be typed by one (a callback). A type may also CLAIM code: sourcePath names the file holding its declaration (and each method may name its own), symbol binds the code-level name when it differs \u2014 the file must then resolve and the declaration must be anchored in it. An owning subsystem the tree does not have is refused, writing nothing, exactly as a component under an unknown subsystem is. Re-defining an existing id REPLACES fields/methods/invariants and restates sourcePath/symbol (an omitted list or path is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
       inputSchema: typeInput,
       outputSchema: specWriteReceiptOutput
     },
-    ({ kind, id, name, description, subsystem, group, fields, methods, componentClass, invariants, database, table, linkedEntity, sourcePath, symbol }) => {
+    ({ kind, id, name, description, subsystem, group, fields, methods, componentClass, invariants, database, table, linkedEntity, sourcePath, symbol, params, returns }) => {
       try {
         const spec = {
           kind,
@@ -41280,7 +42109,9 @@ ${renderChangeReport(report2)}`,
           ...table ? { table } : {},
           ...linkedEntity ? { linkedEntity } : {},
           ...sourcePath ? { sourcePath } : {},
-          ...symbol ? { symbol } : {}
+          ...symbol ? { symbol } : {},
+          ...params ? { params } : {},
+          ...returns ? { returns } : {}
         };
         const receipt = writeSpec({ kind: "type", spec, fields: typeInputFields });
         return writeReceipt(
@@ -41338,7 +42169,7 @@ ${renderChangeReport(report2)}`,
     server,
     "sdd_get_spec",
     {
-      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. The structured content carries the same answer with the two derived markers KEPT SEPARATE from the stored spec ({kind, id, spec, partialResult?, variantGuidance?}), so nothing derived can be mistaken for something stored; the text block folds them in as it always has.`,
+      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")'),
@@ -41371,6 +42202,12 @@ ${renderChangeReport(report2)}`,
             break;
         }
         if (!result) return errText(`Spec of kind "${kind}" with ID "${id}" does not exist.`);
+        let resolvedSignatures = [];
+        if (kind === "interface") {
+          const answer = storedContractAnswer(result);
+          result = answer.spec;
+          resolvedSignatures = answer.resolvedSignatures;
+        }
         if (methods !== void 0) {
           const declared = result.methods;
           if (!Array.isArray(declared)) {
@@ -41392,19 +42229,23 @@ ${renderChangeReport(report2)}`,
             warning: `PARTIAL: ${names.length - kept.length} of this spec's ${names.length} methods are not in this answer. Never re-author from it \u2014 sdd_define_interface and sdd_write_narrative REPLACE the method list, so every method missing here would be removed from the spec.`
           };
           result = { ...result, methods: kept };
+          resolvedSignatures = resolvedSignatures.filter((r) => methods.includes(r.method));
         }
         const guidance = kind === "component" ? resolveComponentVariantGuidance(result) : null;
+        const resolved = resolvedSignatures.length > 0 ? { resolvedSignatures } : {};
         const folded = {
           ...result,
           ...partial2 ? { partialResult: partial2 } : {},
-          ...guidance ? { variantGuidance: guidance } : {}
+          ...guidance ? { variantGuidance: guidance } : {},
+          ...resolved
         };
         return structured(JSON.stringify(folded, null, 2), {
           kind,
           id,
           spec: result,
           ...partial2 ? { partialResult: partial2 } : {},
-          ...guidance ? { variantGuidance: guidance } : {}
+          ...guidance ? { variantGuidance: guidance } : {},
+          ...resolved
         });
       } catch (e) {
         return errText(String(e));
@@ -41663,6 +42504,10 @@ function loadProjectConfig3() {
   RETIRED_STEREOTYPES,
   RegistrySchema,
   RequirementItemSchema,
+  ResolvedInterfaceSpecSchema,
+  ResolvedMethodSignatureSchema,
+  ResolvedTypeMethodSchema,
+  ResolvedTypeSpecSchema,
   RulesConfigSchema,
   SCAN_EXCLUDE_DIRS,
   SDD_RULES,
@@ -41674,6 +42519,8 @@ function loadProjectConfig3() {
   SURFACE_AUDIENCES,
   SpecIdSchema,
   SpecStatusSchema,
+  StoredMethodSignatureSchema,
+  StoredTypeMethodSchema,
   SubsystemSpecSchema,
   SurfaceAudienceSchema,
   SurfaceContractEntrySchema,
@@ -41758,6 +42605,8 @@ function loadProjectConfig3() {
   dependencyCycles,
   deregisterPackRef,
   deriveExecutionProfile,
+  deriveMethodSignature,
+  deriveTypeSignature,
   derivedDocPaths,
   describeProject,
   detectDomainCandidates,
@@ -41917,6 +42766,7 @@ function loadProjectConfig3() {
   renameMethod,
   renderDiagram,
   repairForeignStepFields,
+  repairSignatures,
   repointExternal,
   requiredPolicies,
   resolveAgentTopology,
@@ -41928,6 +42778,7 @@ function loadProjectConfig3() {
   resolveImport,
   resolveInstalledPack,
   resolveProjectExports,
+  resolveSignatures,
   resolveSubprojectForNamespace,
   resolveSubsystemExports,
   resolveVariantGuidance,
@@ -41949,11 +42800,15 @@ function loadProjectConfig3() {
   setProjectRoot,
   setProjectType,
   settledSpecPaths,
+  signatureFacts,
+  signatureTypeRefs,
   specPathsInScope,
   splitNamespace,
   stepConfigVerdict,
   stepFieldsFor,
   stepGraph,
+  storedMethodSignature,
+  storedTypeMethod,
   syncContextFiles,
   technologyName,
   technologyTokens,