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

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.94";
+    WAIRON_VERSION = "5.1.1-dev.95";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -3169,6 +3169,49 @@ function conceptNoun(component) {
   }
   return "";
 }
+function requireStoredSignature(method2, ctx) {
+  if (method2.signatureFrom !== void 0) return;
+  if (method2.returns === void 0) {
+    ctx.addIssue({ code: import_zod8.z.ZodIssueCode.custom, path: ["returns"], message: "Required: a method without a signatureFrom states its returns" });
+  }
+  if (method2.params === void 0 && method2.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" });
+  }
+}
+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(method2) {
+  if (!method2.params) return void 0;
+  const generics = leadingGenericList(method2.name, method2.signature);
+  return `${method2.name}${generics}(${method2.params.map(paramText).join(", ")}): ${method2.returns ?? "unknown"}`;
+}
+function storedMethodSignature(method2) {
+  if (method2.signatureFrom !== void 0) {
+    const { params: _params, returns: _returns, signature: _signature, ...rest } = method2;
+    return rest;
+  }
+  const derived = deriveMethodSignature(method2);
+  return derived === void 0 ? method2 : { ...method2, signature: derived };
+}
 function passesIntentFloor(text3, methodName) {
   if (!text3) return false;
   const t = text3.trim();
@@ -3238,6 +3281,14 @@ function implementationSourceFiles(impl) {
   for (const method2 of impl.methods ?? []) add2(method2.sourcePath);
   return files;
 }
+function deriveTypeSignature(type) {
+  if (type.kind !== "signature") return void 0;
+  return `(${(type.params ?? []).map(paramText).join(", ")}): ${type.returns ?? "unknown"}`;
+}
+function storedTypeMethod(method2) {
+  const derived = deriveMethodSignature(method2);
+  return derived === void 0 ? method2 : { ...method2, signature: derived };
+}
 function typeSourceFiles(type) {
   const files = [];
   const add2 = (file) => {
@@ -3253,7 +3304,7 @@ function relationHealth(status2) {
   if (status2.drifted) return "drifted";
   return "ok";
 }
-var import_zod8, SpecIdSchema, SpecStatusSchema, BoundaryItemSchema, RequirementItemSchema, DatabaseSpecSchema, DiagramConfigSchema, SURFACE_AUDIENCES, SurfaceAudienceSchema, SystemPublicInterfaceSchema, SystemSpecSchema, PublicInterfaceTypeSchema, PublicInterfaceSchema, TrustedLinkSchema, LintAllowSchema, LintConfigSchema, ExtDataSchema, LifecycleEntrypointSchema, SubsystemSpecSchema, ComponentTypeSchema, PATTERN_TYPES, RETIRED_STEREOTYPES, PortalTypeSchema, DispatchBindingSchema, DurabilitySchema, DependencyClassSchema, PatternRefSchema, EventBindingSchema, ExternalLinkTypeSchema, ExternalLinkSchema, PortalAuthSchemeSchema, PortalAuthSchema, PortalMountSchema, ComponentSpecSchema, BLOCK_NOUNS, HttpMethodSchema, TransportSchema, EndpointSchema, SEMANTIC_GUARANTEES, GuaranteeSchema, MethodParamSchema, FindingDeclarationSchema, MethodSignatureSchema, INTENT_FLOOR_MIN_CHARS, InterfaceSpecSchema, NarrativeStepTypeSchema, LoopKindSchema, SwitchCaseSchema, CatchClauseSchema, ParallelBranchSchema, NarrativeStepSchema, NarrativeDetailSchema, ConformanceTierSchema, MethodImplementationSchema, TechnologySchema, ImplementationSpecSchema, TypeKindSchema, TypeFieldSchema, TypeMethodSchema, InvariantSchema, TypeSpecSchema, SurfaceOriginSchema, SurfaceTypeDefSchema, SurfaceTypeExportSchema, SurfaceContractEntrySchema, SurfaceSnapshotSchema, ExternalLockEntrySchema, ExternalsLockSchema, ParentExcerptSchema, NamedOpenApiSpecSchema, GroupSpecSchema;
+var import_zod8, SpecIdSchema, SpecStatusSchema, BoundaryItemSchema, RequirementItemSchema, DatabaseSpecSchema, DiagramConfigSchema, SURFACE_AUDIENCES, SurfaceAudienceSchema, SystemPublicInterfaceSchema, SystemSpecSchema, PublicInterfaceTypeSchema, PublicInterfaceSchema, TrustedLinkSchema, LintAllowSchema, LintConfigSchema, ExtDataSchema, LifecycleEntrypointSchema, SubsystemSpecSchema, ComponentTypeSchema, PATTERN_TYPES, RETIRED_STEREOTYPES, PortalTypeSchema, DispatchBindingSchema, DurabilitySchema, DependencyClassSchema, PatternRefSchema, EventBindingSchema, ExternalLinkTypeSchema, ExternalLinkSchema, PortalAuthSchemeSchema, PortalAuthSchema, PortalMountSchema, ComponentSpecSchema, BLOCK_NOUNS, HttpMethodSchema, TransportSchema, EndpointSchema, SEMANTIC_GUARANTEES, GuaranteeSchema, MethodParamSchema, FindingDeclarationSchema, MethodSignatureSchema, StoredMethodSignatureSchema, ResolvedMethodSignatureSchema, INTENT_FLOOR_MIN_CHARS, InterfaceSpecSchema, ResolvedInterfaceSpecSchema, NarrativeStepTypeSchema, LoopKindSchema, SwitchCaseSchema, CatchClauseSchema, ParallelBranchSchema, NarrativeStepSchema, NarrativeDetailSchema, ConformanceTierSchema, MethodImplementationSchema, TechnologySchema, ImplementationSpecSchema, TypeKindSchema, TypeFieldSchema, TypeMethodSchema, ResolvedTypeMethodSchema, StoredTypeMethodSchema, InvariantSchema, TypeSpecSchema, ResolvedTypeSpecSchema, SurfaceOriginSchema, SurfaceTypeDefSchema, SurfaceTypeExportSchema, SurfaceContractEntrySchema, SurfaceSnapshotSchema, ExternalLockEntrySchema, ExternalsLockSchema, ParentExcerptSchema, NamedOpenApiSpecSchema, GroupSpecSchema;
 var init_specs = __esm({
   "src/models/specs.ts"() {
     "use strict";
@@ -3651,13 +3702,21 @@ var init_specs = __esm({
     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(),
       /**
@@ -3710,6 +3769,11 @@ var init_specs = __esm({
       /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
       ext: ExtDataSchema.optional()
     });
+    StoredMethodSignatureSchema = MethodSignatureSchema.superRefine(requireStoredSignature);
+    ResolvedMethodSignatureSchema = MethodSignatureSchema.extend({
+      signature: import_zod8.z.string(),
+      returns: import_zod8.z.string()
+    });
     INTENT_FLOOR_MIN_CHARS = 40;
     InterfaceSpecSchema = import_zod8.z.object({
       id: SpecIdSchema.regex(/^i[a-z0-9-_]+$/, 'Interface id must be prefixed with a lowercase "i"'),
@@ -3717,7 +3781,7 @@ var init_specs = __esm({
       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. */
@@ -3726,6 +3790,9 @@ var init_specs = __esm({
       createdAt: import_zod8.z.string().datetime(),
       updatedAt: import_zod8.z.string().datetime()
     });
+    ResolvedInterfaceSpecSchema = InterfaceSpecSchema.extend({
+      methods: import_zod8.z.array(ResolvedMethodSignatureSchema).default([])
+    });
     NarrativeStepTypeSchema = import_zod8.z.enum([
       "local",
       // in-component work
@@ -4002,7 +4069,7 @@ var init_specs = __esm({
       createdAt: import_zod8.z.string().datetime(),
       updatedAt: import_zod8.z.string().datetime()
     });
-    TypeKindSchema = import_zod8.z.enum(["entity", "value-object"]);
+    TypeKindSchema = import_zod8.z.enum(["entity", "value-object", "signature"]);
     TypeFieldSchema = import_zod8.z.object({
       name: import_zod8.z.string(),
       // A primitive, or another type id (qualified across subsystems, e.g.
@@ -4026,7 +4093,9 @@ var init_specs = __esm({
     });
     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(),
       /**
@@ -4045,6 +4114,14 @@ var init_specs = __esm({
        */
       symbol: import_zod8.z.string().optional()
     });
+    ResolvedTypeMethodSchema = TypeMethodSchema.extend({
+      signature: import_zod8.z.string()
+    });
+    StoredTypeMethodSchema = TypeMethodSchema.superRefine((method2, ctx) => {
+      if (method2.params === void 0 && method2.signature === void 0) {
+        ctx.addIssue({ code: import_zod8.z.ZodIssueCode.custom, path: ["signature"], message: "Required: a type method without params states a prose signature" });
+      }
+    });
     InvariantSchema = import_zod8.z.object({
       /** Stable invariant id, unique within the entity (referenced as "<type-id>.<invariant-id>"). */
       id: SpecIdSchema,
@@ -4053,7 +4130,7 @@ var init_specs = __esm({
     });
     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(),
@@ -4063,7 +4140,7 @@ var init_specs = __esm({
       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).
@@ -4109,9 +4186,19 @@ var init_specs = __esm({
       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()
     });
+    ResolvedTypeSpecSchema = TypeSpecSchema.extend({
+      methods: import_zod8.z.array(ResolvedTypeMethodSchema).default([])
+    });
     SurfaceOriginSchema = import_zod8.z.enum(["generated", "exchanged", "authored"]);
     SurfaceTypeDefSchema = import_zod8.z.object({
       id: import_zod8.z.string(),
@@ -4122,7 +4209,16 @@ var init_specs = __esm({
         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()
     });
     SurfaceTypeExportSchema = import_zod8.z.object({
       /** The type's public name in the producer's export table. */
@@ -4141,8 +4237,8 @@ var init_specs = __esm({
       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(""),
@@ -4317,13 +4413,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(method2) {
-  return extractGenericTypeVariables(method2.signature);
+  return extractGenericTypeVariables(method2.signature ?? "");
 }
 function normalizePart(part) {
   return part.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -4795,9 +4896,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();
@@ -4806,7 +4919,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)));
 }
@@ -5779,6 +5892,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 } : {}
         }))
@@ -5844,6 +5958,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 } : {},
@@ -7587,15 +7702,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.
@@ -7619,6 +7736,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;
@@ -9705,7 +9829,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>');
@@ -10046,6 +10170,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>' : '')
@@ -10149,7 +10274,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);
@@ -10533,6 +10662,46 @@ function operationFor(method2, closureIds) {
   }
   return op;
 }
+function signatureComponent(t, closureIds) {
+  const params = t.params ?? [];
+  const returns = t.returns ?? "unknown";
+  const text3 = `(${params.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ")}): ${returns}`;
+  return {
+    title: t.name,
+    description: `A function type ${text3}. A function has no JSON form, so no JSON value of this type can be sent; its params and returns are under ${SIGNATURE_EXTENSION}.`,
+    [SIGNATURE_EXTENSION]: {
+      // Each type twice: as wairon wrote it (what a wairon reader decodes, exactly),
+      // and as a $ref or schema (what an OpenAPI reader can follow).
+      params: params.map((p) => ({
+        name: p.name,
+        type: p.type,
+        schema: schemaFor(p.type, closureIds),
+        ...p.optional ? { optional: true } : {},
+        ...p.description ? { description: p.description } : {}
+      })),
+      returns: { type: returns, schema: schemaFor(returns, closureIds) }
+    }
+  };
+}
+function signatureFromComponent(id, schema) {
+  const raw = schema[SIGNATURE_EXTENSION];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const ext = raw;
+  const typeOf = (entry) => {
+    if (typeof entry.type === "string" && entry.type.trim()) return entry.type;
+    const schema2 = entry.schema;
+    if (schema2 && typeof schema2 === "object" && Object.keys(schema2).length === 0) return "unknown";
+    return typeRefFromSchema(schema2);
+  };
+  const params = (Array.isArray(ext.params) ? ext.params : []).filter((p) => !!p && typeof p === "object" && typeof p.name === "string").map((p) => ({
+    name: p.name,
+    type: typeOf(p),
+    ...p.optional === true ? { optional: true } : {},
+    ...typeof p.description === "string" ? { description: p.description } : {}
+  }));
+  const returns = ext.returns && typeof ext.returns === "object" && !Array.isArray(ext.returns) ? typeOf(ext.returns) : "unknown";
+  return { id, name: typeof schema.title === "string" ? schema.title : id, kind: "signature", fields: [], params, returns };
+}
 function securitySchemeObject(auth) {
   if (auth.scheme === "none") return null;
   const desc = auth.description ? { description: auth.description } : {};
@@ -10604,7 +10773,7 @@ function renderDoc(snapshot, entries, closureIds, opts = {}) {
   }
   const schemas = {};
   for (const t of snapshot.types) {
-    schemas[t.id] = {
+    schemas[t.id] = t.kind === "signature" ? signatureComponent(t, closureIds) : {
       type: "object",
       title: t.name,
       properties: Object.fromEntries(t.fields.map((f) => [f.name, schemaFor(f.type, closureIds)])),
@@ -10764,6 +10933,11 @@ function fromOpenApi(document, projectName) {
   const types = [];
   const schemas = parsed.components?.schemas ?? {};
   for (const [id, schema] of Object.entries(schemas)) {
+    const signature = signatureFromComponent(id, schema);
+    if (signature) {
+      types.push(signature);
+      continue;
+    }
     const props = schema.properties ?? {};
     const required = new Set(schema.required ?? []);
     types.push({
@@ -10800,7 +10974,7 @@ function fromOpenApi(document, projectName) {
     types
   });
 }
-var yaml2, PRIMITIVES;
+var yaml2, PRIMITIVES, SIGNATURE_EXTENSION;
 var init_openapi = __esm({
   "src/core/openapi.ts"() {
     "use strict";
@@ -10824,6 +10998,7 @@ var init_openapi = __esm({
       unknown: {},
       void: {}
     };
+    SIGNATURE_EXTENSION = "x-wairon-signature";
   }
 });
 
@@ -10868,21 +11043,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 describe3 = (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(describe3),
+      // A signature type travels complete: its params and returns with it.
+      ...t.kind === "signature" ? { params: (t.params ?? []).map(describe3), returns: t.returns ?? "unknown" } : {}
     };
   });
 }
@@ -10895,7 +11079,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, ...method2 }) => method2);
   return {
     id: entry.publicName,
     name: entry.name ?? comp.name,
@@ -10965,7 +11149,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() {
@@ -13257,7 +13446,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 method2 of impl.methods) {
       const sourceFile = methodSourceFile(method2, impl.sourcePath);
       out.push({
@@ -13265,7 +13454,7 @@ function buildImplementationMethods(ctx) {
         method: method2,
         component,
         ...sourceFile !== void 0 ? { sourceFile } : {},
-        draftContext
+        draftContext: draftContext3
       });
     }
   }
@@ -13628,7 +13817,7 @@ var init_signature_type_references = __esm({
     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" }
       ],
@@ -13639,6 +13828,7 @@ var init_signature_type_references = __esm({
             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())
             );
@@ -13658,6 +13848,225 @@ var init_signature_type_references = __esm({
             }
           }
         }
+        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;
+var init_signature_sources = __esm({
+  "src/core/rules/integrity/signature-sources.ts"() {
+    "use strict";
+    init_models();
+    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;
+var init_signature_types = __esm({
+  "src/core/rules/integrity/signature-types.ts"() {
+    "use strict";
+    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;
+var init_signature_text = __esm({
+  "src/core/rules/integrity/signature-text.ts"() {
+    "use strict";
+    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 }
+          );
+        }
       }
     };
   }
@@ -15252,11 +15661,11 @@ var init_detail_sufficiency = __esm({
           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 method2 of impl.methods) {
             const detail = effectiveDetail(method2, impl, component);
             if (contract.methods.some((m) => m.name === method2.name) && method2.narrative.length === 0 && detail.level !== "full") {
-              dialedDown.push({ implementation: impl, method: method2, component, detail, draftContext });
+              dialedDown.push({ implementation: impl, method: method2, component, detail, draftContext: draftContext3 });
             }
           }
         }
@@ -17481,7 +17890,7 @@ var init_unused_types = __esm({
       // 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" }
       ],
@@ -17503,6 +17912,7 @@ var init_unused_types = __esm({
               markTypeReferenced(ref);
             }
           }
+          for (const ref of signatureTypeRefs(t)) markTypeReferenced(ref, t.id);
         }
         for (const intf of ctx.interfaces) {
           for (const m of intf.methods) {
@@ -17512,6 +17922,13 @@ var init_unused_types = __esm({
             }
           }
         }
+        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);
@@ -19014,7 +19431,7 @@ var init_type_shape = __esm({
     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",
@@ -19198,7 +19615,7 @@ var init_param_conformance = __esm({
           const stated = normalize3(declared.type);
           return stated === realized.type || codeNameOf.get(stated) === realized.type;
         };
-        for (const { implementation, method: method2, sourceFile, draftContext } of ctx.implementationMethods()) {
+        for (const { implementation, method: method2, sourceFile, draftContext: draftContext3 } of ctx.implementationMethods()) {
           const contract = ctx.interfaceMap.get(implementation.contract);
           const declared = contract?.methods.find((m) => m.name === method2.name)?.params ?? [];
           if (declared.length === 0 || !sourceFile) continue;
@@ -19221,7 +19638,7 @@ var init_param_conformance = __esm({
               "UNREALIZED_PARAM",
               `Method "${method2.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: method2.name, covers: unrealized.map((found) => found.unit) }
             );
@@ -19233,7 +19650,7 @@ var init_param_conformance = __esm({
               "UNDECLARED_PARAM",
               `${opening} realizing method "${method2.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: method2.name, covers: undeclared.map((found) => found.unit) }
             );
@@ -19245,7 +19662,7 @@ var init_param_conformance = __esm({
               "PARAM_NAME_MISMATCH",
               `Method "${method2.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: method2.name, covers: renamed.map((found) => found.unit) }
             );
@@ -19257,7 +19674,7 @@ var init_param_conformance = __esm({
               "PARAM_OPTIONALITY",
               `Method "${method2.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: method2.name, covers: disagreed.map((found) => found.unit) }
             );
@@ -19341,7 +19758,7 @@ var init_route_coverage = __esm({
               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(
@@ -19349,7 +19766,7 @@ var init_route_coverage = __esm({
                 "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 }
               );
@@ -19374,7 +19791,7 @@ var init_route_coverage = __esm({
                 "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 }
               );
@@ -19386,7 +19803,7 @@ var init_route_coverage = __esm({
                 "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 }
               );
@@ -19503,7 +19920,7 @@ var init_export_conformance = __esm({
             }
           }
         }
-        for (const { implementation, method: method2, sourceFile, draftContext } of ctx.implementationMethods()) {
+        for (const { implementation, method: method2, sourceFile, draftContext: draftContext3 } of ctx.implementationMethods()) {
           const handle = method2.exportedVia;
           if (!handle || !sourceFile) continue;
           const file = pathKey(sourceFile);
@@ -19518,7 +19935,7 @@ var init_export_conformance = __esm({
             "UNREALIZED_EXPORT_HANDLE",
             `Method "${method2.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) {
@@ -20886,6 +21303,74 @@ var init_naming_discipline = __esm({
   }
 });
 
+// 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;
+var init_signature_source_suggestions = __esm({
+  "src/core/rules/heuristic/signature-source-suggestions.ts"() {
+    "use strict";
+    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
 function addRule(rule) {
   ruleSet.push(rule);
@@ -20925,6 +21410,9 @@ var init_repository = __esm({
     init_type_declarations();
     init_field_type_references();
     init_signature_type_references();
+    init_signature_sources();
+    init_signature_types();
+    init_signature_text();
     init_public_surface_binding();
     init_public_surface_consumers();
     init_public_surface_declared_type();
@@ -21020,6 +21508,7 @@ var init_repository = __esm({
     init_narrative_complexity();
     init_naming_discipline();
     init_method_cohesion();
+    init_signature_source_suggestions();
     SDD_RULES = [
       hierarchyRule,
       // Namespace integrity right after hierarchy: unresolvable/unwritable ids
@@ -21038,6 +21527,9 @@ var init_repository = __esm({
       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
@@ -21223,6 +21715,7 @@ var init_repository = __esm({
       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.
@@ -21438,24 +21931,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;
@@ -21725,13 +22200,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 };
@@ -22810,6 +23320,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,
@@ -23405,6 +23916,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,
@@ -23426,6 +23938,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.
@@ -23544,12 +24057,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, [], []);
@@ -23569,6 +24096,7 @@ function judgePartAlone(config, scopeSubsystem) {
     exportTables: [],
     projectFamily: graph(),
     exportUsages: [],
+    signatureFacts: partSignatures,
     pinnedExternals: [],
     packSelections: packs.filter((p) => typeof p !== "string"),
     packRequirements: [],
@@ -24501,7 +25029,7 @@ var init_project_family2 = __esm({
 });
 
 // src/core/exports.ts
-function localName(id) {
+function localName2(id) {
   return id.split("::").pop() ?? id;
 }
 function ownedBy(subsystemId, declaringSubsystem) {
@@ -24548,7 +25076,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);
@@ -24556,7 +25084,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,
@@ -24596,7 +25124,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: [] };
   }
@@ -24604,7 +25132,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,
@@ -24639,7 +25167,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
       );
@@ -24815,16 +25343,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` });
@@ -24861,7 +25389,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
     );
@@ -25013,6 +25541,130 @@ var init_exports2 = __esm({
   }
 });
 
+// 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(method2) {
+  const { params: _params, ...rest } = method2;
+  return { ...rest, returns: "unknown", signature: `${method2.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 method2 = (tables.methodsOf.get(key) ?? []).find((m) => m.name === tail);
+    if (method2) return { target: `${key}.${tail}`, method: method2 };
+  }
+  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(method2, stored, specId, kind, facts) {
+  const derived = deriveMethodSignature({ ...method2, signature: stored ?? method2.signature });
+  if (derived === void 0) return method2;
+  if (stored !== void 0 && stored !== derived) facts.staleTexts.push({ specId, kind, method: method2.name, stored, derived });
+  return { ...method2, 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 };
+}
+var init_signature_sources2 = __esm({
+  "src/core/signature-sources.ts"() {
+    "use strict";
+    init_models();
+  }
+});
+
 // src/core/specs.ts
 function deniedOwners(reach2, owners) {
   const seen = /* @__PURE__ */ new Set();
@@ -25067,7 +25719,8 @@ function emptyIndex() {
       implementation: {},
       type: {},
       group: {}
-    }
+    },
+    signatures: { sources: [], staleTexts: [] }
   };
 }
 function isWithin(dir, file) {
@@ -25299,6 +25952,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": {
@@ -25329,7 +25993,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;
@@ -25374,6 +26046,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":
@@ -25385,9 +26058,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;
   }
@@ -25417,6 +26095,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":
@@ -25483,6 +26163,9 @@ function respellStoredReferences(kind, doc, map) {
         typed(m, "signature");
         typed(m, "returns");
         for (const p of list2(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":
@@ -25508,6 +26191,9 @@ function respellStoredReferences(kind, doc, map) {
       at(doc, "subsystem", "subsystem");
       at(doc, "group", "group");
       for (const f of list2(doc.fields)) typed(f, "type");
+      for (const p of list2(doc.params)) typed(p, "type");
+      typed(doc, "returns");
+      for (const m of list2(doc.methods)) for (const p of list2(m.params)) typed(p, "type");
       break;
     default:
       break;
@@ -25527,7 +26213,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) } : {}
         }))
       };
     }
@@ -25555,7 +26243,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;
@@ -25892,6 +26587,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) {
@@ -25946,6 +26642,16 @@ function rewriteSpecRefs(raw, remap) {
     rewrite(raw, "component", "component");
     for (const method2 of entries(raw.methods)) {
       for (const param of entries(method2?.params)) rewrite(param, "type", "type");
+      const source = method2?.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) {
+        method2.signatureFrom = next;
+        changed = true;
+      }
     }
   } else if (kind === "implementation") {
     rewrite(raw, "contract", "interface");
@@ -25976,6 +26682,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 method2 of entries(raw.methods)) {
+      for (const param of entries(method2?.params)) rewrite(param, "type", "type");
+    }
   }
   return changed;
 }
@@ -26371,6 +27082,26 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
   walk2(delta, merged, stored, "", "");
   return out;
 }
+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));
 }
@@ -26728,6 +27459,9 @@ function specPathsInScope(scopeSubsystem) {
 function snapshotSpecFiles() {
   return current().snapshotSpecFiles();
 }
+function signatureFacts() {
+  return current().signatureFacts();
+}
 function findLegacySpecFiles() {
   return current().findLegacySpecFiles();
 }
@@ -26793,6 +27527,7 @@ var init_specs2 = __esm({
     init_project_family();
     init_project_config();
     init_project_family2();
+    init_signature_sources2();
     PartReadOnly = class extends WaironError {
       constructor(message) {
         super(message);
@@ -26932,6 +27667,10 @@ var init_specs2 = __esm({
           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 };
       }
       /**
@@ -27357,7 +28096,9 @@ var init_specs2 = __esm({
             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;
@@ -27692,7 +28433,8 @@ var init_specs2 = __esm({
         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() };
       }
       // -------------------------------------------------------------------------
@@ -27788,8 +28530,8 @@ var init_specs2 = __esm({
         if (pathExists(this.paths.specsInterfacesDir()) && listFiles(this.paths.specsInterfacesDir(), ".yaml").length > 0) {
           return path23.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
         }
-        const targetComponent = componentId || "default";
-        return path23.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
+        const targetComponent2 = componentId || "default";
+        return path23.join(this.paths.specsDir(), "default", targetComponent2, ".interface.yaml");
       }
       getImplementationPath(id, contractId) {
         const index = this.scanAll();
@@ -27985,8 +28727,15 @@ var init_specs2 = __esm({
       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 relative26 = this.relativizeSpec("implementation", spec, carry);
@@ -27996,8 +28745,10 @@ var init_specs2 = __esm({
         const partDir = this.partHolding(this.getImplementationPath(spec.id, spec.contract))?.part.directory;
         return partDir ? partRelativeFilePaths(relative26, this.rootDir, partDir) : relative26;
       }
+      /** 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);
@@ -28207,7 +28958,7 @@ var init_specs2 = __esm({
         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",
@@ -28772,6 +29523,17 @@ var init_specs2 = __esm({
        * 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();
@@ -28869,7 +29631,7 @@ var init_specs2 = __esm({
        */
       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.`);
         }
@@ -29382,6 +30144,7 @@ var init_specs2 = __esm({
         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)) {
@@ -30193,7 +30956,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);
@@ -30206,10 +30969,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)
+  ];
+}
 function closeOver(keys, types) {
   const out = /* @__PURE__ */ new Map();
   const queue = [...keys];
@@ -30228,10 +31001,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);
     }
@@ -31762,7 +32534,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);
   }
@@ -36806,6 +37582,52 @@ var init_narrative_repair = __esm({
   }
 });
 
+// src/core/signature-repair.ts
+function repairSignatures(apply4) {
+  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 (apply4 && 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;
+}
+var init_signature_repair = __esm({
+  "src/core/signature-repair.ts"() {
+    "use strict";
+    init_specs2();
+  }
+});
+
 // src/models/lock.ts
 function describeApprover(who) {
   const label7 = who.name ? `${who.name} (${who.id})` : who.id;
@@ -37613,6 +38435,7 @@ var init_core = __esm({
     init_domain_curator();
     init_rules();
     init_specs2();
+    init_signature_sources2();
     init_external_producers();
     init_part_context();
     init_provision();
@@ -37633,6 +38456,7 @@ var init_core = __esm({
     init_provision();
     init_stereotype_migration();
     init_narrative_repair();
+    init_signature_repair();
     init_approval();
     init_approver();
     init_specs2();
@@ -38043,6 +38867,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));
@@ -38050,6 +38876,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;
@@ -38075,7 +38938,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));
@@ -38086,6 +38950,19 @@ function applyRestatement(restatement, existing, parent) {
   const carried = carryInto(restatement, existing, candidate);
   const cleared = clearedByOmission(existing, candidate, restatement.fields);
   stampLifecycle(candidate, existing, status2.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:
@@ -38097,7 +38974,7 @@ function applyRestatement(restatement, existing, parent) {
     spec: parsed.spec,
     ...status2.status ? { status: status2.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)
   };
 }
@@ -42137,6 +43014,16 @@ function pendingBanner() {
     return [];
   }
 }
+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 };
+}
 function schemaShape(schema, seen = /* @__PURE__ */ new Map()) {
   const def = schema?._def;
   if (!def) return null;
@@ -42986,19 +43873,25 @@ ${renderChangeReport(report3)}`,
       }
     }
   );
+  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({
@@ -43026,7 +43919,7 @@ ${renderChangeReport(report3)}`,
     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
     },
@@ -43234,7 +44127,7 @@ ${renderChangeReport(report3)}`,
     }
   );
   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(),
@@ -43250,7 +44143,8 @@ ${renderChangeReport(report3)}`,
     }).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"),
@@ -43265,18 +44159,20 @@ ${renderChangeReport(report3)}`,
     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,
@@ -43300,7 +44196,9 @@ ${renderChangeReport(report3)}`,
           ...table ? { table } : {},
           ...linkedEntity ? { linkedEntity } : {},
           ...sourcePath ? { sourcePath } : {},
-          ...symbol ? { symbol } : {}
+          ...symbol ? { symbol } : {},
+          ...params ? { params } : {},
+          ...returns ? { returns } : {}
         };
         const receipt = writeSpec({ kind: "type", spec, fields: typeInputFields });
         return writeReceipt(
@@ -43358,7 +44256,7 @@ ${renderChangeReport(report3)}`,
     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")'),
@@ -43391,6 +44289,12 @@ ${renderChangeReport(report3)}`,
             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)) {
@@ -43412,19 +44316,23 @@ ${renderChangeReport(report3)}`,
             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));
@@ -43971,6 +44879,15 @@ var init_server = __esm({
       }).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
     };
     FINGERPRINT_VERSION = 1;
@@ -47068,6 +47985,19 @@ async function runDoctor(options = {}) {
     } catch (e) {
       line(tally, "warn", `Could not plan the narrative-step repair: ${e instanceof Error ? e.message : String(e)}`);
     }
+    try {
+      const signatures = repairSignatures(false);
+      if (signatures.length > 0) {
+        console.log(import_chalk12.default.bold("Signatures"));
+        for (const repair of signatures) {
+          line(tally, "warn", `${repair.kind} ${repair.specId}: ${describeSignatureRepair(repair)}`);
+        }
+        line(tally, "warn", "Run `wairon doctor --fix` to write them in their stored form (any save of the spec does too).");
+        logger.blank();
+      }
+    } catch (e) {
+      line(tally, "warn", `Could not plan the signature repair: ${e instanceof Error ? e.message : String(e)}`);
+    }
     try {
       const planned = plan5({ verb: "chaining", rehearse: false });
       const pending4 = planned.chaining;
@@ -47288,6 +48218,17 @@ async function applyFixes(options, tally) {
   } catch (e) {
     console.log(`  ${icon("error")} Narrative-step repair failed: ${e instanceof Error ? e.message : String(e)}`);
   }
+  try {
+    const signatures = repairSignatures(true);
+    if (signatures.length > 0) {
+      console.log(`  ${icon("ok")} Rewrote ${signatures.length} spec(s) into their stored signature form:`);
+      for (const repair of signatures) {
+        console.log(`      ${repair.kind} ${repair.specId}: ${describeSignatureRepair(repair)}`);
+      }
+    }
+  } catch (e) {
+    console.log(`  ${icon("error")} Signature repair failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
   await migrateChaining(options, tally);
   await repairMcpRegistration(options, targets);
   logger.blank();
@@ -47504,6 +48445,12 @@ function printApplied(report3) {
   console.log(`  ${icon("warn")} The writes staled the approval of ${report3.relock.length} project(s); nothing was locked here. Re-lock each with \`wairon lock\`:`);
   for (const dir of report3.relock) console.log(`      ${dir}`);
 }
+function describeSignatureRepair(repair) {
+  const parts = [];
+  if (repair.regenerated.length > 0) parts.push(`regenerates the text of ${repair.regenerated.map((s) => s.method).join(", ")}`);
+  if (repair.dropped.length > 0) parts.push(`drops the restated signature of ${repair.dropped.join(", ")}`);
+  return parts.join("; ");
+}
 function pendingCount(migration) {
   return migration.rewrites.length + migration.projects.reduce((n, p) => n + (p.idToWrite ? 1 : 0) + (p.createsSystem ? 1 : 0) + p.exports.length + p.externals.length + p.imports.length + p.pins.length + p.members.length + p.supersededPins.length + p.locations.length, 0);
 }
@@ -51909,11 +52856,13 @@ function listProducerConfigs() {
 init_core();
 
 // src/producers/projection.ts
+init_models();
 function project(diagramUrl) {
   const system = loadSystemSpec();
   const subsystems = loadSubsystemSpecs();
   const components = loadComponentSpecs();
   const interfaces = loadInterfaceSpecs();
+  const types = loadTypeSpecs();
   let mermaid = "";
   try {
     mermaid = renderDiagram("mermaid");
@@ -51921,7 +52870,7 @@ function project(diagramUrl) {
   }
   return {
     title: "wairon specs",
-    body: systemBody(system, mermaid, diagramUrl),
+    body: systemBody(system, mermaid, diagramUrl, types),
     children: subsystems.map((sub) => ({
       title: sub.name || sub.id,
       body: subsystemBody(sub),
@@ -51950,7 +52899,7 @@ function projectGraph() {
   }
   return { nodes, edges };
 }
-function systemBody(system, mermaid, diagramUrl) {
+function systemBody(system, mermaid, diagramUrl, types) {
   const parts = ["_Generated by wairon from the spec tree \u2014 edit the specs, not this page._", ""];
   if (system) {
     parts.push(`# ${system.name}`, "");
@@ -51961,6 +52910,14 @@ function systemBody(system, mermaid, diagramUrl) {
   }
   if (diagramUrl) parts.push("## Diagram", `[Open the interactive canvas](${diagramUrl})`, "");
   if (mermaid) parts.push("```mermaid", mermaid.trim(), "```", "");
+  const signatures = types.filter((t) => t.kind === "signature");
+  if (signatures.length) {
+    parts.push("## Signature types");
+    for (const t of signatures) {
+      parts.push(`- **${t.name || t.id}** \`${deriveTypeSignature(t)}\`${t.description ? ` \u2014 ${t.description}` : ""}`);
+    }
+    parts.push("");
+  }
   return parts.join("\n");
 }
 function publicInterfaceLine(p) {
@@ -51988,7 +52945,10 @@ function componentBody(comp, interfaces) {
   const intf = interfaces.find((i) => i.component === comp.id);
   if (intf?.methods?.length) {
     parts.push("## Methods");
-    for (const m of intf.methods) parts.push(`- **${m.name}** \`${m.signature}\` \u2192 ${m.returns}`);
+    for (const m of intf.methods) {
+      const from = m.signatureFrom ? ` (from \`${m.signatureFrom}\`)` : "";
+      parts.push(`- **${m.name}** \`${m.signature}\`${from} \u2192 ${m.returns}`);
+    }
     parts.push("");
   }
   return parts.join("\n");
@@ -56838,8 +57798,8 @@ function narrowToScope(projects, scope) {
   if (scope.all) return projects;
   return projects.filter((p) => scope.projectIds.includes(p.id));
 }
-function resolveQuotaPolicy(cfg) {
-  return cfg.quotaPolicy ?? DISABLED_QUOTA_POLICY;
+function effectiveQuotaPolicy(cfg) {
+  return cfg?.quotaPolicy ? { ...DISABLED_QUOTA_POLICY, ...cfg.quotaPolicy } : DISABLED_QUOTA_POLICY;
 }
 function scopeRecords(projects, scope) {
   if (scope && scope.length > 0 && scope !== "instance") {
@@ -57028,7 +57988,7 @@ function evaluateQuota(cfg, credential, scope) {
   const readScope = requireOperationsReadScope(cfg, principal);
   const projects = narrowToScope(listProjectRecords(cfg.dataDir), readScope);
   const usage = collectUsage(projects, scope);
-  const policy = resolveQuotaPolicy(cfg);
+  const policy = effectiveQuotaPolicy(cfg);
   return evaluateUsage(usage, policy);
 }
 function principalSubject6(principal) {
@@ -63377,6 +64337,8 @@ function resolveHostConfig(options) {
   if (builtinPassword) cfg.builtinAdminPassword = builtinPassword;
   const auditPolicy = process.env["WAIRON_AUDIT_POLICY"];
   if (auditPolicy !== void 0 && auditPolicy.trim() !== "") cfg.auditPolicy = parseAuditPolicyEnv(auditPolicy);
+  const quotaPolicy = process.env["WAIRON_QUOTA_POLICY"];
+  if (quotaPolicy !== void 0 && quotaPolicy.trim() !== "") cfg.quotaPolicy = parseQuotaPolicyEnv(quotaPolicy);
   return cfg;
 }
 var AUDIT_POLICY_FIELDS = {
@@ -63421,6 +64383,47 @@ function parseAuditPolicyEnv(raw) {
   }
   return policy;
 }
+var NON_NEGATIVE_INTEGER = {
+  expects: "a non-negative integer",
+  accepts: (v) => typeof v === "number" && Number.isInteger(v) && v >= 0
+};
+var QUOTA_POLICY_FIELDS = {
+  enabled: { expects: "a boolean", accepts: (v) => typeof v === "boolean" },
+  // 'block' is accepted, and evaluation still downgrades it to an observation.
+  mode: {
+    expects: 'one of "observe", "warn", "block"',
+    accepts: (v) => typeof v === "string" && ["observe", "warn", "block"].includes(v)
+  },
+  maxProjectsPerUser: NON_NEGATIVE_INTEGER,
+  maxMcpRequestsPerMinute: NON_NEGATIVE_INTEGER,
+  maxProjectBytes: NON_NEGATIVE_INTEGER,
+  maxAuditEventsPerDay: NON_NEGATIVE_INTEGER
+};
+function parseQuotaPolicyEnv(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new WaironError(`WAIRON_QUOTA_POLICY is not valid JSON: ${e.message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new WaironError("WAIRON_QUOTA_POLICY must be a JSON object of quota policy fields.");
+  }
+  const policy = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    const field = QUOTA_POLICY_FIELDS[key];
+    if (!Object.prototype.hasOwnProperty.call(QUOTA_POLICY_FIELDS, key) || !field) {
+      throw new WaironError(
+        `WAIRON_QUOTA_POLICY sets an unknown field "${key}"; the known fields are ${Object.keys(QUOTA_POLICY_FIELDS).join(", ")}.`
+      );
+    }
+    if (!field.accepts(value)) {
+      throw new WaironError(`WAIRON_QUOTA_POLICY field "${key}" must be ${field.expects}.`);
+    }
+    policy[key] = value;
+  }
+  return policy;
+}
 function masterCredential() {
   return process.env["WAIRON_ADMIN_TOKEN"] ?? null;
 }