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

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.95";
+    WAIRON_VERSION = "5.1.1-dev.96";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -651,6 +651,14 @@ var init_agent = __esm({
       instructions: import_zod2.z.string(),
       /** Rendered variant guidance, also folded into instructions */
       variantGuidance: import_zod2.z.string().optional(),
+      /**
+       * How the neutral types of the contracts this agent implements are spelled
+       * in its language: the write table (type_dialect.mappingLines) of the dialect
+       * for the language its implementations are written in, also folded into
+       * instructions. Absent when no dialect is shipped for that language or the
+       * agent implements nothing.
+       */
+      typeMapping: import_zod2.z.array(import_zod2.z.string()).optional(),
       /**
        * Set only on a brief for a member's agent (an id qualified `<alias>::`): the
        * member's directory relative to the root the brief was asked from. The
@@ -1658,14 +1666,16 @@ function locateScalar(tokens, path92) {
     const base = Math.min(...region.map((t) => t.col));
     const last = k === path92.length - 1;
     let at;
-    if (typeof segment === "string") {
+    const items = region.map((t, i) => ({ t, i })).filter(({ t }) => t.kind === "item" && t.col === base);
+    if (items.length === 0) {
       at = region.findIndex((t) => t.kind === "key" && t.col === base && t.name === segment);
       if (at < 0) return `no block key "${segment}" at ${path92.slice(0, k).join(".") || "the document root"}`;
       if (last) return region[at].valueStart !== void 0 ? region[at] : `"${segment}" holds no inline scalar`;
     } else {
-      const items = region.map((t, i) => ({ t, i })).filter(({ t }) => t.kind === "item" && t.col === base);
-      if (segment >= items.length) return `no block sequence item ${segment} at ${path92.slice(0, k).join(".")}`;
-      at = items[segment].i;
+      if (!/^\d+$/.test(segment)) return `"${segment}" is not a sequence index at ${path92.slice(0, k).join(".") || "the document root"}`;
+      const index = Number(segment);
+      if (index >= items.length) return `no block sequence item ${segment} at ${path92.slice(0, k).join(".")}`;
+      at = items[index].i;
       if (last) {
         const value = region[at + 1];
         return value && value.kind === "scalar" && value.line === region[at].line ? value : `item ${segment} holds no inline scalar`;
@@ -1994,7 +2004,7 @@ function registryOver(store, root) {
           const at = typeof entry.at === "string" ? entry.at : void 0;
           const covers = Array.isArray(entry.covers) ? entry.covers.filter((u) => typeof u === "string") : void 0;
           const next = rekeyAnchor(rename, { spec: entry.spec, at, covers });
-          const base = ["rules", "conformance", "carried", g, "findings", f];
+          const base = ["rules", "conformance", "carried", String(g), "findings", String(f)];
           const named2 = { code: String(entry.code), spec: entry.spec, at: at ?? "" };
           const change = (path92, field, from, to) => {
             if (from === to) return;
@@ -2003,7 +2013,7 @@ function registryOver(store, root) {
           };
           change(["spec"], "spec", entry.spec, next.spec);
           if (at !== void 0) change(["at"], "at", at, next.at);
-          (covers ?? []).forEach((unit, u) => change(["covers", u], "covers", unit, next.covers[u]));
+          (covers ?? []).forEach((unit, u) => change(["covers", String(u)], "covers", unit, next.covers[u]));
         });
       });
       store.rewriteScalars(edits, dryRun);
@@ -3304,7 +3314,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, 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 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, EnumValueSchema, TypeSpecSchema, ResolvedTypeSpecSchema, SurfaceOriginSchema, SurfaceTypeDefSchema, SurfaceTypeExportSchema, SurfaceContractEntrySchema, SurfaceSnapshotSchema, ExternalLockEntrySchema, ExternalsLockSchema, ParentExcerptSchema, NamedOpenApiSpecSchema, GroupSpecSchema;
 var init_specs = __esm({
   "src/models/specs.ts"() {
     "use strict";
@@ -3681,11 +3691,10 @@ var init_specs = __esm({
     MethodParamSchema = import_zod8.z.object({
       name: import_zod8.z.string(),
       /**
-       * A primitive/builtin or a defined type id (qualified across subsystems, e.g.
-       * "billing.Invoice"), on its own or inside a generic, an array or a UNION:
-       * `Invoice | null`, `Promise<Invoice | null>`, `Invoice[] | null`. Every
-       * identifier the string names has to resolve — see the grammar on
-       * src/models/type-references.ts.
+       * A type expression in the neutral type grammar (src/models/type-grammar.ts):
+       * a primitive, a named type (`billing.Invoice`, `alias::name`), `list<T>`,
+       * `set<T>`, `map<K, V>`, `T?`, a union of named types. Stored canonical; an
+       * alias (`Invoice[]`, `Invoice | null`, `boolean`) is normalised on write.
        */
       type: import_zod8.z.string(),
       description: import_zod8.z.string().optional(),
@@ -3704,8 +3713,9 @@ var init_specs = __esm({
       description: 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.
+      // A type expression in the neutral grammar, at the returns position — the only
+      // one `async T` and `void` may stand in: "async void", "Invoice?". Stored
+      // canonical; see src/models/type-grammar.ts.
       returns: import_zod8.z.string().optional(),
       /** Structured parameters (authoritative for type checking when present). */
       params: import_zod8.z.array(MethodParamSchema).optional(),
@@ -4069,12 +4079,12 @@ var init_specs = __esm({
       createdAt: import_zod8.z.string().datetime(),
       updatedAt: import_zod8.z.string().datetime()
     });
-    TypeKindSchema = import_zod8.z.enum(["entity", "value-object", "signature"]);
+    TypeKindSchema = import_zod8.z.enum(["entity", "value-object", "signature", "enum"]);
     TypeFieldSchema = import_zod8.z.object({
       name: import_zod8.z.string(),
-      // A primitive, or another type id (qualified across subsystems, e.g.
-      // "billing.Invoice") — on its own or inside a generic, an array or a union
-      // ("Invoice[] | null"). See the grammar on src/models/type-references.ts.
+      // A type expression in the neutral grammar (src/models/type-grammar.ts): a
+      // primitive, a named type ("billing.Invoice"), list/set/map, `T?`, a union
+      // of named types. Stored canonical.
       type: import_zod8.z.string(),
       description: import_zod8.z.string().optional(),
       optional: import_zod8.z.boolean().default(false),
@@ -4128,9 +4138,13 @@ var init_specs = __esm({
       /** The property that must hold, stated precisely enough to test against. */
       description: import_zod8.z.string().min(1)
     });
+    EnumValueSchema = import_zod8.z.object({
+      name: import_zod8.z.string().min(1),
+      description: import_zod8.z.string().optional()
+    });
     TypeSpecSchema = import_zod8.z.object({
       kind: TypeKindSchema,
-      // discriminator — entity | value-object | signature
+      // discriminator — entity | value-object | signature | enum
       id: SpecIdSchema,
       name: import_zod8.z.string(),
       description: import_zod8.z.string().optional(),
@@ -4193,6 +4207,20 @@ var init_specs = __esm({
       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(),
+      /**
+       * An enum's values, in declared order (the order is part of the design),
+       * unique by nameKey; required and non-empty on kind enum and only there
+       * (ENUM_MEMBERS).
+       */
+      values: import_zod8.z.array(EnumValueSchema).optional(),
+      /**
+       * A named scalar's one primitive (string, int, float, bool, bytes, date,
+       * datetime or duration), in place of fields: a value-object that is a
+       * newtype or type alias in every language. Read as a type position (the
+       * grammar's `holds` position); only on a value-object and never beside
+       * fields (NAMED_SCALAR_MEMBERS).
+       */
+      holds: import_zod8.z.string().optional(),
       createdAt: import_zod8.z.string().datetime(),
       updatedAt: import_zod8.z.string().datetime()
     });
@@ -4218,7 +4246,11 @@ var init_specs = __esm({
         optional: import_zod8.z.boolean().optional()
       })).optional(),
       /** A signature's one output type; only on kind signature. */
-      returns: import_zod8.z.string().optional()
+      returns: import_zod8.z.string().optional(),
+      /** An enum's values in declared order; only on kind enum. */
+      values: import_zod8.z.array(EnumValueSchema).optional(),
+      /** A named scalar's one primitive, in place of fields; only on a value-object that declares it. */
+      holds: import_zod8.z.string().optional()
     });
     SurfaceTypeExportSchema = import_zod8.z.object({
       /** The type's public name in the producer's export table. */
@@ -4323,9 +4355,773 @@ var init_specs = __esm({
   }
 });
 
+// src/models/type-grammar.ts
+function isTypeVocabulary(name) {
+  const lower = name.toLowerCase();
+  return LOWER_PRIMITIVE.has(lower) || LOWER_GENERIC.has(lower) || NOT_NEUTRAL.has(lower) || NONES.has(lower) || lower === "true" || lower === "false" || lower === "number";
+}
+function primitiveOf(name) {
+  if (PRIMITIVES.has(name)) return name;
+  const exact = PRIMITIVE_ALIASES.get(name);
+  if (exact) return exact;
+  return LOWER_PRIMITIVE.get(name.toLowerCase());
+}
+function genericOf(name) {
+  return GENERIC_ALIASES.get(name) ?? LOWER_GENERIC.get(name.toLowerCase());
+}
+function tokenize2(text3) {
+  const out = [];
+  let i = 0;
+  while (i < text3.length) {
+    const c = text3[i];
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(c)) {
+      let j = i + 1;
+      while (j < text3.length && /[A-Za-z0-9_$-]/.test(text3[j])) j++;
+      while (text3[j - 1] === "-") j--;
+      out.push({ t: "id", v: text3.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (/[0-9]/.test(c)) {
+      let j = i + 1;
+      while (j < text3.length && /[0-9.]/.test(text3[j])) j++;
+      out.push({ t: "num", v: text3.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (c === "'" || c === '"' || c === "`") {
+      let j = i + 1;
+      while (j < text3.length && text3[j] !== c) j += text3[j] === "\\" ? 2 : 1;
+      if (j >= text3.length) throw new TypeSyntaxError(`an unterminated string literal at "${text3.slice(i)}"`);
+      out.push({ t: "str", v: text3.slice(i, j + 1) });
+      i = j + 1;
+      continue;
+    }
+    const punct = PUNCTUATION.find((p) => text3.startsWith(p, i));
+    if (!punct) throw new TypeSyntaxError(`"${c}" is not part of any type spelling`);
+    out.push({ t: "p", v: punct });
+    i += punct.length;
+  }
+  return out;
+}
+function readRaw(text3) {
+  return new RawParser(tokenize2(text3)).position();
+}
+function primitive(name) {
+  return { form: "primitive", name, args: [] };
+}
+function optionalOf(inner2) {
+  if (inner2.form === "primitive" && inner2.name === "any") return inner2;
+  if (inner2.form === "optional") throw new TypeProblemError("TYPE_POSITION_INVALID", "a type is made optional twice (T??)", "T?");
+  if (inner2.form === "primitive" && inner2.name === "void") throw new TypeProblemError("TYPE_POSITION_INVALID", "void cannot be optional (void?)", "void");
+  return { form: "optional", args: [inner2] };
+}
+function inner(ctx) {
+  return { ...ctx, top: false, voidAllowed: false, omittable: false };
+}
+function normalise(node, ctx, notes) {
+  switch (node.k) {
+    case "paren":
+      return normalise(node.inner, ctx, notes);
+    case "async":
+      return asyncOf(node.inner, ctx, notes, "async");
+    case "array":
+      return { form: "list", args: [normalise(node.elem, inner(ctx), notes)] };
+    case "opt":
+      return optionalOf(normalise(node.inner, inner(ctx), notes));
+    case "union":
+      return unionOf(node.members, ctx, notes);
+    case "name":
+      return node.args === void 0 ? bareName(node.name, ctx, notes) : appliedName(node.name, node.args, ctx, notes);
+    case "literal":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", `${node.text} is a literal value, not a type \u2014 a literal union is not in the grammar`, "an enum type naming the values");
+    case "object":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "an inline object shape is not in the grammar", "a named value-object");
+    case "function":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "an inline function type is not in the grammar", "a signature type");
+    case "intersection":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "an intersection (A & B) is not in the grammar", "a named type");
+    case "tuple":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "a tuple is not in the grammar", "a named value-object");
+    case "operator":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", `"${node.op}" is TypeScript's type algebra, not in the grammar`, "a named type");
+  }
+}
+function asyncOf(innerNode, ctx, notes, spelled) {
+  if (!ctx.top || !RETURNS_POSITIONS.has(ctx.position)) {
+    throw new TypeProblemError("TYPE_POSITION_INVALID", `${spelled} may stand only at the top of a returns, not in a ${ctx.position}`);
+  }
+  const read2 = normalise(innerNode, { ...inner(ctx), voidAllowed: true }, notes);
+  return { form: "async", args: [read2] };
+}
+function bareName(name, ctx, notes) {
+  const lower = name.toLowerCase();
+  if (NONES.has(name)) {
+    throw new TypeProblemError("TYPE_EXPRESSION_INVALID", `"${name}" on its own names no type \u2014 "no value" joins a type as T?`, "T?, or void for a returns that answers nothing");
+  }
+  if (lower === "true" || lower === "false") {
+    throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", `${name} is a literal value, not a type`, "bool, or an enum type naming the values");
+  }
+  if (name === "number" || lower === "number") {
+    if (ctx.looseNumber) return primitive(LOOSE_NUMBER);
+    notes.notNeutral ??= { detail: '"number" does not say whether it holds an integer \u2014 int or float?', replacement: "int or float" };
+    return primitive("float");
+  }
+  const prim = primitiveOf(name);
+  if (prim !== void 0) {
+    if (prim === "void" && !ctx.voidAllowed) {
+      throw new TypeProblemError("TYPE_POSITION_INVALID", `void may stand only as a whole returns (or async void), not in a ${ctx.top ? ctx.position : "collection, union or argument"}`);
+    }
+    return primitive(prim);
+  }
+  if (genericOf(name) !== void 0) {
+    throw new TypeProblemError("TYPE_EXPRESSION_INVALID", `"${name}" needs its type arguments`, `${genericOf(name)?.form ?? "list"}<...>`);
+  }
+  const legacy = NOT_NEUTRAL.get(lower);
+  if (legacy !== void 0) {
+    notes.notNeutral ??= { detail: `"${name}" has no neutral meaning`, replacement: legacy };
+    return primitive("any");
+  }
+  return { form: "named", name, args: [] };
+}
+function appliedName(name, args, ctx, notes) {
+  const alias = genericOf(name);
+  if (alias !== void 0) {
+    if (args.length !== alias.arity) {
+      throw new TypeProblemError("TYPE_EXPRESSION_INVALID", `"${name}" takes ${alias.arity} type argument${alias.arity === 1 ? "" : "s"}, ${args.length} given`);
+    }
+    if (alias.form === "async") return asyncOf(args[0], ctx, notes, `${name}<...>`);
+    if (alias.form === "optional") return optionalOf(normalise(args[0], inner(ctx), notes));
+    const read2 = args.map((a) => normalise(a, inner(ctx), notes));
+    if (alias.form === "map") assertMapKey(read2[0], args[0]);
+    return { form: alias.form, args: read2 };
+  }
+  if (UTILITY_TYPES.has(name)) {
+    throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", `"${name}<...>" is a TypeScript utility type, not in the grammar`, "a named type");
+  }
+  if (primitiveOf(name) !== void 0 || NONES.has(name)) {
+    throw new TypeProblemError("TYPE_EXPRESSION_INVALID", `"${name}" takes no type arguments`);
+  }
+  const legacy = NOT_NEUTRAL.get(name.toLowerCase());
+  if (legacy !== void 0) {
+    args.forEach((a) => normalise(a, { ...inner(ctx), voidAllowed: true }, notes));
+    notes.notNeutral ??= { detail: `"${name}<...>" has no neutral meaning`, replacement: legacy };
+    return primitive("any");
+  }
+  return { form: "applied", name, args: args.map((a) => normalise(a, inner(ctx), notes)) };
+}
+function assertHoldable(expression) {
+  if (expression.form === "primitive" && HOLDABLE_PRIMITIVES.includes(expression.name ?? "")) return;
+  throw new TypeProblemError(
+    "TYPE_POSITION_INVALID",
+    `a named scalar holds one primitive (${HOLDABLE_PRIMITIVES.join(", ")}), not ${canonicalTypeText(expression)}`,
+    "one of those primitives, or fields for a value-object that holds more than one value"
+  );
+}
+function assertMapKey(key, written) {
+  if (key.form === "named") return;
+  if (key.form === "primitive" && (key.name === "string" || key.name === "int" || key.name === LOOSE_NUMBER)) return;
+  if (key.form === "primitive" && key.name === "float" && written.k === "name" && written.name.toLowerCase() === "number") return;
+  throw new TypeProblemError("TYPE_POSITION_INVALID", "a map key must be string, int or an enum", "map<string, V>");
+}
+function unionOf(members, ctx, notes) {
+  const nones = members.filter((m) => m.k === "name" && m.args === void 0 && NONES.has(m.name));
+  const rest = members.filter((m) => !(m.k === "name" && m.args === void 0 && NONES.has(m.name)));
+  if (rest.length === 0) throw new TypeProblemError("TYPE_EXPRESSION_INVALID", "a union of nones names no type");
+  if (rest.some((m) => m.k === "literal" || m.k === "name" && m.args === void 0 && /^(true|false)$/i.test(m.name))) {
+    throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "a union of literal values is not in the grammar", "an enum type naming the values");
+  }
+  const memberCtx = inner(ctx);
+  let hasNone = nones.length > 0;
+  const read2 = rest.map((m) => {
+    const e = normalise(m, memberCtx, notes);
+    if (e.form !== "optional") return e;
+    hasNone = true;
+    return e.args[0];
+  });
+  let base;
+  if (read2.length === 1) {
+    base = read2[0];
+  } else {
+    const loose = read2.find((e) => e.form !== "named" && e.form !== "applied");
+    if (loose) {
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "a union may hold only named types \u2014 this one mixes in a primitive or a collection", "a named type (an entity, value-object or enum), or two params");
+    }
+    base = { form: "union", args: read2 };
+  }
+  if (!hasNone) return base;
+  const onlyUndefined = nones.length > 0 && nones.every((n) => n.name === "undefined") && read2.length === rest.length && !rest.some((m) => m.k === "opt");
+  if (ctx.omittable && ctx.top && onlyUndefined) return base;
+  return optionalOf(base);
+}
+function canonicalTypeText(expr) {
+  switch (expr.form) {
+    case "primitive":
+    case "named":
+      return expr.name ?? "";
+    case "list":
+    case "set":
+      return `${expr.form}<${canonicalTypeText(expr.args[0])}>`;
+    case "map":
+      return `map<${canonicalTypeText(expr.args[0])}, ${canonicalTypeText(expr.args[1])}>`;
+    case "optional": {
+      const innerText = canonicalTypeText(expr.args[0]);
+      return expr.args[0].form === "union" ? `(${innerText})?` : `${innerText}?`;
+    }
+    case "union":
+      return expr.args.map(canonicalTypeText).join(" | ");
+    case "async":
+      return `async ${canonicalTypeText(expr.args[0])}`;
+    case "applied":
+      return `${expr.name}<${expr.args.map(canonicalTypeText).join(", ")}>`;
+  }
+}
+function typeNamedRefs(expr) {
+  if (expr.form === "named") return [expr.name];
+  const own = expr.form === "applied" ? [expr.name] : [];
+  return [...own, ...expr.args.flatMap(typeNamedRefs)];
+}
+function typeIsMany(expr) {
+  if (expr.form === "list" || expr.form === "set" || expr.form === "map") return true;
+  if (expr.form === "optional" || expr.form === "async") return typeIsMany(expr.args[0]);
+  return false;
+}
+function contextFor(position, omittable2, looseNumber = false) {
+  return { position, top: true, voidAllowed: RETURNS_POSITIONS.has(position), omittable: omittable2, looseNumber };
+}
+function parseTypePosition(text3, position, omittable2 = false) {
+  let raw;
+  try {
+    raw = readRaw(text3);
+  } catch (e) {
+    if (!(e instanceof TypeSyntaxError)) throw e;
+    return { expression: null, canonical: text3, problem: { code: "TYPE_EXPRESSION_INVALID", written: text3, detail: `"${text3}" does not parse as a type: ${e.message}` } };
+  }
+  const notes = {};
+  try {
+    const expression = normalise(raw, contextFor(position, omittable2), notes);
+    if (position === "holds") assertHoldable(expression);
+    const problem = notes.notNeutral ? { code: "TYPE_NOT_NEUTRAL", written: text3, detail: notes.notNeutral.detail, replacement: notes.notNeutral.replacement } : null;
+    return { expression, canonical: canonicalTypeText(expression), problem };
+  } catch (e) {
+    if (!(e instanceof TypeProblemError)) throw e;
+    return {
+      expression: null,
+      canonical: text3,
+      problem: { code: e.code, written: text3, detail: `"${text3}": ${e.detail}`, ...e.replacement ? { replacement: e.replacement } : {} }
+    };
+  }
+}
+function parseTypeExpression(text3, position) {
+  return parseTypePosition(text3, position);
+}
+function readCodeAnnotation(annotation, looseNumber) {
+  let raw;
+  try {
+    raw = readRaw(annotation);
+  } catch (e) {
+    if (e instanceof TypeSyntaxError) return null;
+    throw e;
+  }
+  try {
+    return normalise(raw, contextFor("returns", false, looseNumber), {});
+  } catch (e) {
+    if (e instanceof TypeProblemError) return null;
+    throw e;
+  }
+}
+function writtenTypeRefs(text3, position) {
+  const parse = parseTypePosition(text3, position);
+  if (parse.expression && !parse.problem) return typeNamedRefs(parse.expression);
+  try {
+    return rawRefs(readRaw(text3));
+  } catch (e) {
+    if (e instanceof TypeSyntaxError) return [];
+    throw e;
+  }
+}
+function rawRefs(node) {
+  switch (node.k) {
+    case "name": {
+      const own = isTypeVocabulary(node.name) || UTILITY_TYPES.has(node.name) ? [] : [node.name];
+      return [...own, ...(node.args ?? []).flatMap(rawRefs)];
+    }
+    case "array":
+      return rawRefs(node.elem);
+    case "opt":
+    case "paren":
+    case "async":
+    case "operator":
+      return rawRefs(node.inner);
+    case "union":
+    case "intersection":
+    case "object":
+      return node.members.flatMap(rawRefs);
+    case "tuple":
+      return node.elems.flatMap(rawRefs);
+    case "function":
+      return [...node.params.flatMap(rawRefs), ...rawRefs(node.ret)];
+    case "literal":
+      return [];
+  }
+}
+function interfaceCanonicalTypes(intf) {
+  const reader = new Canonicalizer(intf.id, "interface");
+  const methods = (intf.methods ?? []).map((m) => {
+    if (m.signatureFrom !== void 0) return m;
+    const out = { ...m };
+    if (m.params !== void 0) out.params = reader.params(m.params, "param", `methods.${m.name}.params`);
+    if (typeof m.returns === "string") out.returns = reader.read(m.returns, "returns", `methods.${m.name}.returns`);
+    return out;
+  });
+  return { spec: { ...intf, methods }, respellings: reader.respellings, problems: reader.problems };
+}
+function typeCanonicalTypes(type) {
+  const reader = new Canonicalizer(type.id, "type");
+  const out = { ...type };
+  if (Array.isArray(type.fields)) {
+    out.fields = type.fields.map((f) => ({ ...f, type: reader.read(f.type, "field", `fields.${f.name}`, !!f.optional) }));
+  }
+  if (Array.isArray(type.methods)) {
+    out.methods = type.methods.map((m) => {
+      const method2 = { ...m };
+      if (m.params !== void 0) method2.params = reader.params(m.params, "type-method-param", `methods.${m.name}.params`);
+      if (typeof m.returns === "string") method2.returns = reader.read(m.returns, "type-method-returns", `methods.${m.name}.returns`);
+      return method2;
+    });
+  }
+  if (type.params !== void 0) out.params = reader.params(type.params, "signature-param", "params");
+  if (typeof type.holds === "string") out.holds = reader.read(type.holds, "holds", "holds");
+  if (typeof type.returns === "string") out.returns = reader.read(type.returns, "signature-returns", "returns");
+  return { spec: out, respellings: reader.respellings, problems: reader.problems };
+}
+function namesAnInteger(name) {
+  const words2 = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_\-.]+/).filter(Boolean);
+  return words2.some((word) => INTEGER_WORDS.has(word));
+}
+function positionNameOf(path92) {
+  const segments = path92.split(".");
+  const last = segments[segments.length - 1];
+  return last === "returns" && segments.length >= 3 ? segments[segments.length - 2] : last;
+}
+function typeProblemIntProposal(problem) {
+  if (problem.code !== "TYPE_NOT_NEUTRAL" || problem.replacement !== "int or float") return null;
+  if (problem.specId === void 0 || problem.kind === void 0 || problem.path === void 0) return null;
+  if (!namesAnInteger(positionNameOf(problem.path))) return null;
+  const parse = parseTypePosition(problem.written.replace(NUMBER_NAME, "int"), "returns");
+  if (!parse.expression || parse.problem) return null;
+  return { specId: problem.specId, kind: problem.kind, path: problem.path, written: problem.written, stored: parse.canonical };
+}
+function emptyTypeSpellingFacts() {
+  return { respellings: [], problems: [] };
+}
+var PRIMITIVE_TYPES, PRIMITIVES, HOLDABLE_PRIMITIVES, PRIMITIVE_ALIASES, GENERIC_ALIASES, NOT_NEUTRAL, UTILITY_TYPES, NONES, LOWER_PRIMITIVE, LOWER_GENERIC, TypeSyntaxError, PUNCTUATION, RawParser, TypeProblemError, RETURNS_POSITIONS, LOOSE_NUMBER, Canonicalizer, INTEGER_WORDS, NUMBER_NAME;
+var init_type_grammar = __esm({
+  "src/models/type-grammar.ts"() {
+    "use strict";
+    PRIMITIVE_TYPES = ["string", "int", "float", "bool", "bytes", "date", "datetime", "duration", "void", "any"];
+    PRIMITIVES = new Set(PRIMITIVE_TYPES);
+    HOLDABLE_PRIMITIVES = PRIMITIVE_TYPES.filter((p) => p !== "void" && p !== "any");
+    PRIMITIVE_ALIASES = /* @__PURE__ */ new Map([
+      ["boolean", "bool"],
+      ["integer", "int"],
+      ["long", "int"],
+      ["i8", "int"],
+      ["i16", "int"],
+      ["i32", "int"],
+      ["i64", "int"],
+      ["i128", "int"],
+      ["isize", "int"],
+      ["u8", "int"],
+      ["u16", "int"],
+      ["u32", "int"],
+      ["u64", "int"],
+      ["u128", "int"],
+      ["usize", "int"],
+      ["double", "float"],
+      ["f32", "float"],
+      ["f64", "float"],
+      ["Buffer", "bytes"],
+      ["Uint8Array", "bytes"],
+      ["Date", "datetime"],
+      ["timestamp", "datetime"],
+      ["object", "any"],
+      ["unknown", "any"],
+      ["json", "any"],
+      ["Json", "any"],
+      ["str", "string"]
+    ]);
+    GENERIC_ALIASES = /* @__PURE__ */ new Map([
+      ["list", { form: "list", arity: 1 }],
+      ["Array", { form: "list", arity: 1 }],
+      ["ReadonlyArray", { form: "list", arity: 1 }],
+      ["List", { form: "list", arity: 1 }],
+      ["vec", { form: "list", arity: 1 }],
+      ["vector", { form: "list", arity: 1 }],
+      ["set", { form: "set", arity: 1 }],
+      ["Set", { form: "set", arity: 1 }],
+      ["ReadonlySet", { form: "set", arity: 1 }],
+      ["map", { form: "map", arity: 2 }],
+      ["Map", { form: "map", arity: 2 }],
+      ["Record", { form: "map", arity: 2 }],
+      ["ReadonlyMap", { form: "map", arity: 2 }],
+      ["dict", { form: "map", arity: 2 }],
+      ["dictionary", { form: "map", arity: 2 }],
+      ["HashMap", { form: "map", arity: 2 }],
+      ["Option", { form: "optional", arity: 1 }],
+      ["Optional", { form: "optional", arity: 1 }],
+      ["Promise", { form: "async", arity: 1 }]
+    ]);
+    NOT_NEUTRAL = /* @__PURE__ */ new Map([
+      ["uuid", "a named value-object holding a string (e.g. order_id)"],
+      ["decimal", "a named value-object (e.g. money), or float"],
+      ["char", "string"],
+      ["byte", "int, or bytes for binary data"],
+      ["time", "datetime for an instant, or duration for an elapsed time"],
+      ["tuple", "a named value-object"],
+      ["result", "the success type as the returns (failures as findings or throws), or a named value-object"],
+      ["error", "a named value-object"],
+      ["never", "void"],
+      ["box", "the inner type (ownership is an implementation detail)"],
+      ["arc", "the inner type (ownership is an implementation detail)"],
+      ["rc", "the inner type (ownership is an implementation detail)"],
+      ["ref", "the inner type (ownership is an implementation detail)"],
+      ["cell", "the inner type (ownership is an implementation detail)"],
+      ["refcell", "the inner type (ownership is an implementation detail)"],
+      ["mutex", "the inner type (synchronisation is an implementation detail)"],
+      ["rwlock", "the inner type (synchronisation is an implementation detail)"],
+      ["std", "a named type"],
+      ["mcpserver", "a named type"]
+    ]);
+    UTILITY_TYPES = /* @__PURE__ */ new Set([
+      "Partial",
+      "Required",
+      "Readonly",
+      "Pick",
+      "Omit",
+      "Exclude",
+      "Extract",
+      "NonNullable",
+      "ReturnType",
+      "Parameters",
+      "InstanceType",
+      "Awaited",
+      "ConstructorParameters",
+      "ThisType",
+      "Uppercase",
+      "Lowercase"
+    ]);
+    NONES = /* @__PURE__ */ new Set(["null", "undefined"]);
+    LOWER_PRIMITIVE = new Map([
+      ...PRIMITIVE_TYPES.map((p) => [p, p]),
+      ...[...PRIMITIVE_ALIASES].map(([k, v]) => [k.toLowerCase(), v])
+    ]);
+    LOWER_GENERIC = new Map([...GENERIC_ALIASES].map(([k, v]) => [k.toLowerCase(), v]));
+    TypeSyntaxError = class extends Error {
+    };
+    PUNCTUATION = ["...", "::", "=>", "<", ">", ",", "|", "?", "(", ")", "[", "]", "{", "}", ":", "&", ";", "."];
+    RawParser = class {
+      constructor(tokens) {
+        this.tokens = tokens;
+        this.at = 0;
+      }
+      /** type-position: an optional `async` prefix, one type, and nothing after it. */
+      position() {
+        if (this.tokens.length === 0) throw new TypeSyntaxError("the position is empty");
+        const node = this.isAsyncPrefix() ? (this.at++, { k: "async", inner: this.type() }) : this.type();
+        if (this.at < this.tokens.length) throw new TypeSyntaxError(`"${this.rest()}" is left over after the type`);
+        return node;
+      }
+      isAsyncPrefix() {
+        const first = this.tokens[0];
+        const next = this.tokens[1];
+        if (!first || first.t !== "id" || first.v !== "async" || !next) return false;
+        return next.t !== "p" || ["(", "{", "[", "::"].includes(next.v);
+      }
+      rest() {
+        return this.tokens.slice(this.at).map((t) => t.v).join(" ");
+      }
+      peek(offset = 0) {
+        return this.tokens[this.at + offset];
+      }
+      isP(v, offset = 0) {
+        const t = this.peek(offset);
+        return !!t && t.t === "p" && t.v === v;
+      }
+      expect(v) {
+        if (!this.isP(v)) {
+          const got = this.peek();
+          throw new TypeSyntaxError(got ? `expected "${v}" but found "${got.v}"` : `expected "${v}" but the text ended`);
+        }
+        this.at++;
+      }
+      type() {
+        if (this.isP("|")) this.at++;
+        const members = [this.intersection()];
+        while (this.isP("|")) {
+          this.at++;
+          members.push(this.intersection());
+        }
+        return members.length === 1 ? members[0] : { k: "union", members };
+      }
+      intersection() {
+        const members = [this.postfix()];
+        while (this.isP("&")) {
+          this.at++;
+          members.push(this.postfix());
+        }
+        return members.length === 1 ? members[0] : { k: "intersection", members };
+      }
+      postfix() {
+        let node = this.primary();
+        for (; ; ) {
+          if (this.isP("[") && this.isP("]", 1)) {
+            this.at += 2;
+            node = { k: "array", elem: node };
+          } else if (this.isP("?")) {
+            this.at++;
+            node = { k: "opt", inner: node };
+          } else {
+            return node;
+          }
+        }
+      }
+      primary() {
+        const tok = this.peek();
+        if (!tok) throw new TypeSyntaxError("a type was expected but the text ended");
+        if (tok.t === "str" || tok.t === "num") {
+          this.at++;
+          return { k: "literal", text: tok.v };
+        }
+        if (tok.t === "id" && (tok.v === "keyof" || tok.v === "typeof" || tok.v === "unique") && this.peek(1)?.t === "id") {
+          this.at++;
+          return { k: "operator", op: tok.v, inner: this.postfix() };
+        }
+        const next = this.peek(1);
+        if (tok.t === "id" && tok.v === "readonly" && next && (next.t === "id" || next.t === "p" && (next.v === "(" || next.v === "["))) {
+          this.at++;
+          return this.postfix();
+        }
+        if (tok.t === "id" || tok.t === "p" && tok.v === "::") return this.named();
+        if (tok.t === "p" && tok.v === "(") return this.parenOrFunction();
+        if (tok.t === "p" && tok.v === "{") return this.objectShape();
+        if (tok.t === "p" && tok.v === "[") return this.tuple();
+        throw new TypeSyntaxError(`"${tok.v}" cannot start a type`);
+      }
+      ident() {
+        const tok = this.peek();
+        if (!tok || tok.t !== "id") throw new TypeSyntaxError(tok ? `expected a name but found "${tok.v}"` : "expected a name but the text ended");
+        this.at++;
+        return tok.v;
+      }
+      named() {
+        let name = "";
+        if (this.isP("::")) {
+          this.at++;
+          name = "::";
+        }
+        name += this.ident();
+        while (this.isP("::") || this.isP(".")) {
+          const sep18 = this.peek().v;
+          this.at++;
+          name += sep18 + this.ident();
+        }
+        if (!this.isP("<")) return { k: "name", name };
+        this.at++;
+        const args = [this.type()];
+        while (this.isP(",")) {
+          this.at++;
+          args.push(this.type());
+        }
+        this.expect(">");
+        return { k: "name", name, args };
+      }
+      /** The index of the `)` closing the `(` at the cursor, or -1. */
+      closingParen() {
+        let depth = 0;
+        for (let i = this.at; i < this.tokens.length; i++) {
+          const t = this.tokens[i];
+          if (t.t !== "p") continue;
+          if (t.v === "(") depth++;
+          else if (t.v === ")" && --depth === 0) return i;
+        }
+        return -1;
+      }
+      parenOrFunction() {
+        const close2 = this.closingParen();
+        const after = close2 === -1 ? void 0 : this.tokens[close2 + 1];
+        if (!after || after.t !== "p" || after.v !== "=>") {
+          this.expect("(");
+          const inner2 = this.type();
+          this.expect(")");
+          return { k: "paren", inner: inner2 };
+        }
+        this.expect("(");
+        const params = [];
+        while (!this.isP(")")) {
+          if (this.isP("...")) this.at++;
+          this.ident();
+          if (this.isP("?")) this.at++;
+          if (this.isP(":")) {
+            this.at++;
+            params.push(this.type());
+          }
+          if (!this.isP(",")) break;
+          this.at++;
+        }
+        this.expect(")");
+        this.expect("=>");
+        return { k: "function", params, ret: this.type() };
+      }
+      objectShape() {
+        this.expect("{");
+        const members = [];
+        while (!this.isP("}")) {
+          if (this.isP("[")) {
+            this.at++;
+            this.ident();
+            this.expect(":");
+            members.push(this.type());
+            this.expect("]");
+          } else {
+            if (this.peek()?.t === "id" && this.peek().v === "readonly" && this.peek(1)?.t === "id") this.at++;
+            const key = this.peek();
+            if (!key || key.t !== "id" && key.t !== "str" && key.t !== "num") throw new TypeSyntaxError("an inline object member has no name");
+            this.at++;
+            if (this.isP("?")) this.at++;
+            if (this.isP("(")) {
+              members.push(this.parenOrFunctionMember());
+              this.skipSeparator();
+              continue;
+            }
+          }
+          this.expect(":");
+          members.push(this.type());
+          this.skipSeparator();
+        }
+        this.expect("}");
+        return { k: "object", members };
+      }
+      /** A method member of an inline object: (params): returns. */
+      parenOrFunctionMember() {
+        this.expect("(");
+        const params = [];
+        while (!this.isP(")")) {
+          if (this.isP("...")) this.at++;
+          this.ident();
+          if (this.isP("?")) this.at++;
+          if (this.isP(":")) {
+            this.at++;
+            params.push(this.type());
+          }
+          if (!this.isP(",")) break;
+          this.at++;
+        }
+        this.expect(")");
+        this.expect(":");
+        return { k: "function", params, ret: this.type() };
+      }
+      skipSeparator() {
+        if (this.isP(";") || this.isP(",")) this.at++;
+      }
+      tuple() {
+        this.expect("[");
+        const elems = [];
+        while (!this.isP("]")) {
+          elems.push(this.type());
+          if (!this.isP(",")) break;
+          this.at++;
+        }
+        this.expect("]");
+        return { k: "tuple", elems };
+      }
+    };
+    TypeProblemError = class extends Error {
+      constructor(code, detail, replacement) {
+        super(detail);
+        this.code = code;
+        this.detail = detail;
+        this.replacement = replacement;
+      }
+    };
+    RETURNS_POSITIONS = /* @__PURE__ */ new Set(["returns", "type-method-returns", "signature-returns"]);
+    LOOSE_NUMBER = "number";
+    Canonicalizer = class {
+      constructor(specId, kind) {
+        this.specId = specId;
+        this.kind = kind;
+        this.respellings = [];
+        this.problems = [];
+      }
+      /** One position: its canonical text when it has one, else the text as written, recorded either way. */
+      read(text3, position, path92, omittable2 = false) {
+        const parse = parseTypePosition(text3, position, omittable2);
+        if (parse.problem) {
+          this.problems.push({ ...parse.problem, specId: this.specId, kind: this.kind, path: path92 });
+          return text3;
+        }
+        if (parse.canonical !== text3) this.respellings.push({ specId: this.specId, kind: this.kind, path: path92, written: text3, stored: parse.canonical });
+        return parse.canonical;
+      }
+      params(params, position, prefix) {
+        return params.map((p) => ({ ...p, type: this.read(p.type, position, `${prefix}.${p.name}`, !!p.optional) }));
+      }
+    };
+    INTEGER_WORDS = /* @__PURE__ */ new Set([
+      "count",
+      "counts",
+      "size",
+      "sizes",
+      "length",
+      "len",
+      "limit",
+      "limits",
+      "port",
+      "step",
+      "steps",
+      "index",
+      "idx",
+      "depth",
+      "level",
+      "levels",
+      "days",
+      "day",
+      "hours",
+      "minutes",
+      "seconds",
+      "ms",
+      "millis",
+      "milliseconds",
+      "bytes",
+      "version",
+      "total",
+      "offset",
+      "page",
+      "pages",
+      "retries",
+      "attempts",
+      "number",
+      "num",
+      "line",
+      "lines",
+      "column",
+      "columns",
+      "max",
+      "min",
+      "width",
+      "height"
+    ]);
+    NUMBER_NAME = /(?<![\w:.-])number(?![\w:.-])/g;
+  }
+});
+
 // src/models/type-references.ts
 function extractTypeIdentifiers(typeStr) {
-  let cleaned = typeStr.replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  let cleaned = typeStr.replace(/^\s*async\s+(?=\S)/, "").replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   cleaned = cleaned.replace(/(?<=\S)\s*\([^)]*\)\s*$/, "");
   cleaned = cleaned.replace(/(?<=\S)\s+[-—:]\s+[a-z\s_-]+$/, "");
   cleaned = cleaned.replace(/(["'`])(?:\\.|[^\\])*?\1/g, " ");
@@ -4411,16 +5207,19 @@ function methodTypeRefs(m) {
   if (m.params && m.params.length > 0) {
     const refs = [];
     for (const p of m.params) {
-      refs.push(...extractTypeIdentifiers(p.type));
+      refs.push(...writtenTypeRefs(p.type, "param"));
     }
-    refs.push(...extractTypeIdentifiers(m.returns ?? ""));
+    if (m.returns !== void 0) refs.push(...writtenTypeRefs(m.returns, "returns"));
     return Array.from(new Set(refs));
   }
   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 ?? "")];
+  const refs = [
+    ...(type.params ?? []).flatMap((p) => writtenTypeRefs(p.type, "signature-param")),
+    ...type.returns !== void 0 ? writtenTypeRefs(type.returns, "signature-returns") : []
+  ];
   return Array.from(new Set(refs));
 }
 function methodGenericParameters(method2) {
@@ -4455,85 +5254,117 @@ function typeGenericParameters(type) {
 }
 function fieldTypeRefs(type, fieldType) {
   const generics = new Set(Array.from(typeGenericParameters(type)).map((g) => g.toLowerCase()));
-  return extractTypeIdentifiers(fieldType).filter((ref) => !generics.has(ref.toLowerCase()));
+  return writtenTypeRefs(fieldType, "field").filter((ref) => !generics.has(ref.toLowerCase()));
 }
 function interfaceGenericParameters(intf) {
   return extractTypeGenerics(intf.name);
 }
-var BUILTIN_TYPES;
 var init_type_references = __esm({
   "src/models/type-references.ts"() {
     "use strict";
-    BUILTIN_TYPES = /* @__PURE__ */ new Set([
-      "string",
-      "str",
-      "number",
-      "boolean",
-      "bool",
-      "float",
-      "double",
-      "int",
-      "integer",
-      "u8",
-      "u16",
-      "u32",
-      "u64",
-      "u128",
-      "usize",
-      "i8",
-      "i16",
-      "i32",
-      "i64",
-      "i128",
-      "isize",
-      "f32",
-      "f64",
-      "char",
-      "byte",
-      "bytes",
-      "any",
-      "void",
-      "null",
-      "undefined",
-      "object",
-      "date",
-      "datetime",
-      "time",
-      "timestamp",
-      "duration",
-      "uuid",
-      "decimal",
-      "json",
-      "true",
-      "false",
-      "list",
-      "vector",
-      "vec",
-      "array",
-      "map",
-      "set",
-      "dict",
-      "dictionary",
-      "hashmap",
-      "tuple",
-      "result",
-      "option",
-      "box",
-      "arc",
-      "rc",
-      "ref",
-      "cell",
-      "refcell",
-      "mutex",
-      "rwlock",
-      "std",
-      "promise",
-      "record",
-      "json",
-      "unknown",
-      "never",
-      "error",
-      "mcpserver"
+    init_type_grammar();
+  }
+});
+
+// src/models/type-dialects.ts
+function lastSegment(name) {
+  return name.split(/::|\./).filter(Boolean).pop() ?? name;
+}
+function sameType(code, spec, codeNames) {
+  if (code.form === "primitive" && code.name === "number") return spec.form === "primitive" && (spec.name === "int" || spec.name === "float");
+  if (code.form === "named" && (spec.form === "named" || spec.form === "applied")) {
+    if (spec.form === "applied") return false;
+    return namesAgree(code.name, spec.name, codeNames);
+  }
+  if (code.form !== spec.form) return false;
+  if (code.form === "primitive") return code.name === spec.name;
+  if (code.form === "applied" && !namesAgree(code.name, spec.name, codeNames)) return false;
+  if (code.args.length !== spec.args.length) return false;
+  return code.args.every((arg, i) => sameType(arg, spec.args[i], codeNames));
+}
+function namesAgree(codeName, specName, codeNames) {
+  if (codeName === specName) return true;
+  const mapped = codeNames.get(specName) ?? codeNames.get(lastSegment(specName));
+  return mapped === codeName || mapped === lastSegment(codeName);
+}
+function writeTypeScript(expr) {
+  switch (expr.form) {
+    case "primitive":
+      return TS_PRIMITIVES[expr.name ?? ""] ?? expr.name ?? "unknown";
+    case "named":
+      return expr.name ?? "unknown";
+    case "list": {
+      const elem = writeTypeScript(expr.args[0]);
+      return /[|\s]/.test(elem) ? `(${elem})[]` : `${elem}[]`;
+    }
+    case "set":
+      return `Set<${writeTypeScript(expr.args[0])}>`;
+    case "map":
+      return `Record<${writeTypeScript(expr.args[0])}, ${writeTypeScript(expr.args[1])}>`;
+    case "optional":
+      return `${writeTypeScript(expr.args[0])} | null`;
+    case "union":
+      return expr.args.map(writeTypeScript).join(" | ");
+    case "async":
+      return `Promise<${writeTypeScript(expr.args[0])}>`;
+    case "applied":
+      return `${expr.name}<${expr.args.map(writeTypeScript).join(", ")}>`;
+  }
+}
+function typeDialectFor(language) {
+  return DIALECTS.get(language.toLowerCase()) ?? null;
+}
+var TS_PRIMITIVES, typescriptDialect, DIALECTS;
+var init_type_dialects = __esm({
+  "src/models/type-dialects.ts"() {
+    "use strict";
+    init_type_grammar();
+    TS_PRIMITIVES = {
+      string: "string",
+      int: "number",
+      float: "number",
+      bool: "boolean",
+      bytes: "Uint8Array",
+      date: "string",
+      datetime: "string",
+      duration: "string",
+      void: "void",
+      any: "unknown"
+    };
+    typescriptDialect = {
+      language: "typescript",
+      read(annotation) {
+        return readCodeAnnotation(annotation, false);
+      },
+      agrees(annotation, expression, codeNames) {
+        const code = readCodeAnnotation(annotation, true);
+        return code !== null && sameType(code, expression, codeNames);
+      },
+      write(expression) {
+        return writeTypeScript(expression);
+      },
+      mappingLines() {
+        return [
+          "string \u2192 string",
+          "int, float \u2192 number",
+          "bool \u2192 boolean",
+          "bytes \u2192 Uint8Array",
+          "date, datetime, duration \u2192 string (ISO 8601)",
+          "any \u2192 unknown",
+          "list<T> \u2192 T[]",
+          "set<T> \u2192 Set<T>",
+          "map<K, V> \u2192 Record<K, V>",
+          "T? \u2192 T | null",
+          "A | B \u2192 A | B",
+          "async T \u2192 Promise<T>",
+          "an enum E \u2192 type E = 'a' | 'b' (a string-literal union alias)",
+          "a named scalar E holding P \u2192 type E = P (an alias of the primitive)"
+        ];
+      }
+    };
+    DIALECTS = /* @__PURE__ */ new Map([
+      ["typescript", typescriptDialect],
+      ["javascript", typescriptDialect]
     ]);
   }
 });
@@ -4834,6 +5665,12 @@ function callSitesOf(facts, fn) {
 function hasFunctionBody(facts, symbol) {
   return callSitesOf(facts, symbol) !== void 0;
 }
+function languageOfSourcePath(sourcePath) {
+  return EXTENSION_LANGUAGE[path12.extname(sourcePath).toLowerCase()];
+}
+function dialectOf(facts) {
+  return facts.language ? typeDialectFor(facts.language) : null;
+}
 function resolveImport(fromFile, specifier, knownPaths) {
   if (!specifier.startsWith(".")) return void 0;
   const joined = pathKey(path12.posix.normalize(path12.posix.join(path12.posix.dirname(fromFile), specifier)));
@@ -4852,12 +5689,37 @@ function resolveImport(fromFile, specifier, knownPaths) {
   }
   return void 0;
 }
-var path12, NO_DECLARED_TYPES;
+var path12, NO_DECLARED_TYPES, EXTENSION_LANGUAGE;
 var init_code_model = __esm({
   "src/models/code-model.ts"() {
     "use strict";
     path12 = __toESM(require("path"));
+    init_type_dialects();
     NO_DECLARED_TYPES = [];
+    EXTENSION_LANGUAGE = {
+      ".ts": "typescript",
+      ".tsx": "typescript",
+      ".mts": "typescript",
+      ".cts": "typescript",
+      ".js": "javascript",
+      ".jsx": "javascript",
+      ".mjs": "javascript",
+      ".cjs": "javascript",
+      ".py": "python",
+      ".rs": "rust",
+      ".go": "go",
+      ".cs": "csharp",
+      ".java": "java",
+      ".c": "c",
+      ".h": "c",
+      ".cpp": "cpp",
+      ".cc": "cpp",
+      ".hpp": "cpp",
+      ".rb": "ruby",
+      ".php": "php",
+      ".kt": "kotlin",
+      ".swift": "swift"
+    };
   }
 });
 
@@ -4885,11 +5747,18 @@ function closureTypeOf(snapshot, identifier) {
   if (matches.length === 1) return matches[0];
   return matches.find((def) => nameKey(def.id) === nameKey(ref));
 }
+function renamedRefs(expr, rename) {
+  const args = expr.args.map((a) => renamedRefs(a, rename));
+  return expr.form === "named" || expr.form === "applied" ? { ...expr, name: rename(expr.name), args } : { ...expr, args };
+}
 function canonicalTypeRef(snapshot, typeExpr) {
+  const rename = (identifier) => closureTypeOf(snapshot, identifier)?.id ?? identifier;
+  const parse = parseTypeExpression(typeExpr, "returns");
+  if (parse.expression) return canonicalTypeText(renamedRefs(parse.expression, rename));
   return typeExpr.replace(TYPE_IDENTIFIER, (identifier) => {
     if (!/[A-Za-z]/.test(identifier)) return identifier;
-    if (BUILTIN_TYPES.has(identifier.toLowerCase())) return identifier.toLowerCase();
-    return closureTypeOf(snapshot, identifier)?.id ?? identifier;
+    if (isTypeVocabulary(identifier)) return identifier.toLowerCase();
+    return rename(identifier);
   });
 }
 function typeShape(snapshot, def) {
@@ -4901,7 +5770,9 @@ function typeShape(snapshot, def) {
     ...def.kind === "signature" ? {
       params: (def.params ?? []).map((p) => ({ type: canonicalTypeRef(snapshot, p.type), optional: p.optional === true })),
       returns: canonicalTypeRef(snapshot, def.returns ?? "unknown")
-    } : {}
+    } : {},
+    ...def.kind === "enum" ? { values: (def.values ?? []).map((v) => v.name) } : {},
+    ...def.holds !== void 0 ? { holds: canonicalTypeRef(snapshot, def.holds) } : {}
   };
 }
 function typeDefExprs(def) {
@@ -4978,6 +5849,7 @@ var init_surface_references = __esm({
     "use strict";
     import_crypto = require("crypto");
     init_type_references();
+    init_type_grammar();
     init_canonical_json();
     TYPE_IDENTIFIER = /(?:::)?[A-Za-z0-9_][A-Za-z0-9_-]*(?:(?:::|\.)[A-Za-z0-9_][A-Za-z0-9_-]*)*/g;
   }
@@ -5191,7 +6063,7 @@ var init_project_family = __esm({
 // src/models/validation-options.ts
 function selectsFamily(options, declaresMembers) {
   if (options?.family) return true;
-  return declaresMembers && options?.recursive !== false;
+  return declaresMembers && options?.memberDepth !== 0;
 }
 var init_validation_options = __esm({
   "src/models/validation-options.ts"() {
@@ -5210,6 +6082,8 @@ var init_models = __esm({
     init_template();
     init_specs();
     init_type_references();
+    init_type_grammar();
+    init_type_dialects();
     init_step_graph();
     init_step_config();
     init_code_model();
@@ -5959,17 +6833,23 @@ function buildCanvasModel(issues = [], relations) {
     })),
     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) } : {},
+    ...t.kind === "enum" ? { values: (t.values ?? []).map((v) => ({ name: v.name, ...v.description ? { description: v.description } : {} })) } : {},
+    ...t.holds !== void 0 ? { holds: t.holds } : {},
     usedBy: usedByFor(t),
     ...t.componentClass ? { componentClass: t.componentClass } : {},
     ...t.database ? { database: t.database } : {},
     ...t.table ? { table: t.table } : {},
     ...t.linkedEntity ? { linkedEntity: t.linkedEntity } : {}
   }));
-  const MANY_SHAPE = /\[\s*\]|Array<|Vec<|Set<|List<|Map<|Record<|HashMap</i;
+  const multiplicity = (field) => {
+    const expression = parseTypeExpression(field.type, "field").expression;
+    if (expression && typeIsMany(expression)) return "*";
+    return field.optional || expression?.form === "optional" ? "0..1" : "1";
+  };
   const typeEdges = [];
   for (const t of typeSpecs) {
     for (const field of t.fields) {
-      const refs = new Set(extractTypeIdentifiers(field.type));
+      const refs = new Set(writtenTypeRefs(field.type, "field"));
       if (field.references) {
         const refStr = field.references;
         refs.add(refStr);
@@ -5984,8 +6864,8 @@ function buildCanvasModel(issues = [], relations) {
           const qualified = other.subsystem && !other.id.startsWith(`${other.subsystem}::`) ? `${other.subsystem}::${other.id}` : other.id;
           return matchTypeRef(ref, qualified);
         });
-        if (target && target.id !== t.id) {
-          const card = MANY_SHAPE.test(field.type) ? "*" : field.optional ? "0..1" : "1";
+        if (target && target.id !== t.id && target.kind !== "enum" && target.holds === void 0) {
+          const card = multiplicity(field);
           if (!typeEdges.some((e) => e.from === t.id && e.to === target.id && e.field === field.name)) {
             typeEdges.push({ from: t.id, to: target.id, field: field.name, card });
           }
@@ -7659,7 +8539,7 @@ var MODEL = __MODEL_JSON__;
       return '';
     }
     function visibleFields(t) {
-      if (det === 'names') return [];
+      if (det === 'names' || t.values || t.holds) return [];
       if (det === 'keys') return t.fields.filter(function (f) { return markerOf(t, f) !== ''; });
       return t.fields;
     }
@@ -7704,15 +8584,19 @@ var MODEL = __MODEL_JSON__;
       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 = (sig ? [sig] : []).concat(fields.map(function (f) { return rowText(t, f); }))
+      // An enum is drawn with its values in place of a field list.
+      var vals = t.values && det !== 'names' ? t.values : [];
+      // A named scalar is drawn compactly: its name and the primitive it holds.
+      var head = t.name + (t.holds ? ' = ' + t.holds : '') + '  \\u00AB' + t.kind + '\\u00BB';
+      var rows = (sig ? [sig] : []).concat(vals.map(function (v) { return '\\u2022 ' + v.name; }))
+        .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, 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 };
+      return { fields: fields, meths: meths, sig: sig, vals: vals, head: head, plain: plain, w: plain ? pw : W, h: plain ? 40 : TH_H + (sig ? ROW_H : 0) + vals.length * ROW_H + fields.length * ROW_H + meths.length * ROW_H };
     }
 
     // Emit one type table with its top-left at (ax, ay); returns its size.
@@ -7743,6 +8627,13 @@ var MODEL = __MODEL_JSON__;
         });
         ry += ROW_H;
       }
+      sh.vals.forEach(function (v, vi) {
+        eles.push({
+          data: { id: 'TV~' + t.id + '~' + vi, parent: 'T~' + t.id, label: '\\u2022 ' + v.name, w: sh.w, h: ROW_H, tw: sh.w - 14 },
+          position: { x: ax + sh.w / 2, y: ry + ROW_H / 2 }, classes: 'typeRow' + (dim ? ' dimmed' : ''), grabbable: false,
+        });
+        ry += ROW_H;
+      });
       sh.fields.forEach(function (f) {
         var rid = 'TF~' + t.id + '~' + f.name;
         rowIds[rid] = 1;
@@ -10276,6 +11167,17 @@ var MODEL = __MODEL_JSON__;
           : '<span class="desc">no fields</span>';
         if (ty.signature) {
           body += section('Signature', 1, '<div class="method"><code>' + esc(ty.signature) + '</code></div>', true);
+        } else if (ty.holds) {
+          body += section('Holds', 1, '<div class="method"><code>' + esc(ty.holds) + '</code>'
+            + '<div class="mdesc">A named scalar: one ' + esc(ty.holds) + ' under this name.</div></div>', true);
+        } else if (ty.values) {
+          body += section('Values', ty.values.length, ty.values.length
+            ? ty.values.map(function (v) {
+                return '<div class="method"><div class="mname">' + esc(v.name) + '</div>'
+                  + (v.description ? '<div class="mdesc">' + esc(v.description) + '</div>' : '')
+                  + '</div>';
+              }).join('')
+            : '<span class="desc">no values</span>', true);
         } else {
           body += section('Fields', ty.fields.length, fieldsInner, true);
         }
@@ -10602,21 +11504,66 @@ var init_externals = __esm({
 });
 
 // src/core/openapi.ts
-function schemaFor(typeRef, closureIds) {
-  const trimmed = typeRef.trim().replace(/^promise\s*<(.+)>$/i, "$1").trim();
-  const arrayMatch = /^(.+)\[\]$/.exec(trimmed);
-  if (arrayMatch) {
-    return { type: "array", items: schemaFor(arrayMatch[1], closureIds) };
+function expressionOf(typeRef) {
+  return parseTypeExpression(typeRef.trim(), "returns").expression;
+}
+function closureHit(name, closureIds) {
+  const local = name.split(/::|\./).pop().toLowerCase().replace(/[^a-z0-9_-]/g, "");
+  return [...closureIds].find((id) => id.toLowerCase() === local);
+}
+function schemaOfExpression(expr, closureIds) {
+  switch (expr.form) {
+    case "primitive":
+      return { ...PRIMITIVE_SCHEMAS[expr.name ?? ""] ?? {} };
+    case "named":
+    case "applied": {
+      const hit = closureHit(expr.name ?? "", closureIds);
+      return hit ? { $ref: `#/components/schemas/${hit}` } : { description: `Unresolved type: ${expr.name}` };
+    }
+    case "list":
+      return { type: "array", items: schemaOfExpression(expr.args[0], closureIds) };
+    case "set":
+      return { type: "array", uniqueItems: true, items: schemaOfExpression(expr.args[0], closureIds) };
+    case "map": {
+      const key = expr.args[0];
+      const keyHit = key.form === "named" ? closureHit(key.name ?? "", closureIds) : void 0;
+      const propertyNames = keyHit ? { propertyNames: { $ref: `#/components/schemas/${keyHit}` } } : key.form === "primitive" && key.name === "int" ? { propertyNames: { pattern: "^-?[0-9]+$" } } : {};
+      return { type: "object", ...propertyNames, additionalProperties: schemaOfExpression(expr.args[1], closureIds) };
+    }
+    case "optional": {
+      const inner2 = schemaOfExpression(expr.args[0], closureIds);
+      if (Object.keys(inner2).length === 0) return inner2;
+      if (typeof inner2.type === "string") return { ...inner2, type: [inner2.type, "null"] };
+      return { anyOf: [inner2, { type: "null" }] };
+    }
+    case "union":
+      return { oneOf: expr.args.map((member) => schemaOfExpression(member, closureIds)) };
+    case "async":
+      return schemaOfExpression(expr.args[0], closureIds);
   }
-  const lower = trimmed.toLowerCase();
-  if (lower in PRIMITIVES) {
-    const p = PRIMITIVES[lower];
-    return p.type ? { ...p } : {};
+}
+function schemaFor(typeRef, closureIds) {
+  const expr = expressionOf(typeRef);
+  if (!expr) return { description: `Not a canonical type expression: ${typeRef.trim()}` };
+  return schemaOfExpression(expr, closureIds);
+}
+function returnsNothing(returns) {
+  const expr = expressionOf(returns);
+  const inner2 = expr?.form === "async" ? expr.args[0] : expr;
+  return inner2?.form === "primitive" && inner2.name === "void";
+}
+function enumDescription(values) {
+  return ["Values:", ...values.map((v) => `- \`${v.name}\`${v.description ? `: ${v.description}` : ""}`)].join("\n");
+}
+function enumValuesFrom(schema) {
+  const described = /* @__PURE__ */ new Map();
+  if (typeof schema.description === "string") {
+    for (const line2 of schema.description.split("\n")) {
+      const m = /^- `([^`]+)`: (.+)$/.exec(line2.trim());
+      if (m) described.set(m[1], m[2]);
+    }
   }
-  const local = trimmed.split(/::|\./).pop().toLowerCase().replace(/[^a-z0-9_-]/g, "");
-  const hit = [...closureIds].find((id) => id.toLowerCase() === local);
-  if (hit) return { $ref: `#/components/schemas/${hit}` };
-  return { type: "object", description: `Unresolved type: ${trimmed}` };
+  return schema.enum.filter((v) => typeof v === "string" && v.length > 0).map((name) => ({ name, ...described.has(name) ? { description: described.get(name) } : {} }));
 }
 function operationFor(method2, closureIds) {
   const endpoint = method2.endpoint;
@@ -10629,7 +11576,7 @@ function operationFor(method2, closureIds) {
     responses: {
       "200": {
         description: method2.returns || "Success",
-        ...method2.returns && method2.returns.toLowerCase() !== "void" ? { content: { "application/json": { schema: schemaFor(method2.returns, closureIds) } } } : {}
+        ...method2.returns && !returnsNothing(method2.returns) ? { content: { "application/json": { schema: schemaFor(method2.returns, closureIds) } } } : {}
       }
     }
   };
@@ -10664,7 +11611,7 @@ function operationFor(method2, closureIds) {
 }
 function signatureComponent(t, closureIds) {
   const params = t.params ?? [];
-  const returns = t.returns ?? "unknown";
+  const returns = t.returns ?? "any";
   const text3 = `(${params.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ")}): ${returns}`;
   return {
     title: t.name,
@@ -10689,9 +11636,7 @@ function signatureFromComponent(id, schema) {
   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);
+    return typeRefFromSchema(entry.schema);
   };
   const params = (Array.isArray(ext.params) ? ext.params : []).filter((p) => !!p && typeof p === "object" && typeof p.name === "string").map((p) => ({
     name: p.name,
@@ -10699,7 +11644,7 @@ function signatureFromComponent(id, schema) {
     ...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";
+  const returns = ext.returns && typeof ext.returns === "object" && !Array.isArray(ext.returns) ? typeOf(ext.returns) : "any";
   return { id, name: typeof schema.title === "string" ? schema.title : id, kind: "signature", fields: [], params, returns };
 }
 function securitySchemeObject(auth) {
@@ -10773,6 +11718,15 @@ function renderDoc(snapshot, entries, closureIds, opts = {}) {
   }
   const schemas = {};
   for (const t of snapshot.types) {
+    if (t.kind === "enum") {
+      const values = t.values ?? [];
+      schemas[t.id] = { type: "string", title: t.name, enum: values.map((v) => v.name), description: enumDescription(values) };
+      continue;
+    }
+    if (t.holds !== void 0) {
+      schemas[t.id] = { ...schemaFor(t.holds, closureIds), title: t.name };
+      continue;
+    }
     schemas[t.id] = t.kind === "signature" ? signatureComponent(t, closureIds) : {
       type: "object",
       title: t.name,
@@ -10824,17 +11778,73 @@ function isOpenApiDocument(body) {
     return false;
   }
 }
+function isNullSchema(schema) {
+  return !!schema && typeof schema === "object" && schema.type === "null";
+}
+function isTopLevelUnion(text3) {
+  let depth = 0;
+  for (const ch of text3) {
+    if (ch === "<" || ch === "(") depth++;
+    else if (ch === ">" || ch === ")") depth--;
+    else if (ch === "|" && depth === 0) return true;
+  }
+  return false;
+}
 function typeRefFromSchema(schema) {
-  if (!schema) return "json";
+  if (!schema || typeof schema !== "object") return "any";
   const ref = schema.$ref;
-  if (typeof ref === "string") return ref.split("/").pop() ?? "json";
-  if (schema.type === "array") {
-    return `${typeRefFromSchema(schema.items)}[]`;
+  if (typeof ref === "string") return ref.split("/").pop() ?? "any";
+  for (const key of ["anyOf", "oneOf"]) {
+    const members = schema[key];
+    if (!Array.isArray(members) || members.length === 0) continue;
+    const nullable = members.some(isNullSchema);
+    const texts = members.filter((m) => !isNullSchema(m)).map((m) => typeRefFromSchema(m));
+    if (texts.length === 0 || texts.includes("any")) return "any";
+    const text3 = texts.join(" | ");
+    if (!nullable) return text3;
+    return isTopLevelUnion(text3) ? `(${text3})?` : `${text3}?`;
   }
   const t = schema.type;
+  if (Array.isArray(t)) {
+    const types = t.filter((x) => typeof x === "string");
+    const nonNull = types.filter((x) => x !== "null");
+    if (nonNull.length !== 1) return "any";
+    const inner2 = typeRefFromSchema({ ...schema, type: nonNull[0] });
+    return types.includes("null") && inner2 !== "any" ? `${inner2}?` : inner2;
+  }
+  if (t === "array") {
+    const elem = typeRefFromSchema(schema.items);
+    return schema.uniqueItems === true ? `set<${elem}>` : `list<${elem}>`;
+  }
   if (t === "integer") return "int";
-  if (typeof t === "string" && t !== "object") return t;
-  return "json";
+  if (t === "number") return "float";
+  if (t === "boolean") return "bool";
+  if (t === "string") {
+    if (schema.format === "date") return "date";
+    if (schema.format === "date-time") return "datetime";
+    if (schema.format === "duration") return "duration";
+    if (schema.contentEncoding === "base64" || schema.format === "byte" || schema.format === "binary") return "bytes";
+    return "string";
+  }
+  if (t === "object" || t === void 0) {
+    const additional = schema.additionalProperties;
+    if (additional && typeof additional === "object") {
+      const names = schema.propertyNames;
+      const key = names && typeof names.$ref === "string" ? typeRefFromSchema(names) : names && typeof names.pattern === "string" && names.pattern.includes("[0-9]") ? "int" : "string";
+      return `map<${key}, ${typeRefFromSchema(additional)}>`;
+    }
+    if (additional === true) return "map<string, any>";
+  }
+  return "any";
+}
+function inlineEnumNote(schema) {
+  if (!schema || schema.$ref !== void 0 || !Array.isArray(schema.enum)) return void 0;
+  const values = schema.enum.filter((v) => typeof v === "string" || typeof v === "number");
+  return values.length ? `One of: ${values.join(", ")}.` : void 0;
+}
+function describedWith(description, note) {
+  const text3 = [description, note].filter((x) => !!x).join(" ");
+  return text3 ? { description: text3 } : {};
 }
 function authFromSecurityScheme(scheme) {
   const desc = typeof scheme.description === "string" ? { description: scheme.description } : {};
@@ -10889,11 +11899,12 @@ function fromOpenApi(document, projectName) {
       const params = [];
       for (const p of op.parameters ?? []) {
         if (typeof p.name !== "string") continue;
+        const schema = p.schema;
         params.push({
           name: p.name,
-          type: typeRefFromSchema(p.schema),
+          type: typeRefFromSchema(schema),
           ...p.required === true ? {} : { optional: true },
-          ...typeof p.description === "string" ? { description: p.description } : {}
+          ...describedWith(typeof p.description === "string" ? p.description : void 0, inlineEnumNote(schema))
         });
       }
       const bodySchema = op.requestBody?.content?.["application/json"]?.schema;
@@ -10902,7 +11913,12 @@ function fromOpenApi(document, projectName) {
         const required = new Set(bodySchema.required ?? []);
         if (Object.keys(props).length) {
           for (const [pname, pschema] of Object.entries(props)) {
-            params.push({ name: pname, type: typeRefFromSchema(pschema), ...required.has(pname) ? {} : { optional: true } });
+            params.push({
+              name: pname,
+              type: typeRefFromSchema(pschema),
+              ...required.has(pname) ? {} : { optional: true },
+              ...describedWith(typeof pschema.description === "string" ? pschema.description : void 0, inlineEnumNote(pschema))
+            });
           }
         } else {
           params.push({ name: "body", type: typeRefFromSchema(bodySchema) });
@@ -10938,6 +11954,14 @@ function fromOpenApi(document, projectName) {
       types.push(signature);
       continue;
     }
+    if (schema.type === "string" && Array.isArray(schema.enum)) {
+      types.push({ id, name: typeof schema.title === "string" ? schema.title : id, kind: "enum", fields: [], values: enumValuesFrom(schema) });
+      continue;
+    }
+    if (typeof schema.type === "string" && SCALAR_SCHEMA_TYPES.has(schema.type) && schema.properties === void 0) {
+      types.push({ id, name: typeof schema.title === "string" ? schema.title : id, kind: "value-object", fields: [], holds: typeRefFromSchema(schema) });
+      continue;
+    }
     const props = schema.properties ?? {};
     const required = new Set(schema.required ?? []);
     types.push({
@@ -10974,31 +11998,26 @@ function fromOpenApi(document, projectName) {
     types
   });
 }
-var yaml2, PRIMITIVES, SIGNATURE_EXTENSION;
+var yaml2, PRIMITIVE_SCHEMAS, SIGNATURE_EXTENSION, SCALAR_SCHEMA_TYPES;
 var init_openapi = __esm({
   "src/core/openapi.ts"() {
     "use strict";
     yaml2 = __toESM(require("js-yaml"));
     init_models();
-    PRIMITIVES = {
+    PRIMITIVE_SCHEMAS = {
       string: { type: "string" },
-      number: { type: "number" },
-      float: { type: "number" },
-      decimal: { type: "number" },
       int: { type: "integer" },
-      integer: { type: "integer" },
-      boolean: { type: "boolean" },
+      float: { type: "number" },
       bool: { type: "boolean" },
-      date: { type: "string", format: "date-time" },
+      bytes: { type: "string", contentEncoding: "base64" },
+      date: { type: "string", format: "date" },
       datetime: { type: "string", format: "date-time" },
-      uuid: { type: "string", format: "uuid" },
-      json: { type: "object" },
-      object: { type: "object" },
+      duration: { type: "string", format: "duration" },
       any: {},
-      unknown: {},
       void: {}
     };
     SIGNATURE_EXTENSION = "x-wairon-signature";
+    SCALAR_SCHEMA_TYPES = /* @__PURE__ */ new Set(["string", "integer", "number", "boolean"]);
   }
 });
 
@@ -11027,7 +12046,7 @@ function computeTypeClosure(entries, types, exported = []) {
     queue.push(key);
   };
   const enqueueRef = (ref) => {
-    if (BUILTIN_TYPES.has(ref.toLowerCase())) return;
+    if (isTypeVocabulary(ref)) return;
     for (const spec of types) {
       if (matchTypeRef(ref, qualifiedTypeId2(spec))) include(spec);
     }
@@ -11041,13 +12060,13 @@ function computeTypeClosure(entries, types, exported = []) {
   while (queue.length) {
     const spec = included.get(queue.shift());
     for (const field of spec.fields) {
-      for (const ref of extractTypeIdentifiers(field.type)) enqueueRef(ref);
+      for (const ref of writtenTypeRefs(field.type, "field")) enqueueRef(ref);
     }
     for (const param of spec.params ?? []) {
-      for (const ref of extractTypeIdentifiers(param.type)) enqueueRef(ref);
+      for (const ref of writtenTypeRefs(param.type, "signature-param")) enqueueRef(ref);
     }
     if (spec.returns) {
-      for (const ref of extractTypeIdentifiers(spec.returns)) enqueueRef(ref);
+      for (const ref of writtenTypeRefs(spec.returns, "signature-returns")) enqueueRef(ref);
     }
   }
   const usedIds = /* @__PURE__ */ new Set();
@@ -11066,7 +12085,11 @@ function computeTypeClosure(entries, types, exported = []) {
       kind: t.kind,
       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" } : {}
+      ...t.kind === "signature" ? { params: (t.params ?? []).map(describe3), returns: t.returns ?? "any" } : {},
+      // An enum travels with its values, in declared order.
+      ...t.kind === "enum" ? { values: (t.values ?? []).map((v) => ({ name: v.name, ...v.description ? { description: v.description } : {} })) } : {},
+      // A named scalar travels with the primitive it holds.
+      ...t.holds !== void 0 ? { holds: t.holds } : {}
     };
   });
 }
@@ -11810,7 +12833,7 @@ function depthOf(family, node) {
   return depth;
 }
 function selectProjects(family, options) {
-  const limit = typeof options.recursive === "number" ? options.recursive : options.recursive === false ? 0 : Infinity;
+  const limit = options.memberDepth ?? Infinity;
   const nodes = family.nodes.filter((n) => depthOf(family, n) <= limit);
   const scope = options.scopeSubsystem;
   if (!scope) return nodes.map((node) => ({ node }));
@@ -12617,7 +13640,7 @@ function globalPacksEnabled(config) {
   return config.extensions?.useGlobalPacks ?? GLOBAL_PACKS_DEFAULT;
 }
 function emptyExtensions() {
-  return { packNames: [], packs: [], rules: [], profiles: {}, languages: {}, skills: [], patterns: [], guarantees: [], assertions: [], instructions: [], errors: [], selectionFailures: [] };
+  return { packNames: [], packs: [], rules: [], profiles: {}, languages: {}, skills: [], patterns: [], guarantees: [], assertions: [], instructions: [], errors: [], selectionFailures: [], deprecations: [] };
 }
 function globalPacksDir() {
   return process.env.WAIRON_PACKS_DIR ?? path19.join(os4.homedir(), ".wairon", "packs");
@@ -12678,11 +13701,11 @@ function mergePack(out, pack, ref, scope, packDir) {
   Object.assign(out.profiles, pack.profiles);
   for (const [lang, def] of Object.entries(pack.languages)) {
     const key = lang.toLowerCase();
+    if (def.foreignBuiltins !== void 0) {
+      out.deprecations.push(`${pack.name}: languages.${lang}.foreignBuiltins \u2014 ${FOREIGN_BUILTINS_RETIRED}`);
+    }
     const existing = out.languages[key];
-    out.languages[key] = existing ? {
-      unsupportedFlow: { ...existing.unsupportedFlow, ...def.unsupportedFlow },
-      foreignBuiltins: [.../* @__PURE__ */ new Set([...existing.foreignBuiltins, ...def.foreignBuiltins])]
-    } : def;
+    out.languages[key] = { unsupportedFlow: { ...existing?.unsupportedFlow, ...def.unsupportedFlow } };
   }
   for (const s of pack.skills) out.skills.push({ ...s, pack: pack.name, packVersion: pack.version, sourcePath: path19.resolve(packDir, s.source) });
   for (const p of pack.patterns) out.patterns.push({ ...p, pack: pack.name });
@@ -12973,7 +13996,7 @@ function findBundledPack(projectRoot2, selection) {
   }
   return best?.dir ?? null;
 }
-var fs14, os4, path19, import_module, import_zod9, ProfileDefSchema, LanguagePackDefSchema, PackSkillSchema, PackInstructionBlockSchema, PackInstructionsSchema, PatternDefSchema, AssertionSelectorSchema, assertionBase, PackAssertionSchema, DeclarativePackSchema, EXTENDABLE_BUILTIN_SKILLS, GLOBAL_PACKS_DEFAULT, PACK_DIR_ENTRIES, isYamlPath;
+var fs14, os4, path19, import_module, import_zod9, ProfileDefSchema, LanguagePackDefSchema, PackSkillSchema, PackInstructionBlockSchema, PackInstructionsSchema, PatternDefSchema, AssertionSelectorSchema, assertionBase, PackAssertionSchema, DeclarativePackSchema, EXTENDABLE_BUILTIN_SKILLS, GLOBAL_PACKS_DEFAULT, FOREIGN_BUILTINS_RETIRED, PACK_DIR_ENTRIES, isYamlPath;
 var init_extensions = __esm({
   "src/core/extensions.ts"() {
     "use strict";
@@ -13012,7 +14035,7 @@ var init_extensions = __esm({
     });
     LanguagePackDefSchema = import_zod9.z.object({
       unsupportedFlow: import_zod9.z.record(import_zod9.z.string()).default({}),
-      foreignBuiltins: import_zod9.z.array(import_zod9.z.string()).default([])
+      foreignBuiltins: import_zod9.z.array(import_zod9.z.string()).optional()
     });
     PackSkillSchema = import_zod9.z.object({
       /** A NEW skill, installed namespaced as `<pack-id>-<id>`. Mutually exclusive with `extends`. */
@@ -13126,6 +14149,7 @@ var init_extensions = __esm({
     });
     EXTENDABLE_BUILTIN_SKILLS = ["sdd-architect", "sdd-narrative", "sdd-auditor", "sdd-implement", "sdd-delegate"];
     GLOBAL_PACKS_DEFAULT = false;
+    FOREIGN_BUILTINS_RETIRED = "nothing replaces it: contracts are written in the neutral type grammar and a language is chosen at L4, so the foreign-builtin check it fed is retired";
     PACK_DIR_ENTRIES = ["pack.yaml", "pack.yml", "pack.cjs", "pack.js", "index.cjs", "index.js"];
     isYamlPath = (p) => /\.ya?ml$/i.test(p);
   }
@@ -13446,7 +14470,7 @@ function buildImplementationMethods(ctx) {
     const component = ctx.componentMap.get(contract.component);
     if (!component) continue;
     if (ctx.isInChainedSubproject(component.subsystem)) continue;
-    const draftContext3 = ctx.isImplementationDraft(impl);
+    const draftContext4 = ctx.isImplementationDraft(impl);
     for (const method2 of impl.methods) {
       const sourceFile = methodSourceFile(method2, impl.sourcePath);
       out.push({
@@ -13454,7 +14478,7 @@ function buildImplementationMethods(ctx) {
         method: method2,
         component,
         ...sourceFile !== void 0 ? { sourceFile } : {},
-        draftContext: draftContext3
+        draftContext: draftContext4
       });
     }
   }
@@ -13736,7 +14760,7 @@ var init_type_declarations = __esm({
     typeDeclarationsRule = {
       name: "type-declarations",
       judges: "design",
-      description: "A type owned by a subsystem must reference an existing one, and a type declaring neither fields nor methods is a placeholder that can inform neither implementers nor the ERD.",
+      description: "A type owned by a subsystem must reference an existing one, and a type declaring neither fields nor methods (nor, for an enum, values, nor, for a signature type, returns, nor, for a named scalar, the primitive it holds) is a placeholder that can inform neither implementers nor the ERD.",
       codes: [
         { code: "INVALID_SUBSYSTEM_REFERENCE", defaultSeverity: "error", summary: "Type references a non-existent owning subsystem" },
         { code: "HOLLOW_TYPE", defaultSeverity: "warning", summary: "Type declares no fields and no methods \u2014 a placeholder that informs neither implementers nor the ERD" }
@@ -13754,7 +14778,8 @@ var init_type_declarations = __esm({
               isDraftCtx
             );
           }
-          if ((!t.fields || t.fields.length === 0) && (!t.methods || t.methods.length === 0)) {
+          const models = (t.fields?.length ?? 0) > 0 || (t.methods?.length ?? 0) > 0 || (t.values?.length ?? 0) > 0 || t.returns !== void 0 || t.holds !== void 0;
+          if (!models) {
             ctx.addIssue(
               "warning",
               "HOLLOW_TYPE",
@@ -14018,6 +15043,7 @@ var init_signature_types = __esm({
             );
             continue;
           }
+          if (t.kind === "enum") continue;
           const stated = [...t.params !== void 0 ? ["params"] : [], ...t.returns !== void 0 ? ["returns"] : []];
           if (stated.length === 0) continue;
           ctx.addIssue(
@@ -14072,6 +15098,204 @@ var init_signature_text = __esm({
   }
 });
 
+// src/core/rules/integrity/type-expressions.ts
+function draftContext3(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");
+}
+function siteOf(path92) {
+  const [head2, name] = path92.split(".");
+  return (head2 === "methods" || head2 === "fields") && name ? name : path92;
+}
+function located(kind, specId, path92) {
+  return `${path92 ? `"${path92}" of ` : ""}${kind ?? "spec"} "${specId}"`;
+}
+function problemMessage(problem, specId) {
+  const where = located(problem.kind, specId, problem.path);
+  const replacement = problem.replacement ? ` Write ${problem.replacement} instead.` : "";
+  switch (problem.code) {
+    case "TYPE_EXPRESSION_INVALID":
+      return `The type at ${where} does not parse under the type grammar: ${problem.detail}.${replacement} Every reader treats the position as opaque any until it does.`;
+    case "TYPE_POSITION_INVALID":
+      return `The type at ${where} breaks a position rule: ${problem.detail}.${replacement}`;
+    case "TYPE_FORM_UNSUPPORTED":
+      return `The type at ${where} uses a form the type grammar leaves out: ${problem.detail}.${replacement} Every reader treats the position as opaque any until it is remodelled; the writer refuses it in a new write.`;
+    case "TYPE_NOT_NEUTRAL": {
+      if (problem.replacement === "int or float") {
+        const proposal = typeProblemIntProposal({ ...problem, specId }) ? ` Its name says a whole number, so \`wairon doctor\` proposes int here \u2014 confirm it by writing int, or write float.` : " Write int or float.";
+        return `The type at ${where} is "${problem.written}": number does not say whether it holds an integer \u2014 int or float?${proposal} Until then it is read as float.`;
+      }
+      return `The type at ${where} is "${problem.written}": ${problem.detail}, so it is read as any.${replacement}`;
+    }
+  }
+}
+var typeExpressionsRule;
+var init_type_expressions = __esm({
+  "src/core/rules/integrity/type-expressions.ts"() {
+    "use strict";
+    init_models();
+    typeExpressionsRule = {
+      name: "type-expressions",
+      judges: "design",
+      description: "Reports what the scan's type canonicalisation recorded (ctx.typeSpellingFacts), one finding per position, located by spec and path: a stored text that does not parse (TYPE_EXPRESSION_INVALID); one that breaks a position rule \u2014 void or async out of place, a map key that is not string, int or an enum, a named scalar's holds that is not one primitive other than void and any, `T??` (TYPE_POSITION_INVALID); one using a form the grammar leaves out \u2014 an inline object shape, an inline function type, a string-literal union, a union mixing in a primitive or a collection, an intersection, a utility type or a tuple (TYPE_FORM_UNSUPPORTED); one naming `number` or a legacy builtin with no neutral meaning (TYPE_NOT_NEUTRAL); and one that is an alias of its canonical spelling (TYPE_SPELLING_STALE, which any save or doctor --fix repairs). Every message names the replacement: `number` asks \"int or float?\" (and says when the doctor repair proposes int), a function type names a signature type, a literal union an enum, an inline object or a mixed union a named value-object. The writer refuses all but the stale spelling at write time; these findings are how a tree that held them before the grammar existed is told, while it still loads and its consumers read the position as opaque any \u2014 which is why only what no real tree holds (a text that does not parse, a broken position rule) is an error. No finding when the run carries no facts (a candidate run).",
+      codes: [
+        { code: "TYPE_EXPRESSION_INVALID", defaultSeverity: "error", summary: "A structured type position does not parse under the type grammar" },
+        { code: "TYPE_POSITION_INVALID", defaultSeverity: "error", summary: "A type position breaks a position rule: void or async out of place, a non-scalar map key, or T??" },
+        { code: "TYPE_FORM_UNSUPPORTED", defaultSeverity: "warning", summary: "A type position uses a form the grammar leaves out \u2014 inline object, inline function type, string-literal union, union mixing in a primitive or collection, intersection, utility type or tuple \u2014 and the message names its named replacement" },
+        { code: "TYPE_NOT_NEUTRAL", defaultSeverity: "warning", summary: "A type position names number (int or float?) or a legacy builtin with no neutral meaning, and the message names the replacement" },
+        { code: "TYPE_SPELLING_STALE", defaultSeverity: "warning", summary: "A stored type position is an alias of its canonical spelling; any save or doctor --fix rewrites it" }
+      ],
+      check(ctx) {
+        const facts = ctx.typeSpellingFacts;
+        if (!facts) return;
+        for (const problem of facts.problems) {
+          if (problem.specId === void 0 || !ctx.isSpecInScope(problem.specId)) continue;
+          const severity = problem.code === "TYPE_EXPRESSION_INVALID" || problem.code === "TYPE_POSITION_INVALID" ? "error" : "warning";
+          ctx.addIssue(
+            severity,
+            problem.code,
+            problemMessage(problem, problem.specId),
+            problem.specId,
+            draftContext3(ctx, problem.specId, problem.kind),
+            void 0,
+            problem.path ? { at: siteOf(problem.path) } : void 0
+          );
+        }
+        for (const respelling of facts.respellings) {
+          if (!ctx.isSpecInScope(respelling.specId)) continue;
+          ctx.addIssue(
+            "warning",
+            "TYPE_SPELLING_STALE",
+            `The type at ${located(respelling.kind, respelling.specId, respelling.path)} is stored as "${respelling.written}", an alias of its canonical spelling "${respelling.stored}" \u2014 which is what every reader is shown. Any save of the spec writes the canonical text, and \`wairon doctor --fix\` rewrites every stale spelling at once.`,
+            respelling.specId,
+            draftContext3(ctx, respelling.specId, respelling.kind),
+            void 0,
+            { at: siteOf(respelling.path) }
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/integrity/enum-types.ts
+var enumTypesRule;
+var init_enum_types = __esm({
+  "src/core/rules/integrity/enum-types.ts"() {
+    "use strict";
+    init_models();
+    enumTypesRule = {
+      name: "enum-types",
+      judges: "design",
+      description: "An enum is a closed, ordered set of named values with optional pure methods, nothing else: an enum without values, with two values equal by reference_resolution.nameKey (every language derives one identifier from both), or carrying fields, params, returns, invariants, componentClass, database, table or linkedEntity is reported; so are values on a type of any other kind, where they mean nothing.",
+      codes: [
+        { code: "ENUM_MEMBERS", defaultSeverity: "error", summary: "An enum has no values, two values equal by nameKey, or a member it cannot carry; or a type of another kind carries values" }
+      ],
+      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 === "enum") {
+            const values = t.values ?? [];
+            const problems = [];
+            if (values.length === 0) problems.push("lists no values");
+            const seen = /* @__PURE__ */ new Map();
+            for (const value of values) {
+              const key = nameKey(value.name);
+              const earlier = seen.get(key);
+              if (earlier !== void 0) problems.push(`lists "${earlier}" and "${value.name}", which every language derives one identifier from`);
+              else seen.set(key, value.name);
+            }
+            const members = [
+              ...t.fields.length > 0 ? ["fields"] : [],
+              ...t.params !== void 0 ? ["params"] : [],
+              ...t.returns !== void 0 ? ["returns"] : [],
+              ...(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"] : []
+            ];
+            if (members.length > 0) problems.push(`carries ${members.join(", ")}`);
+            if (problems.length === 0) continue;
+            ctx.addIssue(
+              "error",
+              "ENUM_MEMBERS",
+              `Enum type "${t.id}" ${problems.join("; ")}. An enum is a closed, ordered set of named values, unique by name ignoring case and separators, with optional pure methods and nothing else.`,
+              t.id,
+              isDraft
+            );
+            continue;
+          }
+          if (t.values === void 0) continue;
+          ctx.addIssue(
+            "error",
+            "ENUM_MEMBERS",
+            `Type "${t.id}" is ${t.kind === "entity" ? "an entity" : `a ${t.kind}`} and carries values, which only an enum has. Make it kind enum, or drop them.`,
+            t.id,
+            isDraft
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/integrity/named-scalar-types.ts
+var namedScalarTypesRule;
+var init_named_scalar_types = __esm({
+  "src/core/rules/integrity/named-scalar-types.ts"() {
+    "use strict";
+    namedScalarTypesRule = {
+      name: "named-scalar-types",
+      judges: "design",
+      description: "A named scalar is a value-object that declares `holds: <primitive>` in place of fields \u2014 a newtype or type alias in every language. It models its value and nothing else beside its pure methods and invariants: holds beside fields, componentClass, database, table or linkedEntity is reported, and so is holds on an entity, an enum or a signature type, where it means nothing. Whether holds names one of the primitives is the type-expressions rule's question (TYPE_POSITION_INVALID on the holds position), never a second voice here. Mirrors enum-types and signature-types: judged at validate time, on the type's own fields.",
+      codes: [
+        { code: "NAMED_SCALAR_MEMBERS", defaultSeverity: "error", summary: "A named scalar (a value-object holding a primitive) carries fields or a member it cannot carry; or a type of another kind declares holds" }
+      ],
+      check(ctx) {
+        for (const t of ctx.types) {
+          if (!ctx.isSpecInScope(t.id)) continue;
+          if (t.holds === void 0) 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 !== "value-object") {
+            ctx.addIssue(
+              "error",
+              "NAMED_SCALAR_MEMBERS",
+              `Type "${t.id}" is ${t.kind === "entity" ? "an entity" : `a ${t.kind}`} and declares holds, which only a value-object has: a named scalar is a value-object holding one primitive. Make it a value-object, or drop holds.`,
+              t.id,
+              isDraft
+            );
+            continue;
+          }
+          const members = [
+            ...t.fields.length > 0 ? ["fields"] : [],
+            ...t.componentClass !== void 0 ? ["componentClass"] : [],
+            ...t.database !== void 0 ? ["database"] : [],
+            ...t.table !== void 0 ? ["table"] : [],
+            ...t.linkedEntity !== void 0 ? ["linkedEntity"] : []
+          ];
+          if (members.length === 0) continue;
+          ctx.addIssue(
+            "error",
+            "NAMED_SCALAR_MEMBERS",
+            `Named scalar "${t.id}" holds ${t.holds} and carries ${members.join(", ")}. A named scalar is one primitive under a name, with optional pure methods and invariants and nothing else: drop ${members.length === 1 ? "it" : "them"}, or drop holds and model the value-object's fields.`,
+            t.id,
+            isDraft
+          );
+        }
+      }
+    };
+  }
+});
+
 // src/core/rules/integrity/public-surface-binding.ts
 var publicSurfaceBindingRule;
 var init_public_surface_binding = __esm({
@@ -15661,11 +16885,11 @@ var init_detail_sufficiency = __esm({
           const contract = ctx.interfaceMap.get(impl.contract);
           if (!contract) continue;
           const component = ctx.componentMap.get(contract.component);
-          const draftContext3 = ctx.isImplementationDraft(impl);
+          const draftContext4 = 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: draftContext3 });
+              dialedDown.push({ implementation: impl, method: method2, component, detail, draftContext: draftContext4 });
             }
           }
         }
@@ -17291,6 +18515,31 @@ var init_pack_requirements = __esm({
   }
 });
 
+// src/core/rules/extension/pack-deprecations.ts
+var packDeprecationsRule;
+var init_pack_deprecations = __esm({
+  "src/core/rules/extension/pack-deprecations.ts"() {
+    "use strict";
+    packDeprecationsRule = {
+      name: "pack-deprecations",
+      judges: "design",
+      description: "A loaded pack still declaring a field wairon has deprecated (ctx.ext.deprecations \u2014 today a language's foreignBuiltins, whose foreign-builtin check is retired because contracts are written in the neutral type grammar) is told so: the field is accepted and ignored for one release and removed in the release after. A notice: it never fails the gate.",
+      codes: [
+        { code: "PACK_FIELD_DEPRECATED", defaultSeverity: "notice", summary: "A loaded pack declares a deprecated field, accepted and ignored for one release" }
+      ],
+      check(ctx) {
+        for (const deprecation of ctx.ext.deprecations) {
+          ctx.addIssue(
+            "notice",
+            "PACK_FIELD_DEPRECATED",
+            `Deprecated pack field \u2014 ${deprecation}. It is accepted and ignored in this release and removed in the next; take it out of the pack.`
+          );
+        }
+      }
+    };
+  }
+});
+
 // src/core/rules/wiring/dependency-cycles.ts
 var cyclesRule;
 var init_dependency_cycles = __esm({
@@ -18018,19 +19267,27 @@ var init_durability_round_trip = __esm({
 });
 
 // src/core/rules/wiring/untyped-seams.ts
-function namesBareType(refs) {
-  return refs.some((ref) => BARE_SEAM_TYPES.has(ref.toLowerCase()));
+function holdsAny(expr) {
+  return expr.form === "primitive" && expr.name === "any" || expr.args.some(holdsAny);
+}
+function tokensUntyped(text3) {
+  return extractTypeIdentifiers(text3).some((ref) => UNTYPED_SPELLINGS.has(ref.toLowerCase()));
+}
+function positionUntyped(text3, position) {
+  const parse = parseTypePosition(text3, position);
+  if (parse.expression && !parse.problem) return holdsAny(parse.expression);
+  return tokensUntyped(text3);
 }
-var BARE_SEAM_TYPES, untypedSeamRule;
+var UNTYPED_SPELLINGS, untypedSeamRule;
 var init_untyped_seams = __esm({
   "src/core/rules/wiring/untyped-seams.ts"() {
     "use strict";
     init_models();
-    BARE_SEAM_TYPES = /* @__PURE__ */ new Set(["json", "any", "unknown", "object"]);
+    UNTYPED_SPELLINGS = /* @__PURE__ */ new Set(["any", "json", "unknown", "object"]);
     untypedSeamRule = {
       name: "untyped-seams",
       judges: "design",
-      description: "Methods on a subsystem's published components (its public surface) should not take or return bare Json/any/unknown/object, judged through each method's type references so a prose signature is judged like structured params: cross-subsystem contracts are the swap seam and must be typed. Generic-dispatch portals carry per-capability types via their dispatch table instead.",
+      description: "Methods on a subsystem's published components (its public surface) should not take or return `any` \u2014 the one untyped type of the grammar, which object, unknown, json and Json are canonicalised to \u2014 judged through each method's named types and parsed expressions so a prose signature is judged like structured params (its tokens still read leniently): cross-subsystem contracts are the swap seam and must be typed. Generic-dispatch portals carry per-capability types via their dispatch table instead.",
       codes: [
         { code: "UNTYPED_SEAM", defaultSeverity: "warning", summary: "Bare Json/any/unknown/object parameter or return crossing a subsystem public surface" }
       ],
@@ -18048,14 +19305,14 @@ var init_untyped_seams = __esm({
                 const offenders = [];
                 if (m.params && m.params.length > 0) {
                   for (const p of m.params) {
-                    if (namesBareType(extractTypeIdentifiers(p.type))) {
+                    if (positionUntyped(p.type, "param")) {
                       offenders.push(`param "${p.name}: ${p.type}"`);
                     }
                   }
-                  if (namesBareType(extractTypeIdentifiers(m.returns ?? ""))) {
+                  if (m.returns && positionUntyped(m.returns, "returns")) {
                     offenders.push(`return "${m.returns}"`);
                   }
-                } else if (namesBareType(methodTypeRefs(m))) {
+                } else if (methodTypeRefs(m).some((ref) => UNTYPED_SPELLINGS.has(ref.toLowerCase()))) {
                   offenders.push(`signature "${m.signature}"`);
                 }
                 if (offenders.length) {
@@ -19423,6 +20680,33 @@ function originOf(shape) {
 function absence(optional) {
   return optional ? "may be absent" : "is always there";
 }
+function judgeNamedScalar(ctx, type, file, facts) {
+  if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") return;
+  const dialect = dialectOf(facts);
+  const holds = parseTypePosition(type.holds, "holds").expression;
+  if (!dialect || !holds) return;
+  const symbol = type.symbol ?? type.name;
+  const own = (record2) => !!record2 && Object.prototype.hasOwnProperty.call(record2, symbol);
+  let declared;
+  if (own(facts.aliasTypes)) {
+    const annotation = facts.aliasTypes[symbol];
+    if (dialect.agrees(annotation, holds, /* @__PURE__ */ new Map())) return;
+    declared = `an alias of \`${annotation}\``;
+  } else if (own(facts.typeShapes)) {
+    declared = "a record (an object shape)";
+  } else {
+    return;
+  }
+  ctx.addIssue(
+    "warning",
+    "TYPE_HOLDS_MISMATCH",
+    `Named scalar "${type.id}" holds ${type.holds}, but "${file}" declares "${symbol}" as ${declared}. Every reader of a named scalar is told what one value of it is, and the code says otherwise. Make the declaration an alias of the primitive (in TypeScript, \`type ${symbol} = ${dialect.write(holds)}\`), or change what the type holds.`,
+    type.id,
+    void 0,
+    void 0,
+    { at: symbol }
+  );
+}
 var typeShapeRule;
 var init_type_shape = __esm({
   "src/core/rules/conformance/type-shape.ts"() {
@@ -19431,7 +20715,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 \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.",
+      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. A NAMED SCALAR (a value-object declaring `holds`) has no field list: its shape is the primitive it holds, compared with the right side of the type alias the file declares under its name, read through the file's dialect (`type PackPath = string` agrees with holds string); an object shape under that name, or an alias the dialect does not read as that primitive, is TYPE_HOLDS_MISMATCH.",
       codes: [
         {
           code: "UNREALIZED_TYPE_FIELD",
@@ -19447,6 +20731,12 @@ var init_type_shape = __esm({
           summary: "The shape at a type's sourcePath carries a field the type spec does not declare \u2014 data the design never described, so no diagram draws it and no brief hands it to an implementer",
           carryable: true
         },
+        {
+          code: "TYPE_HOLDS_MISMATCH",
+          defaultSeverity: "warning",
+          summary: "A named scalar's holds disagrees with what its sourcePath declares under its name \u2014 an alias of another type, or a record \u2014 so every reader is told one value of it is something the code says it is not",
+          carryable: true
+        },
         {
           code: "TYPE_FIELD_OPTIONALITY",
           defaultSeverity: "warning",
@@ -19461,6 +20751,10 @@ var init_type_shape = __esm({
           if (type.subsystem && ctx.isInChainedSubproject(type.subsystem)) continue;
           const file = pathKey(type.sourcePath);
           const facts = code.factsAt(file);
+          if (type.holds !== void 0) {
+            judgeNamedScalar(ctx, type, file, facts);
+            continue;
+          }
           if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
           const symbol = type.symbol ?? type.name;
           const shapes = facts.typeShapes;
@@ -19517,6 +20811,74 @@ var init_type_shape = __esm({
   }
 });
 
+// src/core/rules/conformance/enum-values.ts
+var enumValuesRule;
+var init_enum_values = __esm({
+  "src/core/rules/conformance/enum-values.ts"() {
+    "use strict";
+    init_models();
+    enumValuesRule = {
+      name: "enum-values",
+      judges: "code",
+      description: "Code-to-contract for an ENUM: an enum type's values are compared, name by name, with the values the declaration at its sourcePath holds \u2014 a string-literal union alias, the array a z.enum constant holds, or a string enum's member values (source_file_facts.enumValues). `typeRealization` already asks whether the declaration exists; nothing asked whether it holds the values the design lists, and an enum is read by every diagram, OpenAPI document and brief as the closed set it claims. Exact grade only; a declaration the analyzer reads no values from is typeRealization's question, never this rule's. Order is not judged: languages differ on whether declaration order is observable.",
+      codes: [
+        {
+          code: "UNREALIZED_ENUM_VALUE",
+          defaultSeverity: "warning",
+          summary: "An enum type lists a value the declaration at its sourcePath does not hold \u2014 the design promises a value the code would reject",
+          carryable: true
+        },
+        {
+          code: "UNDECLARED_ENUM_VALUE",
+          defaultSeverity: "warning",
+          summary: "The declaration at an enum type's sourcePath holds a value the enum does not list \u2014 a value the design never described",
+          carryable: true
+        }
+      ],
+      check(ctx) {
+        const code = ctx.codeIndex();
+        for (const type of ctx.types) {
+          if (type.kind !== "enum" || !type.sourcePath) continue;
+          if (type.subsystem && ctx.isInChainedSubproject(type.subsystem)) continue;
+          const file = pathKey(type.sourcePath);
+          const facts = code.factsAt(file);
+          const symbol = type.symbol ?? type.name;
+          if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
+          const declared = facts.enumValues;
+          if (!declared || !Object.prototype.hasOwnProperty.call(declared, symbol)) continue;
+          const held = new Set(declared[symbol]);
+          const listed = (type.values ?? []).map((value) => value.name);
+          const listedSet = new Set(listed);
+          const unrealized = listed.filter((value) => !held.has(value));
+          if (unrealized.length > 0) {
+            ctx.addIssue(
+              "warning",
+              "UNREALIZED_ENUM_VALUE",
+              `Enum type "${type.id}" lists ${unrealized.length} value(s) the declaration "${symbol}" in "${file}" does not hold \u2014 ${unrealized.map((value) => `"${value}"`).join(", ")}. The design promises a value the code would reject, and every diagram, OpenAPI document and brief offers it. Add it to the declaration, or drop it from the enum (values compare exactly: a value is data).`,
+              type.id,
+              void 0,
+              void 0,
+              { at: symbol, covers: unrealized }
+            );
+          }
+          const undeclared = declared[symbol].filter((value) => !listedSet.has(value));
+          if (undeclared.length > 0) {
+            ctx.addIssue(
+              "warning",
+              "UNDECLARED_ENUM_VALUE",
+              `The declaration "${symbol}" in "${file}" holds ${undeclared.length} value(s) enum type "${type.id}" does not list \u2014 ${undeclared.map((value) => `"${value}"`).join(", ")}. A value the design never described is one no diagram shows and no brief hands an implementer. List it on the enum, or take it out of the code.`,
+              type.id,
+              void 0,
+              void 0,
+              { at: symbol, covers: undeclared }
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/core/rules/conformance/param-conformance.ts
 function omittable(optional) {
   return optional ? "may be left out" : "is required";
@@ -19572,7 +20934,7 @@ var init_param_conformance = __esm({
     paramConformanceRule = {
       name: "param-conformance",
       judges: "code",
-      description: "Code-to-contract for the SIGNATURE, the last of the three readings a spec-driven gate never made: a contract declares `params`, and nothing ever compared them to the parameters of the function that realizes the method. A contract could promise an argument the code does not take, take one the contract never mentions \u2014 including a secret \u2014 or name the same argument two different things, and the brief handed to an implementer would carry the contract's version. Parameters are matched by POSITION against the tail of the realization's list, and the declared type is what tells a rename from a dropped argument: `seed(config: HostConfig)` realized as `bootstrapInstance(cfg: HostConfig)` is one parameter under two names, which anything matching on names alone reads as a parameter the code lost. What a realization takes BEFORE the contract's own parameters is wiring, and it is declared on the implementation as `injectedParams` rather than inferred, because an inferred prefix cannot be told from a renamed first argument. A method the named file only CALLS is left to `methodRealization`, which already reports that the body is not here.",
+      description: "Code-to-contract for the SIGNATURE, the last of the three readings a spec-driven gate never made: a contract declares `params`, and nothing ever compared them to the parameters of the function that realizes the method. A contract could promise an argument the code does not take, take one the contract never mentions \u2014 including a secret \u2014 or name the same argument two different things, and the brief handed to an implementer would carry the contract's version. Parameters are matched by POSITION against the tail of the realization's list, and the declared type is what tells a rename from a dropped argument: `seed(config: HostConfig)` realized as `bootstrapInstance(cfg: HostConfig)` is one parameter under two names, which anything matching on names alone reads as a parameter the code lost. Types agree when the code's annotation, read through the dialect of the language the file was analyzed as (type_dialect.agrees), is the contract's canonical type \u2014 so `string[]` in the code agrees with `list<string>` in the contract, TypeScript's `number` with int and float alike, and an annotation the dialect cannot read agrees with nothing. What a realization takes BEFORE the contract's own parameters is wiring, and it is declared on the implementation as `injectedParams` rather than inferred, because an inferred prefix cannot be told from a renamed first argument. A method the named file only CALLS is left to `methodRealization`, which already reports that the body is not here.",
       codes: [
         {
           code: "UNREALIZED_PARAM",
@@ -19609,13 +20971,13 @@ var init_param_conformance = __esm({
           codeNameOf.set(type.id, named2);
           if (type.subsystem) codeNameOf.set(`${type.subsystem}.${type.id}`, named2);
         }
-        const normalize3 = (text3) => text3.replace(/\s+/g, " ").trim();
-        const typeAgrees = (declared, realized) => {
-          if (!realized.type) return false;
-          const stated = normalize3(declared.type);
-          return stated === realized.type || codeNameOf.get(stated) === realized.type;
+        const typeAgreesIn = (dialect) => (declared, realized) => {
+          if (!realized.type || !dialect) return false;
+          const stated = parseTypePosition(declared.type, "param", !!declared.optional);
+          if (!stated.expression) return false;
+          return dialect.agrees(realized.type, stated.expression, codeNameOf);
         };
-        for (const { implementation, method: method2, sourceFile, draftContext: draftContext3 } of ctx.implementationMethods()) {
+        for (const { implementation, method: method2, sourceFile, draftContext: draftContext4 } 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;
@@ -19628,6 +20990,7 @@ var init_param_conformance = __esm({
           const candidates = signatures[symbol];
           if (candidates.length === 0) continue;
           const injected = new Set(implementation.injectedParams ?? []);
+          const typeAgrees = typeAgreesIn(dialectOf(facts));
           const judgements = candidates.map((realized) => judge(declared, realized, injected, typeAgrees));
           const subject = candidates.length > 1 ? `every function called "${symbol}" in "${file}"` : `the function "${symbol}" in "${file}"`;
           const opening = subject.charAt(0).toUpperCase() + subject.slice(1);
@@ -19638,7 +21001,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,
-              draftContext3,
+              draftContext4,
               void 0,
               { at: method2.name, covers: unrealized.map((found) => found.unit) }
             );
@@ -19650,7 +21013,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,
-              draftContext3,
+              draftContext4,
               void 0,
               { at: method2.name, covers: undeclared.map((found) => found.unit) }
             );
@@ -19662,7 +21025,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,
-              draftContext3,
+              draftContext4,
               void 0,
               { at: method2.name, covers: renamed.map((found) => found.unit) }
             );
@@ -19674,7 +21037,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,
-              draftContext3,
+              draftContext4,
               void 0,
               { at: method2.name, covers: disagreed.map((found) => found.unit) }
             );
@@ -19685,6 +21048,69 @@ var init_param_conformance = __esm({
   }
 });
 
+// src/core/rules/conformance/async-conformance.ts
+var asyncConformanceRule;
+var init_async_conformance = __esm({
+  "src/core/rules/conformance/async-conformance.ts"() {
+    "use strict";
+    init_models();
+    asyncConformanceRule = {
+      name: "async-conformance",
+      judges: "code",
+      description: "Code-to-contract for ASYNC: a contract method whose returns is `async T` is realized by a function that completes later, and one whose returns is not, by one that completes now \u2014 every caller in every language with async/await is shaped by the difference, so a contract that hides it misleads every implementer and translation built from it. Compared with source_file_facts.asyncFunctions for the method's realizing function (under its `symbol`), at exact grade only; where a name has several bodies only what they all agree on is reported, as param-conformance does. A method whose file only calls the function is methodRealization's finding.",
+      codes: [
+        {
+          code: "ASYNC_MISMATCH",
+          defaultSeverity: "warning",
+          summary: "A contract method and the function realizing it disagree about whether the call completes later: the returns says `async T` and the code completes now, or the code is async and the returns does not say so",
+          carryable: true
+        }
+      ],
+      check(ctx) {
+        const code = ctx.codeIndex();
+        for (const { implementation, method: method2, sourceFile, draftContext: draftContext4 } of ctx.implementationMethods()) {
+          const contractMethod = ctx.interfaceMap.get(implementation.contract)?.methods.find((m) => m.name === method2.name);
+          if (!contractMethod || typeof contractMethod.returns !== "string" || !sourceFile) continue;
+          const file = pathKey(sourceFile);
+          const facts = code.factsAt(file);
+          if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
+          const symbol = method2.symbol ?? method2.name;
+          const signatures = facts.functionParams;
+          if (!signatures || !Object.prototype.hasOwnProperty.call(signatures, symbol)) continue;
+          const bodies = signatures[symbol].length;
+          if (bodies === 0) continue;
+          const returns = parseTypeExpression(contractMethod.returns, "returns");
+          if (!returns.expression) continue;
+          const contractAsync = returns.expression.form === "async";
+          const asyncBodies = (facts.asyncFunctions ?? []).filter((name) => name === symbol).length;
+          const subject = bodies > 1 ? `every function called "${symbol}" in "${file}"` : `the function "${symbol}" in "${file}"`;
+          if (contractAsync && asyncBodies === 0) {
+            ctx.addIssue(
+              "warning",
+              "ASYNC_MISMATCH",
+              `Method "${method2.name}" of contract "${implementation.contract}" returns "${contractMethod.returns}", which completes later, but ${subject} completes now \u2014 it is neither declared async nor annotated to return a Promise. Every caller is told to await a call that answers at once. Make the code async, or drop \`async\` from the returns.`,
+              implementation.id,
+              draftContext4,
+              void 0,
+              { at: method2.name }
+            );
+          } else if (!contractAsync && asyncBodies === bodies) {
+            ctx.addIssue(
+              "warning",
+              "ASYNC_MISMATCH",
+              `Method "${method2.name}" of contract "${implementation.contract}" returns "${contractMethod.returns}", which completes now, but ${subject} completes later (declared async, or annotated to return a Promise). Every caller built from the contract forgets to await it. Write the returns as "async ${contractMethod.returns}" \u2014 or, if the code is async by accident, make it complete now.`,
+              implementation.id,
+              draftContext4,
+              void 0,
+              { at: method2.name }
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/core/rules/conformance/route-coverage.ts
 function liesUnder2(path92, prefix) {
   return path92 === prefix || path92.startsWith(prefix + "/");
@@ -19758,7 +21184,7 @@ var init_route_coverage = __esm({
               const routes = code.factsAt(file).functionRoutes;
               return routes && Object.prototype.hasOwnProperty.call(routes, via) ? routes[via] : [];
             });
-            const draftContext3 = ctx.isComponentDraft(listener.id) || ctx.isComponentDraft(portal.id);
+            const draftContext4 = ctx.isComponentDraft(listener.id) || ctx.isComponentDraft(portal.id);
             const where = holders.map((file) => `"${file}"`).join(", ");
             if (read2.length === 0) {
               ctx.addIssue(
@@ -19766,7 +21192,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,
-                draftContext3,
+                draftContext4,
                 void 0,
                 { at: via }
               );
@@ -19791,7 +21217,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,
-                draftContext3,
+                draftContext4,
                 void 0,
                 { at: via, covers: undeclared }
               );
@@ -19803,7 +21229,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,
-                draftContext3,
+                draftContext4,
                 void 0,
                 { at: via, covers: unrouted }
               );
@@ -19920,7 +21346,7 @@ var init_export_conformance = __esm({
             }
           }
         }
-        for (const { implementation, method: method2, sourceFile, draftContext: draftContext3 } of ctx.implementationMethods()) {
+        for (const { implementation, method: method2, sourceFile, draftContext: draftContext4 } of ctx.implementationMethods()) {
           const handle = method2.exportedVia;
           if (!handle || !sourceFile) continue;
           const file = pathKey(sourceFile);
@@ -19935,7 +21361,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,
-            draftContext3
+            draftContext4
           );
         }
         for (const listener of ctx.components) {
@@ -20330,89 +21756,6 @@ var init_coupling_health = __esm({
   }
 });
 
-// src/core/rules/heuristic/signature-language-builtins.ts
-var LANGUAGE_MARKERS, signatureLanguageBuiltinsRule;
-var init_signature_language_builtins = __esm({
-  "src/core/rules/heuristic/signature-language-builtins.ts"() {
-    "use strict";
-    init_models();
-    LANGUAGE_MARKERS = {
-      rust: /* @__PURE__ */ new Set([
-        "u8",
-        "u16",
-        "u32",
-        "u64",
-        "u128",
-        "usize",
-        "i8",
-        "i16",
-        "i32",
-        "i64",
-        "i128",
-        "isize",
-        "f32",
-        "f64",
-        "vec",
-        "box",
-        "arc",
-        "rc",
-        "refcell",
-        "cell",
-        "mutex",
-        "rwlock",
-        "str"
-      ]),
-      typescript: /* @__PURE__ */ new Set(["any", "unknown", "never", "undefined", "promise", "record"]),
-      javascript: /* @__PURE__ */ new Set(["promise", "undefined"]),
-      python: /* @__PURE__ */ new Set(["dict", "tuple"]),
-      csharp: /* @__PURE__ */ new Set(["task"]),
-      go: /* @__PURE__ */ new Set(["chan", "rune"])
-    };
-    signatureLanguageBuiltinsRule = {
-      name: "signature-language-builtins",
-      judges: "design",
-      description: "Contracts must speak the declared target language: builtin types that unambiguously belong to another language family are flagged in method signatures (e.g. `usize` in a TypeScript system, `Promise` in a Rust one). Set targetLanguage on the system (L0) or override per subsystem (L1).",
-      codes: [
-        { code: "LANGUAGE_FOREIGN_BUILTIN", defaultSeverity: "warning", summary: "Signature uses a builtin from a different language family" }
-      ],
-      check(ctx) {
-        const markersFor = (family) => {
-          const base = LANGUAGE_MARKERS[family];
-          const extra = ctx.ext.languages[family]?.foreignBuiltins;
-          if (!extra?.length) return base;
-          return /* @__PURE__ */ new Set([...base ?? [], ...extra.map((s) => s.toLowerCase())]);
-        };
-        const families = [.../* @__PURE__ */ new Set([...Object.keys(LANGUAGE_MARKERS), ...Object.keys(ctx.ext.languages)])];
-        const scans = [];
-        for (const intf of ctx.interfaces) {
-          const comp = ctx.componentMap.get(intf.component);
-          const lang = ctx.targetLanguageFor(comp?.subsystem);
-          if (!lang) continue;
-          const ownMarkers = markersFor(lang);
-          if (!ownMarkers || ownMarkers.size === 0) continue;
-          const draft = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
-          for (const method2 of intf.methods) {
-            for (const ref of methodTypeRefs(method2)) scans.push({ intf, method: method2, ref, lang, ownMarkers, draft });
-          }
-        }
-        for (const scan of scans) {
-          const refLower = scan.ref.toLowerCase();
-          if (scan.ownMarkers.has(refLower)) continue;
-          const foreign = families.find((family) => family !== scan.lang && markersFor(family)?.has(refLower));
-          if (!foreign) continue;
-          ctx.addIssue(
-            "warning",
-            "LANGUAGE_FOREIGN_BUILTIN",
-            `Method "${scan.method.name}" on interface "${scan.intf.id}" uses "${scan.ref}", a ${foreign} builtin, but the target language here is ${scan.lang}. Use the ${scan.lang} equivalent so implementers generate idiomatic code.`,
-            scan.intf.id,
-            scan.draft
-          );
-        }
-      }
-    };
-  }
-});
-
 // src/core/rules/heuristic/narrative-language-constructs.ts
 function constructsOf(step) {
   const constructs = [
@@ -21413,6 +22756,9 @@ var init_repository = __esm({
     init_signature_sources();
     init_signature_types();
     init_signature_text();
+    init_type_expressions();
+    init_enum_types();
+    init_named_scalar_types();
     init_public_surface_binding();
     init_public_surface_consumers();
     init_public_surface_declared_type();
@@ -21465,6 +22811,7 @@ var init_repository = __esm({
     init_pack_resolution();
     init_pack_reproducibility();
     init_pack_requirements();
+    init_pack_deprecations();
     init_dependency_cycles();
     init_dispatch_table_bindings();
     init_dispatch_step_routing();
@@ -21493,13 +22840,14 @@ var init_repository = __esm({
     init_integration_sim_coverage();
     init_type_realization();
     init_type_shape();
+    init_enum_values();
     init_param_conformance();
+    init_async_conformance();
     init_route_coverage();
     init_unclaimed_source();
     init_export_conformance();
     init_carried_debt();
     init_coupling_health();
-    init_signature_language_builtins();
     init_narrative_language_constructs();
     init_technology_binding();
     init_technology_boundaries();
@@ -21530,6 +22878,11 @@ var init_repository = __esm({
       signatureSourcesRule,
       signatureTypesRule,
       signatureTextRule,
+      // The type grammar beside the signatures: how each stored type position is
+      // spelled, then what an enum and a named scalar may hold.
+      typeExpressionsRule,
+      enumTypesRule,
+      namedScalarTypesRule,
       // 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
@@ -21694,14 +23047,17 @@ var init_repository = __esm({
       // others named.
       typeRealizationRule,
       typeShapeRule,
+      // An enum's values beside the data shape, and whether the call completes
+      // later beside the signature: the same readings, of their own facts.
+      enumValuesRule,
       paramConformanceRule,
+      asyncConformanceRule,
       routeCoverageRule,
       unclaimedSourceRule,
       exportConformanceRule,
       couplingRule,
-      // Target-language fit in two questions: what a CONTRACT may name, and what
-      // a NARRATIVE may describe.
-      signatureLanguageBuiltinsRule,
+      // Target-language fit: what a NARRATIVE may describe. What a contract may
+      // name is the neutral type grammar's (type-expressions), not a language's.
       narrativeLanguageConstructsRule,
       // The declaration before the consequences: which stereotype may bind a
       // technology at all, then where its name may appear.
@@ -21725,6 +23081,9 @@ var init_repository = __esm({
       // stage): configuration too, and the family run cannot judge a member against
       // a requirement that does not parse.
       packRequirementsRule,
+      // The fields a loaded pack still declares that wairon has deprecated: about
+      // the packs' configuration too, and only ever a notice.
+      packDeprecationsRule,
       // MUST run last, in this order: each audits what the earlier rules did
       // with a declared exception. The debt register first (which carried
       // findings the conformance family actually matched), then the allows
@@ -21871,6 +23230,9 @@ function walkExact(ts, sourceText, fileName) {
   const typeShapes = /* @__PURE__ */ new Map();
   const functionParams = /* @__PURE__ */ new Map();
   const functionRoutes = /* @__PURE__ */ new Map();
+  const asyncFunctions = [];
+  const enumValues = /* @__PURE__ */ new Map();
+  const aliasTypes = /* @__PURE__ */ new Map();
   const mutableBindings = /* @__PURE__ */ new Set();
   const schemaConstants = /* @__PURE__ */ new Map();
   const derivedAliases = [];
@@ -22085,6 +23447,48 @@ function walkExact(ts, sourceText, fileName) {
     if (fn.body) walk2(fn.body, []);
     return routes;
   };
+  const completesLater = (fn) => {
+    const mods = fn.modifiers;
+    if (mods?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) return true;
+    const returned = fn.type;
+    return !!returned && ts.isTypeReferenceNode(returned) && ts.isIdentifier(returned.typeName) && returned.typeName.text === "Promise";
+  };
+  const stringLiteralUnion = (type) => {
+    const members = ts.isUnionTypeNode(type) ? [...type.types] : [type];
+    const values = [];
+    for (const member of members) {
+      if (!ts.isLiteralTypeNode(member) || !ts.isStringLiteral(member.literal)) return void 0;
+      values.push(member.literal.text);
+    }
+    return values;
+  };
+  const zodEnumValues = (expression) => {
+    const strings = (array, hops) => {
+      let node2 = array;
+      while (node2 && (ts.isAsExpression(node2) || ts.isParenthesizedExpression(node2) || ts.isSatisfiesExpression(node2))) node2 = node2.expression;
+      if (node2 && ts.isIdentifier(node2) && hops > 0) return strings(schemaConstants.get(node2.text), hops - 1);
+      if (!node2 || !ts.isArrayLiteralExpression(node2) || node2.elements.length === 0) return void 0;
+      const values = [];
+      for (const element of node2.elements) {
+        if (!ts.isStringLiteral(element) && !ts.isNoSubstitutionTemplateLiteral(element)) return void 0;
+        values.push(element.text);
+      }
+      return 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 === "enum") return strings(node.arguments[0], 1);
+        node = callee;
+      } else if (ts.isPropertyAccessExpression(node)) {
+        node = node.expression;
+      } else break;
+    }
+    return void 0;
+  };
   const visit = (node) => {
     const fnName = namedFunctionName(node);
     if (fnName && node.body) {
@@ -22096,6 +23500,7 @@ function walkExact(ts, sourceText, fileName) {
       const signatures = functionParams.get(fnName) ?? [];
       signatures.push(declaredParameters(node));
       functionParams.set(fnName, signatures);
+      if (completesLater(node)) asyncFunctions.push(fnName);
       const routes = collectRoutes(node);
       if (routes.size > 0) {
         const known = functionRoutes.get(fnName) ?? /* @__PURE__ */ new Map();
@@ -22118,10 +23523,17 @@ function walkExact(ts, sourceText, fileName) {
     } else if (ts.isTypeAliasDeclaration(node)) {
       if (ts.isTypeLiteralNode(node.type)) recordDeclaredShape(node.name.text, node.type.members, false);
       else {
+        if (!aliasTypes.has(node.name.text)) aliasTypes.set(node.name.text, node.type.getText(sf));
         const constant = inferredSchemaConstant(node.type);
         if (constant) derivedAliases.push({ name: node.name.text, constant });
+        const literals = stringLiteralUnion(node.type);
+        if (literals) enumValues.set(node.name.text, literals);
       }
     }
+    if (ts.isEnumDeclaration(node)) {
+      const values = node.members.map((member) => member.initializer && (ts.isStringLiteral(member.initializer) || ts.isNoSubstitutionTemplateLiteral(member.initializer)) ? member.initializer.text : void 0);
+      if (values.length > 0 && values.every((v) => v !== void 0)) enumValues.set(node.name.text, values);
+    }
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && !schemaConstants.has(node.name.text)) {
       schemaConstants.set(node.name.text, node.initializer);
     }
@@ -22243,8 +23655,17 @@ function walkExact(ts, sourceText, fileName) {
     if (!fields) continue;
     typeShapes.set(alias.name, { origin: "derived", fields, methods: [] });
   }
+  for (const [name, initializer] of schemaConstants) {
+    const values = zodEnumValues(initializer);
+    if (values) enumValues.set(name, values);
+  }
+  for (const alias of derivedAliases) {
+    if (enumValues.has(alias.name)) continue;
+    const values = enumValues.get(alias.constant);
+    if (values && schemaConstants.has(alias.constant)) enumValues.set(alias.name, values);
+  }
   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 };
+  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, complexity, calls, importBindings, typeOnlyBindings, fieldTypes, localTypes, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
 }
 function resolveRelativeModule(fromFile, specifier) {
   if (!specifier.startsWith(".")) return null;
@@ -22323,7 +23744,7 @@ function walkDeclaredRoots(roots, exclude, projectRoot2) {
   const record2 = (absolute) => {
     const key = pathKey(path20.relative(projectRoot2, absolute));
     if (seen.has(key) || isExcluded(key)) return;
-    if (!EXTENSION_LANGUAGE[path20.extname(key).toLowerCase()]) return;
+    if (!languageOfSourcePath(key)) return;
     seen.add(key);
     found.push(key);
   };
@@ -22405,7 +23826,7 @@ function buildCodeModel(implementations, types, projectRoot2, sourceRoots = [],
       continue;
     }
     const text3 = buffer.toString("utf8");
-    const language = EXTENSION_LANGUAGE[path20.extname(sourcePath).toLowerCase()];
+    const language = languageOfSourcePath(sourcePath);
     let analyzed;
     if (language === "typescript" || language === "javascript") {
       const ts = resolveTypeScript(projectRoot2);
@@ -22433,6 +23854,9 @@ function buildCodeModel(implementations, types, projectRoot2, sourceRoots = [],
             typeShapes: Object.fromEntries(facts.typeShapes),
             functionParams: Object.fromEntries(facts.functionParams),
             functionRoutes: Object.fromEntries([...facts.functionRoutes].map(([k, v]) => [k, [...v.values()]])),
+            asyncFunctions: [...facts.asyncFunctions],
+            enumValues: Object.fromEntries(facts.enumValues),
+            aliasTypes: Object.fromEntries(facts.aliasTypes),
             topLevelMutableBindings: [...facts.mutableBindings],
             reexportOnly: facts.reexportOnly
           };
@@ -22585,7 +24009,7 @@ function findTestsReferencing(methods, projectRoot2, testRoots) {
   }
   return found;
 }
-var fs15, path20, import_module2, EXTENSION_LANGUAGE, C_FAMILY_COMMENTS, NAMED_IMPORT_BINDINGS_RE, JS_PATTERNS, LANGUAGE_PATTERNS, PATTERN_ANALYSIS_MAX_BYTES, IDENTIFIER_RE, STRING_RE, tsResolutionCache, TS_RESOLUTION_RETRY_MS, IMPORT_FROM_RE, DYNAMIC_IMPORT_RE, IDENTIFIER_ONLY_RE, NAMED_REEXPORT_RE, STAR_REEXPORT_RE;
+var fs15, path20, import_module2, C_FAMILY_COMMENTS, NAMED_IMPORT_BINDINGS_RE, JS_PATTERNS, LANGUAGE_PATTERNS, PATTERN_ANALYSIS_MAX_BYTES, IDENTIFIER_RE, STRING_RE, tsResolutionCache, TS_RESOLUTION_RETRY_MS, IMPORT_FROM_RE, DYNAMIC_IMPORT_RE, IDENTIFIER_ONLY_RE, NAMED_REEXPORT_RE, STAR_REEXPORT_RE;
 var init_source_analysis = __esm({
   "src/core/source-analysis.ts"() {
     "use strict";
@@ -22593,30 +24017,6 @@ var init_source_analysis = __esm({
     path20 = __toESM(require("path"));
     import_module2 = require("module");
     init_models();
-    EXTENSION_LANGUAGE = {
-      ".ts": "typescript",
-      ".tsx": "typescript",
-      ".mts": "typescript",
-      ".cts": "typescript",
-      ".js": "javascript",
-      ".jsx": "javascript",
-      ".mjs": "javascript",
-      ".cjs": "javascript",
-      ".py": "python",
-      ".rs": "rust",
-      ".go": "go",
-      ".cs": "csharp",
-      ".java": "java",
-      ".c": "c",
-      ".h": "c",
-      ".cpp": "cpp",
-      ".cc": "cpp",
-      ".hpp": "cpp",
-      ".rb": "ruby",
-      ".php": "php",
-      ".kt": "kotlin",
-      ".swift": "swift"
-    };
     C_FAMILY_COMMENTS = { lineComments: ["//"], blockComments: [["/*", "*/"]] };
     NAMED_IMPORT_BINDINGS_RE = /\bimport\s*\{([^}]*)\}/g;
     JS_PATTERNS = {
@@ -22920,7 +24320,7 @@ function buildRuleContext(opts) {
   const authoredTypeRefs = new Set((family?.authoredReferences ?? []).filter((r) => r.position === "type" && r.binding !== "local" && memberOf(r.specId) === void 0).map((r) => r.authored));
   const isTypeResolved = (ref, generics) => {
     const refLower = ref.toLowerCase();
-    if (BUILTIN_TYPES.has(refLower)) return true;
+    if (isTypeVocabulary(refLower)) return true;
     if (generics.has(refLower)) return true;
     if (ownTypes.some((spec) => typeMatchesRef(spec, ref))) return true;
     const [first, ...rest] = ref.split(/::|\./);
@@ -23134,7 +24534,7 @@ function buildRuleContext(opts) {
     }
     return projectNaming;
   };
-  const isBuiltinType = (ref) => BUILTIN_TYPES.has(ref.toLowerCase());
+  const isBuiltinType = (ref) => isTypeVocabulary(ref);
   const getRuleSeverity = (ruleCode, defaultSeverity, isDraftContext, subsystemId) => {
     if (rules?.sddRuleSeverity?.[ruleCode]) {
       return rules.sddRuleSeverity[ruleCode];
@@ -23312,7 +24712,7 @@ function buildRuleContext(opts) {
     documentationConfigFor,
     namingConfigFor,
     isBuiltinType,
-    ext: { profiles: extensions.profiles, languages: extensions.languages, patterns: extensions.patterns, guarantees: extensions.guarantees, assertions: extensions.assertions, packSelections: opts.packSelections ?? [], selectionFailures: extensions.selectionFailures ?? [], packRequirements: opts.packRequirements ?? [] },
+    ext: { profiles: extensions.profiles, languages: extensions.languages, patterns: extensions.patterns, guarantees: extensions.guarantees, assertions: extensions.assertions, packSelections: opts.packSelections ?? [], selectionFailures: extensions.selectionFailures ?? [], packRequirements: opts.packRequirements ?? [], deprecations: extensions.deprecations ?? [] },
     variants: opts.variants ?? [],
     surfaceSnapshots,
     ...opts.projectIdentity ? { projectIdentity: opts.projectIdentity } : {},
@@ -23321,6 +24721,7 @@ function buildRuleContext(opts) {
     ...opts.projectFamily ? { projectFamily: opts.projectFamily } : {},
     ...opts.exportUsages ? { exportUsages: opts.exportUsages } : {},
     ...opts.signatureFacts ? { signatureFacts: opts.signatureFacts } : {},
+    ...opts.typeSpellingFacts ? { typeSpellingFacts: opts.typeSpellingFacts } : {},
     pinnedExternals,
     codeModel: opts.codeModel ?? emptyCodeModel(),
     roundTripIssues: opts.roundTripIssues,
@@ -23829,7 +25230,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
   let extensions;
   let treatAllAsComplete = false;
   let packSelections;
-  if (rulesOrOptions && ("scopeSubsystem" in rulesOrOptions || "recursive" in rulesOrOptions || "rules" in rulesOrOptions || "projectType" in rulesOrOptions || "extensions" in rulesOrOptions || "treatAllAsComplete" in rulesOrOptions || "family" in rulesOrOptions || "packSelections" in rulesOrOptions)) {
+  if (rulesOrOptions && ("scopeSubsystem" in rulesOrOptions || "memberDepth" in rulesOrOptions || "rules" in rulesOrOptions || "projectType" in rulesOrOptions || "extensions" in rulesOrOptions || "treatAllAsComplete" in rulesOrOptions || "family" in rulesOrOptions || "packSelections" in rulesOrOptions)) {
     const opts = rulesOrOptions;
     rules = opts.rules;
     projectType = opts.projectType ?? "backend";
@@ -23839,7 +25240,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
     packSelections = opts.packSelections;
   }
   extensions ??= loadProjectExtensions();
-  scanAllSpecs({ recursive: true });
+  scanAllSpecs();
   const issues = [];
   clearLoaderIssues();
   const boundConfig = boundConfiguration();
@@ -23917,6 +25318,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
     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 typeSpellings = typeSpellingFacts();
     const ctx = buildRuleContext({
       system,
       subsystems,
@@ -23939,6 +25341,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
       projectFamily: family,
       exportUsages,
       signatureFacts: signatures,
+      typeSpellingFacts: typeSpellings,
       pinnedExternals,
       // By-name selections only: a legacy path ref pins nothing to check. A dry
       // run supplies its candidate's; otherwise the stored ones.
@@ -24058,7 +25461,12 @@ function judgePartAlone(config, scopeSubsystem) {
     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(
+  const ownTypeSpellings = typeSpellingFacts();
+  const partTypeSpellings = {
+    respellings: ownTypeSpellings.respellings.filter((r) => isOwn(r.specId)),
+    problems: ownTypeSpellings.problems.filter((p) => p.specId === void 0 || isOwn(p.specId))
+  };
+  const resolved = resolveSignatures(
     [...own.interfaces, ...context.interfaces],
     [...own.components, ...context.components],
     [...own.types, ...context.types]
@@ -24097,6 +25505,7 @@ function judgePartAlone(config, scopeSubsystem) {
     projectFamily: graph(),
     exportUsages: [],
     signatureFacts: partSignatures,
+    typeSpellingFacts: partTypeSpellings,
     pinnedExternals: [],
     packSelections: packs.filter((p) => typeof p !== "string"),
     packRequirements: [],
@@ -24184,7 +25593,7 @@ function builtinProjectKinds() {
   return [...PROJECT_KINDS];
 }
 function computeGateStateId() {
-  scanAllSpecs({ recursive: true });
+  scanAllSpecs();
   const content = computeOwnStateId();
   const extensions = loadProjectExtensions();
   let gate = {};
@@ -24873,16 +26282,16 @@ function bindReferencedMembers(node, root) {
       out.push({ ...base, sourceKind: "hosted", hosted: member.source.hosted });
       continue;
     }
-    const located = root.referenced.find((r) => r.alias === member.alias);
+    const located2 = root.referenced.find((r) => r.alias === member.alias);
     const sourceKind = member.storage === "git" ? "git" : "path";
-    const directory = located?.directory ?? (member.storage === "path" ? path22.resolve(node.directory, member.source.path ?? "") : void 0);
-    const commit3 = located?.commit ?? member.source.commit;
+    const directory = located2?.directory ?? (member.storage === "path" ? path22.resolve(node.directory, member.source.path ?? "") : void 0);
+    const commit3 = located2?.commit ?? member.source.commit;
     out.push({
       ...base,
       sourceKind,
       ...directory !== void 0 ? { directory } : {},
       ...commit3 !== void 0 ? { commit: commit3 } : {},
-      ...located?.availability === "unavailable" ? { problem: located.reason } : {}
+      ...located2?.availability === "unavailable" ? { problem: located2.reason } : {}
     });
   }
   return out;
@@ -25720,7 +27129,8 @@ function emptyIndex() {
       type: {},
       group: {}
     },
-    signatures: { sources: [], staleTexts: [] }
+    signatures: { sources: [], staleTexts: [] },
+    typeSpellings: emptyTypeSpellingFacts()
   };
 }
 function isWithin(dir, file) {
@@ -26075,7 +27485,7 @@ function bareRawReferences(kind, spec) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const add2 = (position, value, generics = /* @__PURE__ */ new Set()) => {
-    if (!value || value.includes("::") || BUILTIN_TYPES.has(value.toLowerCase()) || generics.has(value.toLowerCase())) return;
+    if (!value || value.includes("::") || isTypeVocabulary(value) || generics.has(value.toLowerCase())) return;
     const k = `${position}|${value}`;
     if (seen.has(k)) return;
     seen.add(k);
@@ -26495,6 +27905,49 @@ function bindImport(raw, suppliers, p) {
     }
   };
 }
+function typePositionText(spec, at) {
+  const [head2, name, member, param] = at.split(".");
+  const named2 = (list2, key) => Array.isArray(list2) ? list2.find((x) => x?.name === key) : void 0;
+  if (head2 === "returns") return spec.returns;
+  if (head2 === "params") return named2(spec.params, name)?.type;
+  if (head2 === "fields") return named2(spec.fields, name)?.type;
+  if (head2 !== "methods") return void 0;
+  const method2 = named2(spec.methods, name);
+  return member === "returns" ? method2?.returns : named2(method2?.params, param)?.type;
+}
+function writtenSignatureTexts(raws) {
+  const texts = /* @__PURE__ */ new Map();
+  const record2 = (kind, specId, methods) => {
+    for (const m of methods) {
+      if (m.signatureFrom !== void 0) continue;
+      const derived = deriveMethodSignature(m);
+      if (derived !== void 0) texts.set(`${kind}|${specId}|${m.name}`, derived);
+    }
+  };
+  for (const raw of raws) {
+    for (const intf of raw.index.interfaces) record2("interface", intf.id, intf.methods ?? []);
+    for (const type of raw.index.types) record2("type", type.id, type.methods ?? []);
+  }
+  return texts;
+}
+function canonicalizeRootTypes(raws) {
+  const facts = emptyTypeSpellingFacts();
+  for (const raw of raws) {
+    raw.index.interfaces = raw.index.interfaces.map((intf) => {
+      const read2 = interfaceCanonicalTypes(intf);
+      facts.respellings.push(...read2.respellings);
+      facts.problems.push(...read2.problems);
+      return read2.spec;
+    });
+    raw.index.types = raw.index.types.map((type) => {
+      const read2 = typeCanonicalTypes(type);
+      facts.respellings.push(...read2.respellings);
+      facts.problems.push(...read2.problems);
+      return read2.spec;
+    });
+  }
+  return facts;
+}
 function bindRootReferences(raw, raws, readables) {
   const bound2 = /* @__PURE__ */ new Map();
   for (const p of raw.pending) {
@@ -26587,7 +28040,8 @@ 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";
+  if (raw.kind === "signature" || raw.kind === "enum") return "type";
+  if ("kind" in raw && typeof raw.holds === "string") return "type";
   return void 0;
 }
 function rewriteSpecRefs(raw, remap) {
@@ -26883,12 +28337,12 @@ function pairSteps(before, after) {
     const gapBefore = before.slice(oi + 1, oj).map((step, k) => ({ step, at: oi + 1 + k }));
     const gapAfter = after.slice(ni + 1, nj).map((step, k) => ({ step, at: ni + 1 + k }));
     const similar = commonRun(gapBefore, gapAfter, (x, y) => recognisablySame(x.step, y.step)).map(([x, y]) => [gapBefore[x].at, gapAfter[y].at]);
-    const inner = [[oi, ni], ...similar, [oj, nj]];
-    for (let k = 0; k < inner.length - 1; k++) {
-      const [a0, b0] = inner[k];
-      const [a1, b1] = inner[k + 1];
+    const inner2 = [[oi, ni], ...similar, [oj, nj]];
+    for (let k = 0; k < inner2.length - 1; k++) {
+      const [a0, b0] = inner2[k];
+      const [a1, b1] = inner2[k + 1];
       if (a1 - a0 === b1 - b0) for (let d = 1; d < a1 - a0; d++) pairs.push([a0 + d, b0 + d]);
-      if (k < inner.length - 2) pairs.push(inner[k + 1]);
+      if (k < inner2.length - 2) pairs.push(inner2[k + 1]);
     }
     if (g < bounds2.length - 2) pairs.push(bounds2[g + 1]);
   }
@@ -27173,6 +28627,7 @@ function moveChangeReports(edits, dryRun) {
     changes,
     ineffective: [],
     notices: [],
+    respellings: [],
     testsToRevisit: [],
     summary: edit4.before === null ? `${dryRun ? "Would create" : "Created"} ${edit4.kind} "${edit4.id}" to receive the moved methods.` : `${dryRun ? "Would move" : "Moved"} into ${edit4.kind} "${edit4.id}": ${changes.length} change${changes.length === 1 ? "" : "s"}.`
   }));
@@ -27462,6 +28917,9 @@ function snapshotSpecFiles() {
 function signatureFacts() {
   return current().signatureFacts();
 }
+function typeSpellingFacts() {
+  return current().typeSpellingFacts();
+}
 function findLegacySpecFiles() {
   return current().findLegacySpecFiles();
 }
@@ -27559,7 +29017,7 @@ var init_specs2 = __esm({
     SpecWorkspace = class {
       constructor(rootDir) {
         this.cachedIndex = null;
-        this.cachedRecursive = null;
+        this.cachedDepth = null;
         this.cachedSpecDirs = [];
         this.cachedSignature = null;
         this.lastSignatureCheckMs = 0;
@@ -27588,7 +29046,7 @@ var init_specs2 = __esm({
       }
       invalidate() {
         this.cachedIndex = null;
-        this.cachedRecursive = null;
+        this.cachedDepth = null;
         this.cachedSpecDirs = [];
         this.cachedConfigFiles = [];
         this.cachedRoots = [];
@@ -27603,8 +29061,8 @@ var init_specs2 = __esm({
       // Scanning
       // -------------------------------------------------------------------------
       scanAll(options) {
-        const recursive = options?.recursive ?? true;
-        if (this.cachedIndex && this.cachedRecursive === recursive) {
+        const maxDepth = options?.memberDepth ?? Infinity;
+        if (this.cachedIndex && this.cachedDepth === maxDepth) {
           const now = Date.now();
           if (now - this.lastSignatureCheckMs <= SIGNATURE_TTL_MS) return this.cachedIndex;
           this.lastSignatureCheckMs = now;
@@ -27612,10 +29070,9 @@ var init_specs2 = __esm({
           this.invalidate();
         }
         this.loaderIssues = [];
-        this.cachedRecursive = recursive;
+        this.cachedDepth = maxDepth;
         this.scanVisitedSpecDirs = [];
         this.scanVisitedConfigFiles = [];
-        const maxDepth = typeof recursive === "number" ? recursive : recursive ? Infinity : 0;
         const scan = this.scanFamily(maxDepth);
         this.cachedIndex = scan.index;
         this.cachedRoots = scan.raws.map((raw) => raw.record);
@@ -27656,6 +29113,8 @@ var init_specs2 = __esm({
         raws.forEach((raw) => this.bindAliases(raw, raws));
         const readables = raws.map((raw) => readableOf(raw));
         resolveFamilyTables(raws);
+        const writtenTexts = writtenSignatureTexts(raws);
+        const typeSpellings = canonicalizeRootTypes(raws);
         raws.forEach((raw) => bindRootReferences(raw, raws, readables));
         const index = emptyIndex();
         for (const raw of raws) {
@@ -27670,7 +29129,11 @@ var init_specs2 = __esm({
         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;
+        index.signatures = {
+          ...signatures.facts,
+          staleTexts: signatures.facts.staleTexts.filter((stale) => writtenTexts.get(`${stale.kind}|${stale.specId}|${stale.method}`) !== stale.stored)
+        };
+        index.typeSpellings = typeSpellings;
         return { index, raws, readables };
       }
       /**
@@ -27816,26 +29279,26 @@ var init_specs2 = __esm({
           decl.kind = "project";
           return;
         }
-        const located = this.memberRoot(raw, decl);
-        if (located === null) return;
-        if ("unavailable" in located) {
+        const located2 = this.memberRoot(raw, decl);
+        if (located2 === null) return;
+        if ("unavailable" in located2) {
           if (asserted === "project" || pinnedAsMember(raw.dir, decl.alias)) {
             decl.kind = "project";
-            raw.record.referenced.push({ alias: decl.alias, storage: decl.storage, partOf: null, subsystems: [], specIds: [], availability: "unavailable", reason: located.unavailable });
+            raw.record.referenced.push({ alias: decl.alias, storage: decl.storage, partOf: null, subsystems: [], specIds: [], availability: "unavailable", reason: located2.unavailable });
             return;
           }
           decl.kind = "part";
-          this.memberProblem(raw, "part-unavailable", decl.alias, located.unavailable);
-          raw.record.parts.push({ alias: decl.alias, storage: decl.storage, partOf: null, subsystems: [], specIds: [], availability: "unavailable", reason: located.unavailable });
+          this.memberProblem(raw, "part-unavailable", decl.alias, located2.unavailable);
+          raw.record.parts.push({ alias: decl.alias, storage: decl.storage, partOf: null, subsystems: [], specIds: [], availability: "unavailable", reason: located2.unavailable });
           return;
         }
-        const kind = projectContentAt(located.dir) ? "project" : "part";
+        const kind = projectContentAt(located2.dir) ? "project" : "part";
         decl.kind = kind;
         if (asserted !== void 0 && asserted !== kind) {
           this.memberProblem(raw, "kind-mismatch", decl.alias, `the member "${decl.alias}" is asserted \`as: ${asserted}\`, but its content makes it a ${kind}: ${kind === "project" ? "its tree declares an id, holds an L0 or carries a lock \u2014 drop the `as`, or remove that content with `wairon member demote`" : "its tree declares no id, holds no L0 and carries no lock \u2014 drop the `as`, or create the project content with `wairon member promote`"}`);
         }
-        if (kind === "part") this.readPart(raw, decl, located.dir, located.commit);
-        else if (decl.storage !== "contained") this.recordReferenced(raw, decl, located.dir, located.commit);
+        if (kind === "part") this.readPart(raw, decl, located2.dir, located2.commit);
+        else if (decl.storage !== "contained") this.recordReferenced(raw, decl, located2.dir, located2.commit);
       }
       /**
        * A referenced project member (stage 8): where its root is — the sibling
@@ -28734,7 +30197,8 @@ var init_specs2 = __esm({
        * the owning project.
        */
       prepareInterfaceForWrite(spec) {
-        const stored = { ...spec, methods: (spec.methods ?? []).map((m) => storedMethodSignature(m)) };
+        const canonical3 = interfaceCanonicalTypes(spec).spec;
+        const stored = { ...canonical3, methods: (canonical3.methods ?? []).map((m) => storedMethodSignature(m)) };
         return this.relativizeSpec("interface", stored);
       }
       prepareImplementationForWrite(spec, carry = true) {
@@ -28745,9 +30209,14 @@ 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. */
+      /**
+       * A type written in its stored form — every type position canonical (one
+       * that is not canonical written as it stands), every params-bearing method's
+       * text derived from them — relative to the owning project.
+       */
       prepareTypeForWrite(spec) {
-        const stored = { ...spec, methods: (spec.methods ?? []).map((m) => storedTypeMethod(m)) };
+        const canonical3 = typeCanonicalTypes(spec).spec;
+        const stored = { ...canonical3, methods: (canonical3.methods ?? []).map((m) => storedTypeMethod(m)) };
         return this.relativizeSpec("type", stored);
       }
       prepareGroupForWrite(spec) {
@@ -28958,7 +30427,7 @@ var init_specs2 = __esm({
         if (!pathExists(p)) return null;
         try {
           const raw = readSpecFile(p);
-          return resolveTree([InterfaceSpecSchema.parse(raw)], index.components, index.types).interfaces[0];
+          return resolveTree([interfaceCanonicalTypes(InterfaceSpecSchema.parse(raw)).spec], index.components, index.types).interfaces[0];
         } catch (e) {
           this.loaderIssues.push({
             severity: "error",
@@ -29534,6 +31003,33 @@ var init_specs2 = __esm({
         index.listProjectRoots();
         return this.cachedIndex.signatures;
       }
+      /**
+       * A delta's merged spec with every type position canonical, IN PLACE (an
+       * interface or a type; nothing else holds type positions). Answers the
+       * respellings the write applies: each alias the merge holds — written by the
+       * delta — and each alias the stored file still holds at a position the merge
+       * kept, which the scan recorded and the save rewrites with it. A position
+       * that is not canonical stays as written.
+       */
+      canonicalizeMerged(kind, merged) {
+        if (kind !== "interface" && kind !== "type") return [];
+        const read2 = kind === "interface" ? interfaceCanonicalTypes(merged) : typeCanonicalTypes(merged);
+        Object.assign(merged, read2.spec);
+        const respelled = new Set(read2.respellings.map((r) => r.path));
+        const fromFile = this.scanAll().typeSpellings.respellings.filter((r) => r.specId === merged.id && r.kind === kind && !respelled.has(r.path) && typePositionText(merged, r.path) === r.stored);
+        return [...read2.respellings, ...fromFile];
+      }
+      /**
+       * ispec_index.typeSpellingFacts — what the current scan's type
+       * canonicalisation recorded: every stored type position that is an alias of
+       * its canonical spelling, and every one that is not canonical at all. Read
+       * from the cached scan, rescanning first when the tree changed.
+       */
+      typeSpellingFacts() {
+        const index = this;
+        index.listProjectRoots();
+        return this.cachedIndex.typeSpellings;
+      }
       snapshotSpecFiles() {
         const index = this.scanAll();
         const snapshot = /* @__PURE__ */ new Map();
@@ -30144,6 +31640,7 @@ var init_specs2 = __esm({
         const qualifiedDelta = qualifyDeltaRefs(mergeableDelta);
         const mergedResult = mergeDelta(result, qualifiedDelta);
         for (const field of unsetFields) delete mergedResult[field];
+        const respellings = this.canonicalizeMerged(kind, mergedResult);
         deriveMergedTexts(kind, mergedResult);
         const withDefaults = deltaSchema.safeParse(mergedResult);
         if (withDefaults.success) {
@@ -30184,6 +31681,7 @@ var init_specs2 = __esm({
             changes,
             ineffective,
             notices,
+            respellings: [],
             testsToRevisit: [],
             summary: `No change to ${kind} "${id}" \u2014 the delta matches what is stored, so nothing ${dryRun ? "would be" : "was"} written.`
           };
@@ -30200,6 +31698,7 @@ var init_specs2 = __esm({
             changes,
             ineffective,
             notices,
+            respellings,
             testsToRevisit: [],
             ...stripped.length ? { strippedKeys: stripped } : {},
             summary: `Dry run on ${kind} "${id}": ${changes.length} change${changes.length === 1 ? "" : "s"} would be made. Nothing was written.`
@@ -30218,6 +31717,7 @@ var init_specs2 = __esm({
           changes,
           ineffective,
           notices,
+          respellings,
           // The store never searches for tests: it holds the tree and knows
           // nothing about the rule engine that reads code. The GATED write above
           // it fills this in, which is also the only write path a human drives.
@@ -33579,6 +35079,19 @@ function composeAgentBrief(agentId) {
 ## Project guidance
 
 ${guidance.trim()}
+`;
+  }
+  const language = implementationLanguage(record2);
+  const dialect = language ? typeDialectFor(language) : null;
+  const typeMapping = dialect ? dialect.mappingLines() : void 0;
+  if (typeMapping) {
+    instructions = `${instructions.trimEnd()}
+
+## Types in ${language}
+
+Contracts speak wairon's neutral type grammar; write each type in ${language} as:
+
+${typeMapping.map((line2) => `- ${line2}`).join("\n")}
 `;
   }
   const profile = deriveExecutionProfile(record2);
@@ -33592,10 +35105,28 @@ ${guidance.trim()}
     readPaths: record2.readPaths,
     instructions,
     variantGuidance: record2.variantGuidance || void 0,
+    ...typeMapping ? { typeMapping } : {},
     profile: budget ? profile : void 0,
     budget
   };
 }
+function implementationLanguage(record2) {
+  const owned = new Set(record2.ownedPaths);
+  const implementations = loadImplementationSpecs().filter((impl) => implementationSourceFiles(impl).some((file) => owned.has(file)));
+  for (const impl of implementations) {
+    for (const technology of impl.technologies ?? []) {
+      const name = typeof technology === "string" ? technology : technology.name;
+      if (typeDialectFor(name)) return name.toLowerCase();
+    }
+  }
+  for (const impl of implementations) {
+    for (const file of implementationSourceFiles(impl)) {
+      const language = languageOfSourcePath(file);
+      if (language) return language;
+    }
+  }
+  return void 0;
+}
 function memberHop(agentId) {
   const at = agentId.indexOf("::");
   if (at < 0) return null;
@@ -33641,6 +35172,8 @@ var init_agent_resolver = __esm({
     init_budget_policy();
     init_specs2();
     init_specs();
+    init_code_model();
+    init_type_dialects();
     init_variants();
     projectFilesCache = /* @__PURE__ */ new Map();
     UnknownAgentError = class extends WaironError {
@@ -36845,7 +38378,6 @@ var require_dist = __commonJS({
         "# languages:",
         "#   rust:",
         "#     unsupportedFlow: {}",
-        "#     foreignBuiltins: []",
         "languages: {}",
         "",
         "# Reusable, versioned architecture patterns:",
@@ -37072,12 +38604,12 @@ var require_dist = __commonJS({
       const suggestedFileName = `${sealed.name}-${sealed.version}.wpack`;
       return { archive: archiveBytes, info, suggestedFileName };
     }
-    function inspectArchive3(archiveBytes) {
-      const entries = listEntries(archiveBytes);
+    function inspectArchive3(archive) {
+      const entries = listEntries(archive);
       if (!entries.some((entry) => entry.path === ENVELOPE_FILENAME)) {
         throw new Error("not a .wpack archive (missing wairon-pack.yaml envelope)");
       }
-      const envelopeBytes = inflateEntry(archiveBytes, ENVELOPE_FILENAME);
+      const envelopeBytes = inflateEntry(archive, ENVELOPE_FILENAME);
       const manifest = parseManifest(decode(envelopeBytes));
       const compatible = checkCompatibility(manifest, SDK_VERSION);
       const fileEntries = entries.filter((entry) => entry.kind === "file");
@@ -37095,13 +38627,13 @@ var require_dist = __commonJS({
       if (manifest.minWaironVersion !== void 0) info.minWaironVersion = manifest.minWaironVersion;
       return info;
     }
-    function extractPack3(archiveBytes, destDir, limits) {
+    function extractPack3(archive, destDir, limits) {
       const effectiveLimits = limits === void 0 ? defaultLimits() : limits;
-      const entries = listEntries(archiveBytes);
+      const entries = listEntries(archive);
       const plan7 = planExtraction(entries, effectiveLimits);
       const files = [];
       for (const approvedPath of plan7.paths) {
-        const contents = inflateEntry(archiveBytes, approvedPath);
+        const contents = inflateEntry(archive, approvedPath);
         files.push({ path: approvedPath, contents });
       }
       const envelope = files.find((file) => file.path === ENVELOPE_FILENAME);
@@ -37158,28 +38690,28 @@ var require_dist = __commonJS({
       const suggestedFileName = `${slugify2(projectName)}.waitree`;
       return { archive: archiveBytes, manifest: sealed, suggestedFileName, fileCount: files.length };
     }
-    function inspectTreeArchive3(archiveBytes) {
-      const entries = listEntries(archiveBytes);
+    function inspectTreeArchive3(archive) {
+      const entries = listEntries(archive);
       if (!entries.some((entry) => entry.path === TREE_ENVELOPE_FILENAME)) {
         throw new Error("not a .waitree archive (missing wairon-tree.yaml envelope)");
       }
-      const envelopeBytes = inflateEntry(archiveBytes, TREE_ENVELOPE_FILENAME);
+      const envelopeBytes = inflateEntry(archive, TREE_ENVELOPE_FILENAME);
       const manifest = parseTreeManifest(decode(envelopeBytes));
       const compatible = checkTreeCompatibility(manifest, SDK_VERSION);
       const fileEntries = entries.filter((entry) => entry.kind === "file");
       const totalUncompressedBytes = entries.reduce((sum, entry) => sum + entry.uncompressedSize, 0);
       return { manifest, entryCount: fileEntries.length, totalUncompressedBytes, compatible };
     }
-    function extractTreeArchive3(archiveBytes, destDir, limits, refuseExecutableEntries) {
+    function extractTreeArchive3(archive, destDir, limits, refuseExecutableEntries) {
       const effectiveLimits = limits === void 0 ? defaultTreeLimits() : limits;
-      const entries = listEntries(archiveBytes);
+      const entries = listEntries(archive);
       const plan7 = planTreeExtraction(entries, effectiveLimits);
       if (refuseExecutableEntries === true) {
         assertPortableTreePaths(plan7.paths);
       }
       const files = [];
       for (const approvedPath of plan7.paths) {
-        const contents = inflateEntry(archiveBytes, approvedPath);
+        const contents = inflateEntry(archive, approvedPath);
         files.push({ path: approvedPath, contents });
       }
       const envelope = files.find((file) => file.path === TREE_ENVELOPE_FILENAME);
@@ -37212,9 +38744,9 @@ var require_dist = __commonJS({
     }
     function readInnerIdentity(files, manifest) {
       const innerPath = manifest.kind === "code" ? "package.json" : manifest.entry;
-      const inner = files.find((file) => file.path === innerPath);
-      if (!inner) throw new Error(`pack build: inner pack manifest "${innerPath}" is missing`);
-      const parsed = manifest.kind === "code" ? JSON.parse(decode(inner.contents)) : (0, import_js_yaml3.load)(decode(inner.contents));
+      const inner2 = files.find((file) => file.path === innerPath);
+      if (!inner2) throw new Error(`pack build: inner pack manifest "${innerPath}" is missing`);
+      const parsed = manifest.kind === "code" ? JSON.parse(decode(inner2.contents)) : (0, import_js_yaml3.load)(decode(inner2.contents));
       const name = parsed?.name;
       const version = parsed?.version;
       if (typeof name !== "string" || typeof version !== "string") {
@@ -37628,6 +39160,59 @@ var init_signature_repair = __esm({
   }
 });
 
+// src/core/type-spelling-repair.ts
+function repairTypeSpellings(apply4) {
+  const facts = typeSpellingFacts();
+  const held = new Set(signatureFacts().sources.filter((f) => f.outcome === "restated" && f.differs).map((f) => f.interfaceId));
+  const repairs = /* @__PURE__ */ new Map();
+  const repairOf = (specId, kind) => {
+    const key = `${kind}:${specId}`;
+    let repair = repairs.get(key);
+    if (!repair) {
+      repair = { specId, kind, rewritten: [], proposals: [], authorNeeded: [] };
+      repairs.set(key, repair);
+    }
+    return repair;
+  };
+  const own = (specId) => !specId.includes("::");
+  for (const respelling of facts.respellings) {
+    if (!own(respelling.specId)) continue;
+    if (respelling.kind === "interface" && held.has(respelling.specId)) continue;
+    repairOf(respelling.specId, respelling.kind).rewritten.push(respelling);
+  }
+  for (const problem of facts.problems) {
+    if (problem.specId === void 0 || problem.kind === void 0 || !own(problem.specId)) continue;
+    const repair = repairOf(problem.specId, problem.kind);
+    const proposal = typeProblemIntProposal(problem);
+    if (proposal) repair.proposals.push(proposal);
+    else repair.authorNeeded.push(problem);
+  }
+  const planned = [...repairs.values()];
+  const rewriting = planned.filter((repair) => repair.rewritten.length > 0);
+  if (apply4 && rewriting.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 rewriting) {
+      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_type_spelling_repair = __esm({
+  "src/core/type-spelling-repair.ts"() {
+    "use strict";
+    init_specs2();
+    init_models();
+  }
+});
+
 // src/models/lock.ts
 function describeApprover(who) {
   const label7 = who.name ? `${who.name} (${who.id})` : who.id;
@@ -38210,7 +39795,7 @@ function parentPinState(parent) {
 }
 function getStatusReport(options = {}, decor) {
   const mark = fillDecor(decor);
-  scanAllSpecs({ recursive: options.recursive ?? true });
+  scanAllSpecs({ memberDepth: options.memberDepth });
   const system = loadSystemSpec();
   const loaderErrors = getLoaderIssues();
   if (loaderErrors.length > 0) {
@@ -38412,6 +39997,11 @@ var init_status = __esm({
 });
 
 // src/core/index.ts
+function resolveSignatures(interfaces, components, types) {
+  const canonicalInterfaces = interfaces.map((intf) => interfaceCanonicalTypes(intf).spec);
+  const canonicalTypes = types.map((type) => typeCanonicalTypes(type).spec);
+  return resolveTree(canonicalInterfaces, components, canonicalTypes);
+}
 function resolveDomains2() {
   return resolveDomains();
 }
@@ -38433,9 +40023,10 @@ var init_core = __esm({
     init_project_config();
     init_domain_projector();
     init_domain_curator();
+    init_models();
+    init_signature_sources2();
     init_rules();
     init_specs2();
-    init_signature_sources2();
     init_external_producers();
     init_part_context();
     init_provision();
@@ -38457,6 +40048,7 @@ var init_core = __esm({
     init_stereotype_migration();
     init_narrative_repair();
     init_signature_repair();
+    init_type_spelling_repair();
     init_approval();
     init_approver();
     init_specs2();
@@ -38863,12 +40455,14 @@ function noticesFrom(verdict) {
     ...verdict.notices.map((n) => `${n.code} (notice): ${n.message}`)
   ];
 }
-function componentCandidateGate(options = candidateOptions(), storedOwner) {
+function componentCandidateGate(options = candidateOptions(), storedOwner, stored) {
   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.`);
+      const written = deltaWrittenTypeProblems(kind, merged, stored ?? null);
+      if (written.length) throw new Error(`${typeProblemRefusal(kind, String(merged.id), written)} Nothing was written.`);
       if (kind !== "component") return;
       const verdict = validateComponentCandidate(merged, options);
       if (verdict.errors.length) throw new Error(formatCandidateRefusal(verdict));
@@ -38876,6 +40470,22 @@ function componentCandidateGate(options = candidateOptions(), storedOwner) {
     }
   };
 }
+function canonicalTypesOf(kind, spec) {
+  if (!spec || typeof spec !== "object") return null;
+  if (kind === "interface") return interfaceCanonicalTypes(spec);
+  if (kind === "type") return typeCanonicalTypes(spec);
+  return null;
+}
+function deltaWrittenTypeProblems(kind, merged, stored) {
+  const now = canonicalTypesOf(kind, merged)?.problems ?? [];
+  if (now.length === 0) return [];
+  const before = new Set((canonicalTypesOf(kind, stored)?.problems ?? []).map((p) => `${p.path}|${p.written}`));
+  return now.filter((p) => !before.has(`${p.path}|${p.written}`));
+}
+function typeProblemRefusal(kind, id, problems) {
+  const lines = problems.map((p) => `${p.code} at ${p.path}: ${p.detail}${p.replacement ? ` \u2014 write ${p.replacement} instead` : ""}.`);
+  return `Refusing to write ${kind} "${id}": ${problems.length === 1 ? "a type position is" : `${problems.length} type positions are`} not in the neutral type grammar. ${lines.join(" ")} Aliases (string[], T | null, boolean, Promise<T>, ...) are accepted and respelled; these forms have no canonical spelling.`;
+}
 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));
@@ -38962,6 +40572,11 @@ function applyRestatement(restatement, loaded, parent) {
       `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 types = canonicalTypesOf(restatement.kind, candidate);
+  if (types && types.problems.length) {
+    return refused(restatement, replacedExisting, `${typeProblemRefusal(restatement.kind, String(candidate.id), types.problems)} Nothing was written.`);
+  }
+  if (types) Object.assign(candidate, types.spec);
   const derivedNotices = deriveStatedTexts(restatement.kind, candidate);
   const labelErrors = resolveLabelsOf(restatement.kind, candidate);
   if (labelErrors.length) {
@@ -38975,7 +40590,8 @@ function applyRestatement(restatement, loaded, parent) {
     ...status2.status ? { status: status2.status } : {},
     replacedExisting,
     notices: [...existing ? rewriteNotices(restatement.kind, existing, candidate, carried, cleared) : [], ...derivedNotices],
-    changedMethods: changedMethodsOf(restatement.kind, existing, candidate)
+    changedMethods: changedMethodsOf(restatement.kind, existing, candidate),
+    respellings: types?.respellings ?? []
   };
 }
 function parseCandidate(kind, candidate) {
@@ -39006,7 +40622,7 @@ function parseCandidate(kind, candidate) {
   };
 }
 function refused(restatement, replacedExisting, refusal2) {
-  return { spec: restatement.spec, refusal: refusal2, replacedExisting, notices: [], changedMethods: [] };
+  return { spec: restatement.spec, refusal: refusal2, replacedExisting, notices: [], changedMethods: [], respellings: [] };
 }
 function statusForCreate(restatement, existing) {
   if (!STATUSED_KINDS.has(restatement.kind)) return {};
@@ -39146,6 +40762,7 @@ function writeSpec(restatement) {
     replacedExisting: application.replacedExisting,
     ...application.status ? { status: application.status } : {},
     notices: [...gateNotices, ...persisted.notices, ...application.notices],
+    respellings: application.respellings,
     testsToRevisit
   };
 }
@@ -39201,7 +40818,7 @@ function updateSpecGated(kind, id, delta, dryRun) {
   const bound2 = candidateOptions();
   const testRoots = bound2.rules?.conformance?.testRoots ?? [];
   const stored = loadSpec(kind, id);
-  const gate = componentCandidateGate(bound2, stored?.subsystem);
+  const gate = componentCandidateGate(bound2, stored?.subsystem, stored);
   const report3 = updateSpec(kind, id, delta, gate, dryRun);
   const changed = changedMethods(report3);
   if (changed.length > 0 && testRoots.length > 0) {
@@ -39249,6 +40866,7 @@ var init_authoring = __esm({
   "src/core/authoring.ts"() {
     "use strict";
     init_specs();
+    init_type_grammar();
     init_authoring_core();
     init_authoring_validator();
     init_candidate2();
@@ -42950,6 +44568,7 @@ function renderChangeReport(report3) {
   if (report3.strippedKeys?.length) {
     lines.push("", `DROPPED FROM THE STORED FILE (${report3.dryRun ? "would be " : ""}removed \u2014 the schema does not know them):`, ...report3.strippedKeys.map((k) => `- ${k}`));
   }
+  lines.push(...renderRespellings(report3.respellings));
   lines.push(...renderTestsToRevisit(report3.testsToRevisit));
   return lines.join("\n");
 }
@@ -42966,13 +44585,19 @@ function renderTestsToRevisit(entries) {
   }
   return lines;
 }
+function renderRespellings(entries) {
+  if (!entries.length) return [];
+  return ["", "RESPELLED (stored canonical):", ...entries.map((r) => `- ${r.path}: "${r.written}" \u2192 "${r.stored}"`)];
+}
 function writeReceipt(sentence, receipt) {
   const noticeBlock = receipt.notices.length ? `
 
 NOTICE:
 - ${receipt.notices.join("\n- ")}` : "";
+  const respelledBlock = renderRespellings(receipt.respellings).join("\n");
   const testsBlock = renderTestsToRevisit(receipt.testsToRevisit).join("\n");
-  return structured(`${sentence}${noticeBlock}${testsBlock ? `
+  return structured(`${sentence}${noticeBlock}${respelledBlock ? `
+${respelledBlock}` : ""}${testsBlock ? `
 ${testsBlock}` : ""}`, receipt);
 }
 function describeMemberPacks(creation) {
@@ -43030,46 +44655,46 @@ function schemaShape(schema, seen = /* @__PURE__ */ new Map()) {
   const known = seen.get(schema);
   if (known !== void 0) return { ref: known };
   seen.set(schema, seen.size);
-  const inner = (s) => schemaShape(s, seen);
+  const inner2 = (s) => schemaShape(s, seen);
   const kind = String(def.typeName);
   switch (kind) {
     case "ZodObject": {
       const shape = typeof def.shape === "function" ? def.shape() : def.shape;
       return {
         kind,
-        keys: Object.keys(shape).sort().map((key) => [key, inner(shape[key])]),
+        keys: Object.keys(shape).sort().map((key) => [key, inner2(shape[key])]),
         unknownKeys: def.unknownKeys,
-        catchall: inner(def.catchall)
+        catchall: inner2(def.catchall)
       };
     }
     case "ZodArray":
-      return { kind, of: inner(def.type), min: def.minLength?.value, max: def.maxLength?.value };
+      return { kind, of: inner2(def.type), min: def.minLength?.value, max: def.maxLength?.value };
     case "ZodOptional":
     case "ZodNullable":
     case "ZodReadonly":
     case "ZodBranded":
     case "ZodCatch":
-      return { kind, of: inner(def.innerType ?? def.type) };
+      return { kind, of: inner2(def.innerType ?? def.type) };
     case "ZodDefault":
-      return { kind, of: inner(def.innerType), default: JSON.stringify(def.defaultValue?.()) };
+      return { kind, of: inner2(def.innerType), default: JSON.stringify(def.defaultValue?.()) };
     case "ZodEffects":
-      return { kind, effect: def.effect?.type, of: inner(def.schema) };
+      return { kind, effect: def.effect?.type, of: inner2(def.schema) };
     case "ZodLazy":
-      return { kind, of: inner(def.getter()) };
+      return { kind, of: inner2(def.getter()) };
     case "ZodUnion":
     case "ZodDiscriminatedUnion": {
       const options = def.options instanceof Map ? [...def.options.values()] : def.options;
-      return { kind, discriminator: def.discriminator, of: options.map(inner) };
+      return { kind, discriminator: def.discriminator, of: options.map(inner2) };
     }
     case "ZodIntersection":
-      return { kind, left: inner(def.left), right: inner(def.right) };
+      return { kind, left: inner2(def.left), right: inner2(def.right) };
     case "ZodTuple":
-      return { kind, of: def.items.map(inner), rest: inner(def.rest) };
+      return { kind, of: def.items.map(inner2), rest: inner2(def.rest) };
     case "ZodRecord":
     case "ZodMap":
-      return { kind, key: inner(def.keyType), value: inner(def.valueType) };
+      return { kind, key: inner2(def.keyType), value: inner2(def.valueType) };
     case "ZodSet":
-      return { kind, of: inner(def.valueType) };
+      return { kind, of: inner2(def.valueType) };
     case "ZodEnum":
       return { kind, values: def.values };
     case "ZodNativeEnum":
@@ -43077,7 +44702,7 @@ function schemaShape(schema, seen = /* @__PURE__ */ new Map()) {
     case "ZodLiteral":
       return { kind, value: def.value };
     case "ZodPipeline":
-      return { kind, in: inner(def.in), out: inner(def.out) };
+      return { kind, in: inner2(def.in), out: inner2(def.out) };
     default:
       return { kind, checks: def.checks?.map((c) => [c.kind, c.value ?? null]) ?? [] };
   }
@@ -43878,7 +45503,7 @@ ${renderChangeReport(report3)}`,
     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.'
+      'Whether the parameter may be OMITTED by a caller. It is not nullability: a parameter that must be passed but may be passed as nothing is a required parameter whose type says so \u2014 "ProjectConfig?". Say whichever is true; they are different contracts (both together: may be left out, and may be none).'
     )
   }).strict();
   const interfaceMethodShape = {
@@ -44127,7 +45752,7 @@ ${renderChangeReport(report3)}`,
     }
   );
   const typeInput = {
-    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"),
+    kind: import_zod11.z.enum(["entity", "value-object", "signature", "enum"]).describe("entity (owned by a subsystem), value-object (often system-level shared), signature \u2014 a named function type: params and returns, nothing else \u2014 or enum: a closed, ordered set of named values"),
     id: import_zod11.z.string().describe("Lowercase identifier"),
     name: import_zod11.z.string().describe("Human-readable name"),
     description: import_zod11.z.string().optional(),
@@ -44161,18 +45786,23 @@ ${renderChangeReport(report3)}`,
     sourcePath: import_zod11.z.string().optional().describe("Source file holding the declaration of this type (project-relative). Naming one turns the type into a claim on code: the file must resolve and the declaration must be anchored in it (UNREALIZED_TYPE)"),
     symbol: import_zod11.z.string().optional().describe('Code-level name realizing the declaration when it differs from name, e.g. a type named "Invoice Line" declared as InvoiceLine'),
     params: import_zod11.z.array(methodParamItem).optional().describe("kind signature only: the function type's parameters, in declared order (SIGNATURE_TYPE_MEMBERS on any other kind)"),
-    returns: import_zod11.z.string().optional().describe(TYPE_REF_GRAMMAR("kind signature only, and required there: the function type's one output"))
+    returns: import_zod11.z.string().optional().describe(TYPE_REF_GRAMMAR("kind signature only, and required there: the function type's one output")),
+    values: import_zod11.z.array(import_zod11.z.object({
+      name: import_zod11.z.string().min(1).describe(`The value's name, exactly as data carries it ("stable", "local_only")`),
+      description: import_zod11.z.string().optional().describe("What the value means")
+    }).strict()).optional().describe("kind enum only, and required there: the values in declared order \u2014 the order is part of the design (a narrowest-first track list means something). Unique by name ignoring case and separators; no ordinals and no separate wire value"),
+    holds: import_zod11.z.string().optional().describe('kind value-object only: makes it a NAMED SCALAR \u2014 one primitive under a name (string, int, float, bool, bytes, date, datetime or duration), a newtype or type alias in every language (`type PackPath = string`), declared in place of fields. Not a union, not a named type, not any; fields beside it, or holds on another kind, is NAMED_SCALAR_MEMBERS. Aliases are respelled (boolean \u2192 bool) and number is refused ("int or float?")')
   };
   const typeInputFields = Object.keys(typeInput);
   reg(
     server,
     "sdd_add_type",
     {
-      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.",
+      description: "Define a type: an entity or value-object (the data components operate on), a signature \u2014 a named function type \u2014 or an enum: a closed, ordered set of named `values` ({name, description?}, unique by name ignoring case and separators; the name is also the value as data carries it), with optional pure methods and nothing else (no fields, params or returns). A value-object may instead be a NAMED SCALAR: it `holds` one primitive in place of fields (a newtype or type alias in every language). Every type position (a field's type, a method's params and returns, a signature's params and returns, a named scalar's holds) is written in the neutral type grammar; aliases are respelled and listed in the receipt. 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, params, returns }) => {
+    ({ kind, id, name, description, subsystem, group, fields, methods, componentClass, invariants, database, table, linkedEntity, sourcePath, symbol, params, returns, values, holds }) => {
       try {
         const spec = {
           kind,
@@ -44198,7 +45828,9 @@ ${renderChangeReport(report3)}`,
           ...sourcePath ? { sourcePath } : {},
           ...symbol ? { symbol } : {},
           ...params ? { params } : {},
-          ...returns ? { returns } : {}
+          ...returns ? { returns } : {},
+          ...values ? { values } : {},
+          ...holds ? { holds } : {}
         };
         const receipt = writeSpec({ kind: "type", spec, fields: typeInputFields });
         return writeReceipt(
@@ -44231,7 +45863,8 @@ ${renderChangeReport(report3)}`,
           rules: config.rules,
           projectType: config.projectType,
           scopeSubsystem: subsystem,
-          recursive: recursive ?? true,
+          // The tool's flag at the edge: recursive false is a member depth of 0.
+          ...recursive === false ? { memberDepth: 0 } : {},
           family
         };
         const result = selectsFamily(options2, declaredMembers(config).length > 0) ? validateFamily(options2) : validateProject(options2);
@@ -44366,7 +45999,7 @@ ${testsBlock}` : ""}`, deletion);
     server,
     "sdd_update_spec",
     {
-      description: "Update/patch an existing SDD specification (subsystem, component, interface, implementation, or type) using a granular delta. Updates fields, appends/merges array elements, or inserts/deletes narrative steps. Answers with exactly what changed, and with every path the delta named that the write did not act on. Pass dryRun to be told what it would do without writing it.",
+      description: "Update/patch an existing SDD specification (subsystem, component, interface, implementation, or type) using a granular delta. Updates fields, appends/merges array elements, or inserts/deletes narrative steps. Answers with exactly what changed, and with every path the delta named that the write did not act on. Type positions (the type of a param, a returns, the type of a field, the params and returns of a signature) are written in the neutral type grammar: an alias the delta writes (string[], T | null, boolean, Promise<T>) is stored canonical and listed under `respellings`, and a stored alias at a position the write keeps is respelled with it; a position the delta writes that has no canonical spelling (number \u2014 int or float?, an inline object or function type, a literal union, a union mixing in a primitive) is refused, naming the replacement, while one the stored spec already held is left alone. Pass dryRun to be told what it would do without writing it.",
       inputSchema: {
         kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project export table, each entry a re-export {from, component, interface, typeDef, as, name, type, details, audience: project|department|instance|partner|external} \u2014 from alone re-exports everything a subsystem exports, and a legacy {id, subsystem} reads as {as, from})"),
         id: import_zod11.z.string().describe("The ID of the spec to update (namespaced if needed)"),
@@ -44395,18 +46028,19 @@ ${testsBlock}` : ""}`, deletion);
       }
     },
     ({ subsystem, recursive }) => {
+      const memberDepth = recursive === false ? 0 : void 0;
       const banner = pendingBanner().map((line2) => `\u26A0 TRANSACTION PENDING: ${line2}
 `).join("");
       try {
         let approvals;
         try {
-          approvals = familyApprovals(recursive === false ? 0 : void 0);
+          approvals = familyApprovals(memberDepth);
         } catch {
           approvals = void 0;
         }
         const report3 = getStatusReport({
           subsystem,
-          recursive: recursive ?? true,
+          memberDepth,
           approvals
         });
         const family = statusFamilyContext();
@@ -44623,7 +46257,7 @@ async function startMcpServer() {
   } catch {
   }
 }
-var import_mcp, import_stdio, import_zod11, import_types12, fs30, path50, import_url, crypto10, TYPE_REF_GRAMMAR, staleServerOutput, externalPinsOutput, externalStatusesOutput, SPEC_KINDS, STATUS_VALUES, testsToRevisitOutput, specWriteReceiptOutput, specDeletionOutput, specChangeOutput, specChangeReportOutput, validationIssueOutput, memberCreationOutput, doctrineChangeOutput, impactTotalsOutput, packImpactOutput, validateTreeOutput, getSpecOutput, FINGERPRINT_VERSION, runningFingerprint, RECONNECT, assessedAsChanged, serverBuildStamps, SERVER_BUILD_STAMP, SPEC_WRITE_TOOLS, listChangedEmitters, statusInput, SKILL_RESOURCE_MIME, AGENT_BRIEF_SCHEME;
+var import_mcp, import_stdio, import_zod11, import_types12, fs30, path50, import_url, crypto10, TYPE_REF_GRAMMAR, staleServerOutput, externalPinsOutput, externalStatusesOutput, SPEC_KINDS, STATUS_VALUES, testsToRevisitOutput, typeRespellingOutput, specWriteReceiptOutput, specDeletionOutput, specChangeOutput, specChangeReportOutput, validationIssueOutput, memberCreationOutput, doctrineChangeOutput, impactTotalsOutput, packImpactOutput, validateTreeOutput, getSpecOutput, FINGERPRINT_VERSION, runningFingerprint, RECONNECT, assessedAsChanged, serverBuildStamps, SERVER_BUILD_STAMP, SPEC_WRITE_TOOLS, listChangedEmitters, statusInput, SKILL_RESOURCE_MIME, AGENT_BRIEF_SCHEME;
 var init_server = __esm({
   "src/mcp/server.ts"() {
     "use strict";
@@ -44652,7 +46286,7 @@ var init_server = __esm({
     init_project();
     init_validation_options();
     init_migrations3();
-    TYPE_REF_GRAMMAR = (what) => `${what}: a primitive/builtin or a defined type id (qualified across subsystems, e.g. "billing.Invoice" or "billing::Invoice"). Generics, arrays and UNIONS are all read, at any depth: "Invoice | null" (the commonest shape there is), "Invoice | undefined", "Invoice | Receipt", "Promise<Invoice | null>", "Map<string, Invoice | null>", "Invoice[] | null", "(Invoice | null)[]". Every identifier the string names must resolve \u2014 a union of two defined types means BOTH must exist. A union of string literals ("read" | "write") names no type and resolves to nothing.`;
+    TYPE_REF_GRAMMAR = (what) => `${what}, in the neutral type grammar: a primitive (string, int, float, bool, bytes, date, datetime, duration, any; void only as a whole returns), a defined type id ("billing.Invoice", "alias::name"), list<T>, set<T>, map<K, V> (K is string, int or an enum), T? (T or no value), a union of NAMED types ("Invoice | Receipt"), and on a returns only, async T ("async void"). Every named type must resolve. TypeScript spellings are accepted and respelled \u2014 "Invoice[]" \u2192 list<Invoice>, "Invoice | null" \u2192 Invoice?, boolean \u2192 bool, Record<string, V> \u2192 map<string, V>, Promise<T> \u2192 async T \u2014 and the answer lists each respelling. Refused, naming the replacement: number ("int or float?"), inline object or function types (name a value-object or a signature type), string-literal unions (name an enum), and unions mixing in a primitive or a collection.`;
     staleServerOutput = {
       staleServer: import_zod11.z.boolean().optional().describe(
         "True when the wairon build on disk changed after this server started \u2014 the structured twin of the text answer's STALE SERVER banner. When the rebuild left the spec and tool schemas alone, writes still go through; reconnect to run the new code."
@@ -44702,6 +46336,13 @@ var init_server = __esm({
     })).describe(
       "The tests that encode a method this write changed or deleted, one entry per such method. Empty when the write touched no method, when the project declares no `rules.conformance.testRoots`, or when nothing references them. Read it before promising that existing tests still pass."
     );
+    typeRespellingOutput = import_zod11.z.object({
+      specId: import_zod11.z.string().describe("The interface or type holding the position."),
+      kind: import_zod11.z.enum(["interface", "type"]).describe("interface | type."),
+      path: import_zod11.z.string().describe("Where in the spec: methods.save.params.key, methods.save.returns, fields.createdAt, params.listener."),
+      written: import_zod11.z.string().describe("The text the input (or the stored file) held."),
+      stored: import_zod11.z.string().describe("The canonical spelling, which is what is stored and shown.")
+    });
     specWriteReceiptOutput = {
       kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind written."),
       id: import_zod11.z.string().describe('The id the spec is stored under; "system" for the L0 singleton.'),
@@ -44715,6 +46356,9 @@ var init_server = __esm({
       notices: import_zod11.z.array(import_zod11.z.string()).describe(
         "The notice lines the text answer lists, one per entry: what was carried forward, what a restatement removed, what an omission cleared, and every gate warning the write raised. Empty for a clean create."
       ),
+      respellings: import_zod11.z.array(typeRespellingOutput).describe(
+        "Each type position the write normalised: what the input wrote against the canonical spelling stored. Aliases are accepted, never refused, and this list is how an author learns the canonical form. Empty when every position was already canonical."
+      ),
       testsToRevisit: testsToRevisitOutput,
       ...staleServerOutput
     };
@@ -44747,6 +46391,9 @@ var init_server = __esm({
         "Every path the delta named that the write did not act on, each with why. Read it: a nested typo the permissive delta cannot refuse shows up here and nowhere else."
       ),
       notices: import_zod11.z.array(import_zod11.z.string()).describe("Store placement notices, gate warnings and delta notices."),
+      respellings: import_zod11.z.array(typeRespellingOutput).describe(
+        "Each type position the write normalised (or, on a dry run, would): what the delta or the stored file wrote against the canonical spelling stored. Aliases are accepted and respelled, never refused \u2014 this is how the canonical form is taught. Empty when every position was already canonical."
+      ),
       summary: import_zod11.z.string().describe("One line for people."),
       testsToRevisit: testsToRevisitOutput,
       strippedKeys: import_zod11.z.array(import_zod11.z.string()).optional().describe(
@@ -45147,7 +46794,7 @@ function planMcpInstall(options) {
     upToDate
   }));
 }
-async function runMcpInstall(options = {}) {
+function runMcpInstall(options = {}) {
   for (const target of resolveInstallTargets(options)) {
     const agentLabel = target.backend === "gemini" ? "Antigravity" : "Claude";
     if (target.upToDate) {
@@ -45188,7 +46835,7 @@ function reportInstalled(target, agentLabel) {
   }
   logger.blank();
 }
-async function runMcpStatus() {
+function runMcpStatus() {
   assertProjectInitialized();
   const projectConfig = loadProjectConfig();
   if (!projectConfig) throw new ProjectNotInitializedError();
@@ -45998,7 +47645,7 @@ async function executeInit(projectName, projectConfig, guidePlan) {
   if (targetTypes.includes("claude")) {
     try {
       const { runMcpInstall: runMcpInstall2 } = (init_mcp(), __toCommonJS(mcp_exports));
-      await runMcpInstall2({ global: false, backend: "claude" });
+      runMcpInstall2({ global: false, backend: "claude" });
     } catch (err) {
       logger.warn(`Failed to automatically register MCP server for Claude: ${err}`);
     }
@@ -46006,7 +47653,7 @@ async function executeInit(projectName, projectConfig, guidePlan) {
   if (targetTypes.includes("gemini") || targetTypes.includes("agy")) {
     try {
       const { runMcpInstall: runMcpInstall2 } = (init_mcp(), __toCommonJS(mcp_exports));
-      await runMcpInstall2({ backend: "gemini", global: false });
+      runMcpInstall2({ backend: "gemini", global: false });
     } catch (err) {
       logger.warn(`Failed to automatically register MCP server for Antigravity: ${err}`);
     }
@@ -46700,7 +48347,8 @@ async function runValidate(options = {}) {
       rules: projectConfig.rules,
       projectType: projectConfig.projectType,
       scopeSubsystem: options.subsystem,
-      recursive: options.recursive ?? true,
+      // The flag at the edge: --no-recursive is a member depth of 0, the default every level.
+      ...options.recursive === false ? { memberDepth: 0 } : {},
       family: options.family
     };
     const family = selectsFamily(sddOptions, declaredMembers(projectConfig).length > 0);
@@ -47234,16 +48882,12 @@ function refuseUnreadableTree(explanation) {
 function withoutTrailingNewline(text3) {
   return text3.endsWith("\n") ? text3.slice(0, -1) : text3;
 }
-function depthOf2(recursive) {
-  if (recursive === false) return 0;
-  return typeof recursive === "number" ? recursive : void 0;
-}
 async function runStatus(options = {}) {
   assertProjectInitialized();
   printPendingTransactions();
   let approvals;
   try {
-    approvals = familyApprovals(depthOf2(options.recursive));
+    approvals = familyApprovals(options.memberDepth);
   } catch {
     approvals = void 0;
   }
@@ -47649,7 +49293,7 @@ async function runDomainsRemove(id) {
 var import_chalk11 = __toESM(require("chalk"));
 init_logger();
 init_paths();
-async function runSkillsList() {
+function runSkillsList() {
   assertProjectInitialized();
   const names = listSkillNames();
   logger.header(`SDD Skills (${names.length})`);
@@ -47658,7 +49302,7 @@ async function runSkillsList() {
     console.log(`  ${import_chalk11.default.bold(n)}`);
   }
 }
-async function runSkillsInstall() {
+function runSkillsInstall() {
   assertProjectInitialized();
   const result = exportSddSkills();
   if (result.destinations.length === 0) {
@@ -47998,6 +49642,34 @@ async function runDoctor(options = {}) {
     } catch (e) {
       line(tally, "warn", `Could not plan the signature repair: ${e instanceof Error ? e.message : String(e)}`);
     }
+    try {
+      const spellings = repairTypeSpellings(false);
+      const rewriting = spellings.filter((repair) => repair.rewritten.length > 0);
+      const proposals = spellings.flatMap((repair) => repair.proposals);
+      const authorNeeded = spellings.flatMap((repair) => repair.authorNeeded);
+      if (spellings.length > 0) console.log(import_chalk12.default.bold("Type spellings"));
+      if (rewriting.length > 0) {
+        for (const repair of rewriting) {
+          line(tally, "warn", `${repair.kind} ${repair.specId}: ${repair.rewritten.length} position(s) to respell (${describeRespellings(repair.rewritten)})`);
+        }
+        line(tally, "warn", "Run `wairon doctor --fix` to write them in their canonical spelling (any save of the spec does too).");
+      }
+      if (proposals.length > 0) {
+        console.log(`  ${import_chalk12.default.gray("int proposed \u2014 never written: confirm by writing int, or write float")}`);
+        for (const proposal of proposals) {
+          line(tally, "warn", `${proposal.kind} ${proposal.specId} ${proposal.path}: "${proposal.written}" \u2192 ${proposal.stored} (proposed)`);
+        }
+      }
+      if (authorNeeded.length > 0) {
+        console.log(`  ${import_chalk12.default.gray("needs an author \u2014 no rewrite can settle these")}`);
+        for (const problem of authorNeeded) {
+          line(tally, "warn", `${problem.kind} ${problem.specId} ${problem.path ?? ""}: "${problem.written}" \u2014 ${problem.replacement ? `write ${problem.replacement}` : problem.detail}`);
+        }
+      }
+      if (spellings.length > 0) logger.blank();
+    } catch (e) {
+      line(tally, "warn", `Could not plan the type-spelling repair: ${e instanceof Error ? e.message : String(e)}`);
+    }
     try {
       const planned = plan5({ verb: "chaining", rehearse: false });
       const pending4 = planned.chaining;
@@ -48229,6 +49901,28 @@ async function applyFixes(options, tally) {
   } catch (e) {
     console.log(`  ${icon("error")} Signature repair failed: ${e instanceof Error ? e.message : String(e)}`);
   }
+  try {
+    const spellings = repairTypeSpellings(true);
+    const rewritten = spellings.filter((repair) => repair.rewritten.length > 0);
+    if (rewritten.length > 0) {
+      const positions = rewritten.reduce((n, repair) => n + repair.rewritten.length, 0);
+      console.log(`  ${icon("ok")} Rewrote ${positions} type position(s) in ${rewritten.length} spec(s) into their canonical spelling.`);
+    }
+    const proposals = spellings.flatMap((repair) => repair.proposals);
+    if (proposals.length > 0) {
+      console.log(`  ${icon("warn")} ${proposals.length} number position(s) with int proposed \u2014 not written; confirm by writing int, or write float:`);
+      for (const proposal of proposals) console.log(`      ${proposal.kind} ${proposal.specId} ${proposal.path}: "${proposal.written}" \u2192 ${proposal.stored} (proposed)`);
+    }
+    const authorNeeded = spellings.flatMap((repair) => repair.authorNeeded);
+    if (authorNeeded.length > 0) {
+      console.log(`  ${icon("warn")} ${authorNeeded.length} type position(s) need an author \u2014 no rewrite can settle them:`);
+      for (const problem of authorNeeded) {
+        console.log(`      ${problem.kind} ${problem.specId} ${problem.path ?? ""}: "${problem.written}" \u2014 ${problem.replacement ? `write ${problem.replacement}` : problem.detail}`);
+      }
+    }
+  } catch (e) {
+    console.log(`  ${icon("error")} Type-spelling repair failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
   await migrateChaining(options, tally);
   await repairMcpRegistration(options, targets);
   logger.blank();
@@ -48248,18 +49942,18 @@ async function repairMcpRegistration(options, targets) {
       continue;
     }
     if (writes.some((w) => w.outsideProject && !w.upToDate)) outside.push({ install, writes });
-    else await installMcp(install);
+    else installMcp(install);
   }
   const plugin = gemini ? findLegacyPlugin() : null;
   if (outside.length === 0 && !plugin) return;
   printOutsideWrites(outside, plugin);
   if (!await confirmOutsideWrites(options)) return;
-  for (const planned of outside) await installMcp(planned.install);
+  for (const planned of outside) installMcp(planned.install);
   if (plugin) retireLegacyPlugin();
 }
-async function installMcp(install) {
+function installMcp(install) {
   try {
-    await runMcpInstall(install);
+    runMcpInstall(install);
   } catch (e) {
     console.log(`  ${icon("warn")} MCP install for ${install.backend} failed: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -48451,6 +50145,11 @@ function describeSignatureRepair(repair) {
   if (repair.dropped.length > 0) parts.push(`drops the restated signature of ${repair.dropped.join(", ")}`);
   return parts.join("; ");
 }
+function describeRespellings(respellings) {
+  const shown2 = respellings.slice(0, 3).map((r) => `${r.written} \u2192 ${r.stored}`);
+  const more = respellings.length - shown2.length;
+  return more > 0 ? `${shown2.join("; ")}; and ${more} more` : shown2.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);
 }
@@ -48689,7 +50388,7 @@ var import_chalk13 = __toESM(require("chalk"));
 init_logger();
 init_validation();
 init_core();
-async function listRules3() {
+function listRules3() {
   let overrides = {};
   if (projectConfigExists()) {
     try {
@@ -48743,7 +50442,7 @@ SDD conformance rules (${active.length})
 var import_chalk14 = __toESM(require("chalk"));
 init_logger();
 init_core();
-async function listPatterns() {
+function listPatterns() {
   const ext = loadProjectExtensions();
   console.log(import_chalk14.default.bold(`
 Reusable patterns (${ext.patterns.length})
@@ -48768,7 +50467,7 @@ Reusable patterns (${ext.patterns.length})
 var import_chalk15 = __toESM(require("chalk"));
 init_logger();
 init_core();
-async function listVariants() {
+function listVariants() {
   const variants = loadProjectVariants();
   console.log(import_chalk15.default.bold(`
 Component variants (${variants.length})
@@ -48948,7 +50647,7 @@ async function addPackFromArchive(source, options) {
   }
   logger.info(`${describe2(probe2)} \u2014 commit .wai/ so CI and every clone enforce it.`);
 }
-async function initPack(name, options = {}) {
+function initPack(name, options = {}) {
   const kind = options.kind === "code" ? "code" : "declarative";
   const targetDir = options.dir ?? `./${name}`;
   const request = { name, kind, targetDir };
@@ -48961,7 +50660,7 @@ async function initPack(name, options = {}) {
   logger.blank();
   logger.info(`Next: cd ${targetDir} && wairon pack build`);
 }
-async function buildPack(source, options = {}) {
+function buildPack(source, options = {}) {
   const sourceDir = source && source.length > 0 ? source : ".";
   const result = (0, import_sdk.buildPack)(sourceDir);
   const outPath = options.out ?? result.suggestedFileName;
@@ -49108,7 +50807,7 @@ function extractArchiveToTemp(source) {
     return null;
   }
 }
-async function uninstallStorePack(spec) {
+function uninstallStorePack(spec) {
   const { name, version } = parseNameAtVersion(spec);
   if (!uninstallPack(name, version)) {
     logger.error(`No pack "${spec}" is installed in the store (${packStoreDir()}).`);
@@ -49118,7 +50817,7 @@ async function uninstallStorePack(spec) {
   logger.success(`Uninstalled ${version ? `${name} v${version}` : `every version of ${name}`} from the pack store.`);
   logger.info("A project that still SELECTS it will now fail its gate with PACK_NOT_INSTALLED \u2014 reinstall it or drop the selection.");
 }
-async function whichPack(spec) {
+function whichPack(spec) {
   const { name, version } = parseNameAtVersion(spec);
   const resolved = resolveInstalledPack(name, version);
   if (!resolved) {
@@ -49276,7 +50975,7 @@ function writeBundle(root, resolved) {
   fs37.cpSync(resolved.path, dest, { recursive: true });
   return dest;
 }
-async function bundlePack(name, options = {}) {
+function bundlePack(name, options = {}) {
   if (!projectConfigExists()) {
     logger.error("Not inside a wairon project \u2014 run `wairon init` first.");
     process.exitCode = 1;
@@ -49341,7 +51040,7 @@ function parseNameAtVersion(spec) {
   if (at <= 0) return { name: spec };
   return { name: spec.slice(0, at), version: spec.slice(at + 1) };
 }
-async function listPacks() {
+function listPacks() {
   const inProject = projectConfigExists();
   const config = inProject ? loadProjectConfig() : null;
   if (inProject && !config) throw new ProjectNotInitializedError();
@@ -49508,7 +51207,7 @@ function printImpact(impact) {
   After:  ${totals3(impact.after)}`);
   logger.blank();
 }
-async function impactPack(spec) {
+function impactPack(spec) {
   if (!projectConfigExists()) {
     logger.error("Not inside a wairon project \u2014 run `wairon init` first.");
     process.exitCode = 1;
@@ -56320,7 +58019,7 @@ function referencedTypeNames(methods) {
   const names = /* @__PURE__ */ new Set();
   for (const m of methods) {
     for (const ref of methodTypeRefs(m)) {
-      if (!BUILTIN_TYPES.has(ref.toLowerCase())) names.add(ref.split(/::|\./).pop());
+      if (!isTypeVocabulary(ref)) names.add(ref.split(/::|\./).pop());
     }
   }
   return [...names];
@@ -56871,7 +58570,7 @@ function scopeOf2(grant) {
   if (!grant.projectId || grant.projectId === "*") return { scopeKind: "instance" };
   return { scopeKind: "project", scopeId: grant.projectId };
 }
-function readRaw(file) {
+function readRaw2(file) {
   try {
     return JSON.parse(fs57.readFileSync(file, "utf8"));
   } catch {
@@ -56912,7 +58611,7 @@ function migratePermissionModel(dataDir, apply4) {
   const found = (area, detail) => {
     findings.push({ area, detail });
   };
-  const grid = readRaw(
+  const grid = readRaw2(
     path79.join(dataDir, "permissions.json")
   ) ?? [];
   if (!getInstanceIdentity(dataDir)) {
@@ -56920,7 +58619,7 @@ function migratePermissionModel(dataDir, apply4) {
     if (apply4) ensureInstanceIdentity(dataDir);
   }
   const orgPath = path79.join(dataDir, "organization.json");
-  const org = readRaw(orgPath);
+  const org = readRaw2(orgPath);
   if (org?.units?.length) {
     const units = org.units;
     const byId = new Map(units.map((u) => [u.id, u]));
@@ -56974,7 +58673,7 @@ function migratePermissionModel(dataDir, apply4) {
     }
   }
   const usersPath = path79.join(dataDir, "users.json");
-  const users = readRaw(usersPath);
+  const users = readRaw2(usersPath);
   if (users) {
     let changed = false;
     for (const user of users) {
@@ -57001,7 +58700,7 @@ function migratePermissionModel(dataDir, apply4) {
     if (apply4 && changed) writeRaw(usersPath, users);
   }
   const keysPath = path79.join(dataDir, "auth", "credentials.json");
-  const keys = readRaw(keysPath);
+  const keys = readRaw2(keysPath);
   if (keys) {
     let changed = false;
     for (const key of keys) {
@@ -57051,7 +58750,7 @@ function migratePermissionModel(dataDir, apply4) {
     if (apply4 && changed) writeRaw(keysPath, keys);
   }
   const sessionsPath = path79.join(dataDir, "web-sessions.json");
-  const sessions = readRaw(sessionsPath);
+  const sessions = readRaw2(sessionsPath);
   if (sessions) {
     let changed = false;
     const kept = sessions.filter((s) => {
@@ -59270,9 +60969,9 @@ function serveMembershipTool(cfg, principal, binding, body) {
         return answer(relocationResult("adopt", adopt(cfg, principal, binding, String(call.args.alias ?? ""), String(call.args.path ?? ""), apply4), apply4));
       default: {
         const named2 = call.name === "sdd_rename_project" ? String(call.args.project ?? "") : call.name === "sdd_externalize_subsystem" ? String(call.args.subsystem ?? "") : String(call.args.alias ?? "");
-        const located = typeof call.args.source === "string" ? call.args.source : typeof call.args.path === "string" ? call.args.path : void 0;
+        const located2 = typeof call.args.source === "string" ? call.args.source : typeof call.args.path === "string" ? call.args.path : void 0;
         const newId = call.name === "sdd_promote_member" && typeof call.args.id === "string" && call.args.id ? call.args.id : void 0;
-        const screened = screen(cfg.dataDir, binding, call.name, named2, located, newId);
+        const screened = screen(cfg.dataDir, binding, call.name, named2, located2, newId);
         if (screened.refusal !== void 0) return answer({ content: [{ type: "text", text: screened.refusal }], isError: true });
         return { screen: screened };
       }
@@ -66016,7 +67715,7 @@ async function statusCommand(opts) {
 `);
     return;
   }
-  await runStatus({ subsystem: opts.subsystem, recursive: opts.recursive });
+  await runStatus({ subsystem: opts.subsystem, ...opts.recursive === false ? { memberDepth: 0 } : {} });
 }
 async function lockCheckCommand(options) {
   const verdict = checkApproval(options.strict === true);
@@ -66041,34 +67740,34 @@ program.command("status").description("Show a hierarchical completeness graph of
 program.command("doctor").description("Health check: flags stale generated guides/skills, an unregistered MCP server, spec-tree issues and the chaining migration still pending").option("--fix", "regenerate stale in-project guides/context/skills, register the MCP server, then apply the chaining migration once confirmed").option("--report <section>", "print one section's report and nothing else, writing nothing (chaining | composed-validation); never combines with --fix").option("-y, --yes", "answer the chaining migration's confirmation (for a non-interactive --fix); a write outside the project root also needs --global").option("--global", "consent to the --fix writes outside the project root (a machine-wide MCP config, the legacy global plugin); with --yes it answers their confirmation, and each replaced file is backed up beside itself").action(async (opts) => {
   await runDoctor({ fix: opts.fix, report: opts.report, yes: opts.yes, global: opts.global === true });
 });
-async function runRules() {
-  await listRules3();
+function runRules() {
+  listRules3();
 }
-async function runPatterns() {
-  await listPatterns();
+function runPatterns() {
+  listPatterns();
 }
-async function runVariants() {
-  await listVariants();
+function runVariants() {
+  listVariants();
 }
 async function runPacks(action, arg, options = {}) {
   if (action === "add") await addPack(arg, options.global);
-  else if (action === "list") await listPacks();
+  else if (action === "list") listPacks();
   else if (action === "remove") await removePack(arg, options.global);
 }
 async function runPack(action, arg, options = {}) {
-  if (action === "init") await initPack(arg, { kind: options.kind === "code" ? "code" : "declarative", dir: options.dir, skill: options.skill });
-  else if (action === "build") await buildPack(arg ?? ".", { out: options.out });
+  if (action === "init") initPack(arg, { kind: options.kind === "code" ? "code" : "declarative", dir: options.dir, skill: options.skill });
+  else if (action === "build") buildPack(arg ?? ".", { out: options.out });
   else if (action === "add") await addPack(arg, options.global, options.yes);
-  else if (action === "list") await listPacks();
+  else if (action === "list") listPacks();
   else if (action === "remove") await removePack(arg, options.global, options.yes);
   else if (action === "install") await installPack(arg, options.yes);
-  else if (action === "uninstall") await uninstallStorePack(arg);
-  else if (action === "which") await whichPack(arg);
+  else if (action === "uninstall") uninstallStorePack(arg);
+  else if (action === "which") whichPack(arg);
   else if (action === "use") await usePack(arg, { source: options.source, bundle: options.bundle, pin: options.pin, yes: options.yes });
   else if (action === "unuse") await unusePack(arg, options.yes);
-  else if (action === "bundle") await bundlePack(arg, { all: options.all });
+  else if (action === "bundle") bundlePack(arg, { all: options.all });
   else if (action === "sync") await syncPacks();
-  else if (action === "impact") await impactPack(arg);
+  else if (action === "impact") impactPack(arg);
   else throw new WaironError("unknown pack action (expected init | build | install | uninstall | which | use | unuse | impact | bundle | sync | add | list | remove)");
 }
 var executionCmd = program.command("execution").description("Execution budgets: what each agent's work is like and the model/turn/tool allowance it earns");
@@ -66237,9 +67936,9 @@ var mcpCmd = program.command("mcp").description("MCP (Model Context Protocol) se
 mcpCmd.command("serve").description("Start the wairon MCP server (stdio transport \u2014 use in mcpServers config)").action(async () => {
   await runMcpServe();
 });
-async function mcpInstallCommand(opts) {
+function mcpInstallCommand(opts) {
   const hostedToken = opts.hosted ? opts.token ?? storedCredentialFor(String(opts.hosted).replace(/\/+$/, "")) ?? void 0 : void 0;
-  await runMcpInstall({
+  runMcpInstall({
     global: opts.global,
     configDir: opts.configDir,
     backend: opts.backend,
@@ -66249,8 +67948,8 @@ async function mcpInstallCommand(opts) {
   });
 }
 mcpCmd.command("install").description("Register the wairon MCP server in the Claude Code settings.json or Antigravity mcp_config.json").option("--global", "install into the global/home config instead of the project (respects CLAUDE_CONFIG_DIR / GEMINI_CONFIG_DIR)").option("--config-dir <path>", "explicit config dir to install into (validated for the agent; requires --backend). Reliable alternative to relying on the shell's CLAUDE_CONFIG_DIR").option("--backend <type>", "target AI assistant: claude | gemini (aliases: agy, antigravity \u2192 gemini)").option("--hosted <url>", "register a HOSTED entry against this instance instead of the local stdio server").option("--project <id>", "hosted: the project the agent should be bound to").option("--token <token>", "hosted: the bearer to carry (else the credential stored by `wairon login`)").action(mcpInstallCommand);
-mcpCmd.command("status").description("Show whether the wairon MCP server is registered in Claude Code and Antigravity settings").action(async () => {
-  await runMcpStatus();
+mcpCmd.command("status").description("Show whether the wairon MCP server is registered in Claude Code and Antigravity settings").action(() => {
+  runMcpStatus();
 });
 program.command("produce <target>").description("project the local project's specs to a producer target (notion | miro)").option("--page <id>", "parent page/board id in the target").option("--token <token>", "integration token (else env, else interactive prompt)").action(async (target, opts) => {
   await runProduce(target, { page: opts.page, token: opts.token });
@@ -66413,11 +68112,11 @@ domainsCmd.command("remove <id>").alias("rm").description("Remove a free-standin
   await runDomainsRemove(id);
 });
 var skillsCmd = program.command("skills").description("Manage the SDD skills installed into your AI tools");
-skillsCmd.command("list").alias("ls").description("List the built-in SDD skills").action(async () => {
-  await runSkillsList();
+skillsCmd.command("list").alias("ls").description("List the built-in SDD skills").action(() => {
+  runSkillsList();
 });
-skillsCmd.command("install").alias("sync").description("Install/refresh the SDD skills into each active target tool").action(async () => {
-  await runSkillsInstall();
+skillsCmd.command("install").alias("sync").description("Install/refresh the SDD skills into each active target tool").action(() => {
+  runSkillsInstall();
 });
 async function main() {
   try {