@wairon/cli 5.1.1-dev.106 → 5.1.1-dev.107

package/dist/index.js

@@ -3547,6 +3547,7 @@ __export(src_exports, {
   SurfaceSnapshotSchema: () => SurfaceSnapshotSchema,
   SurfaceTypeDefSchema: () => SurfaceTypeDefSchema,
   SurfaceTypeExportSchema: () => SurfaceTypeExportSchema,
+  SurfaceUnresolvedExportSchema: () => SurfaceUnresolvedExportSchema,
   SwitchCaseSchema: () => SwitchCaseSchema,
   SystemPublicInterfaceSchema: () => SystemPublicInterfaceSchema,
   SystemSpecSchema: () => SystemSpecSchema,
@@ -3580,12 +3581,14 @@ __export(src_exports, {
   approvalKeyIn: () => approvalKeyIn,
   approvalRecord: () => approvalRecord,
   approvalVerdict: () => approvalVerdict,
+  approvedStatuses: () => approvedStatuses,
   assertContainedProjectPath: () => assertContainedProjectPath,
   assertProjectInitialized: () => assertProjectInitialized,
   attachRetiredMounts: () => attachRetiredMounts,
   backendCommand: () => backendCommand,
   backfillChainedSubprojectConfigs: () => backfillChainedSubprojectConfigs,
   backupBeside: () => backupBeside,
+  bindDeclaredExternal: () => bindDeclaredExternal,
   bodySitesOf: () => bodySitesOf,
   buildCanvasDataModel: () => buildCanvasDataModel,
   buildProjectGraph: () => buildProjectGraph,
@@ -3597,6 +3600,7 @@ __export(src_exports, {
   canonicalTypeRef: () => canonicalTypeRef,
   canonicalTypeText: () => canonicalTypeText,
   captureApprovedSpecs: () => captureApprovedSpecs,
+  carriedFactChanges: () => carriedFactChanges,
   carryRetiredReachForms: () => carryRetiredReachForms,
   checkDeclarativePack: () => checkDeclarativePack,
   clearLoaderIssues: () => clearLoaderIssues,
@@ -3608,6 +3612,7 @@ __export(src_exports, {
   composeRuleSequence: () => composeRuleSequence,
   computeGateStateId: () => computeGateStateId,
   computeOwnDesignId: () => computeOwnDesignStateId,
+  computeOwnDesignIdAsRecorded: () => computeOwnDesignStateIdAsRecorded,
   computeOwnStateId: () => computeOwnStateId,
   computeStateId: () => computeStateId,
   computeStateIdAt: () => computeStateIdAt,
@@ -3711,6 +3716,7 @@ __export(src_exports, {
   injectGuide: () => injectGuide,
   installPackFromDirectory: () => installPackFromDirectory,
   interfaceCanonicalTypes: () => interfaceCanonicalTypes,
+  interfaceDesignView: () => interfaceDesignView,
   interfaceGenericParameters: () => interfaceGenericParameters,
   internalizeMember: () => internalizeMember,
   isDraftSubsystem: () => isDraftSubsystem,
@@ -3730,6 +3736,7 @@ __export(src_exports, {
   languageOfSourcePath: () => languageOfSourcePath,
   lineEndingFor: () => lineEndingFor,
   listDirectChainedSubprojects: () => listDirectChainedSubprojects,
+  listExternalConsumers: () => listConsumers,
   listExternals: () => listExternals2,
   listFiles: () => listFiles,
   listFilesRecursive: () => listFilesRecursive,
@@ -3831,6 +3838,7 @@ __export(src_exports, {
   removeSnapshot: () => removeSnapshot2,
   renameAlias: () => renameAlias,
   renameComponent: () => renameComponent,
+  renameField: () => renameField,
   renameId: () => renameProjectId,
   renameMethod: () => renameMethod,
   renameType: () => renameType,
@@ -3845,6 +3853,7 @@ __export(src_exports, {
   resolveChainingParent: () => resolveChainingParent,
   resolveDomains: () => resolveDomains2,
   resolveExpectedOutputPaths: () => resolveExpectedOutputPaths,
+  resolveExternalCandidate: () => resolveCandidate,
   resolveExternals: () => resolveDeclared,
   resolveImport: () => resolveImport,
   resolveInstalledPack: () => resolveInstalledPack,
@@ -3873,6 +3882,7 @@ __export(src_exports, {
   setExecutionTier: () => setExecutionTier,
   setId: () => setProjectId,
   setLogLevel: () => setLogLevel,
+  setNetwork: () => setNetwork,
   setProjectRoot: () => setProjectRoot,
   setProjectType: () => setProjectType,
   settledSpecPaths: () => settledSpecPaths,
@@ -3886,6 +3896,7 @@ __export(src_exports, {
   stepGraph: () => stepGraph,
   storedMethodSignature: () => storedMethodSignature,
   storedTypeMethod: () => storedTypeMethod,
+  subsystemDesignView: () => subsystemDesignView,
   syncContextFiles: () => syncContextFiles,
   technologyName: () => technologyName,
   technologyTokens: () => technologyTokens,
@@ -3899,6 +3910,7 @@ __export(src_exports, {
   typeDialectFor: () => typeDialectFor,
   typeGenericParameters: () => typeGenericParameters,
   typeIsMany: () => typeIsMany,
+  typeMappingFor: () => typeMappingFor,
   typeMatchesRef: () => typeMatchesRef,
   typeNamedRefs: () => typeNamedRefs,
   typeProblemEnumProposal: () => typeProblemEnumProposal,
@@ -4273,7 +4285,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.106";
+var WAIRON_VERSION = "5.1.1-dev.107";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -5390,12 +5402,12 @@ function declaredPackNames(config) {
 function declaredProfileIds(config) {
   return [...new Set(config.profileSelection?.profileIds ?? [])];
 }
-function withPack(config, entry, remove2 = false) {
+function withPack(config, entry, remove3 = false) {
   const packs = config.extensions?.packs ?? [];
   const same = (e) => typeof entry === "string" ? e === entry : typeof e !== "string" && e.name === entry.name;
   const others = packs.filter((e) => !same(e));
   let next;
-  if (remove2) next = others;
+  if (remove3) next = others;
   else if (typeof entry === "string") next = packs.includes(entry) ? packs : [...packs, entry];
   else next = [...others, entry];
   return { ...config, extensions: { useGlobalPacks: false, ...config.extensions, packs: next } };
@@ -6045,8 +6057,8 @@ var DocumentReconciler = class {
   }
   mapping(map, target, at, replace2) {
     const written = (pair) => String(YAML.isScalar(pair.key) ? pair.key.value : pair.key);
-    const renamed = this.renamedKeys(map, target, written);
-    const keyOf = (pair) => renamed.get(pair) ?? written(pair);
+    const renamed2 = this.renamedKeys(map, target, written);
+    const keyOf = (pair) => renamed2.get(pair) ?? written(pair);
     const kept = map.items.filter((pair) => target[keyOf(pair)] !== void 0);
     if (kept.length === 0) {
       replace2(target);
@@ -6056,7 +6068,7 @@ var DocumentReconciler = class {
       const key2 = keyOf(pair);
       const span = this.pairSpan(pair);
       const keyRange = pair.key.range;
-      if (renamed.has(pair) && keyRange) this.splices.push({ start: keyRange[0], end: keyRange[1], text: key2, rank: 0 });
+      if (renamed2.has(pair) && keyRange) this.splices.push({ start: keyRange[0], end: keyRange[1], text: key2, rank: 0 });
       if (target[key2] === void 0) {
         this.splices.push({ start: span.start, end: span.end, text: "", rank: 0 });
         continue;
@@ -6294,6 +6306,13 @@ function packsOf(config) {
 function withPacks(config, packs) {
   return { ...config, extensions: { ...config.extensions, packs, useGlobalPacks: effectiveUseGlobalPacks(config) } };
 }
+function networkReads(stored, value) {
+  if (value === null || stored === void 0) return value === null && stored === void 0;
+  return (stored.description ?? "") === (value.description ?? "");
+}
+function networkValue(network) {
+  return network.description ? { description: network.description } : true;
+}
 function registryOver(store, root) {
   const current2 = () => {
     const config = store.read();
@@ -6499,6 +6518,18 @@ function registryOver(store, root) {
       store.write(partConfig(partOf, config));
       return true;
     },
+    setNetwork(network) {
+      const config = current2();
+      if (config.partOf !== void 0) {
+        throw new WaironError(
+          `Refusing to declare a network at ${root}: it is a part of "${config.partOf.project}", and a part declares no network \u2014 the project that declares one encloses it. Declare it on that project.`
+        );
+      }
+      if (networkReads(config.network, network)) return false;
+      const { network: _dropped, ...rest } = config;
+      save(network === null ? rest : { ...rest, network: networkValue(network) });
+      return true;
+    },
     removeMember(alias) {
       const config = current2();
       const members = config.members;
@@ -6738,6 +6769,9 @@ function projectConfigRepositoryOver(adapter, rootDir) {
     setPartOf(partOf) {
       return registry.setPartOf(partOf);
     },
+    setNetwork(network) {
+      return registry.setNetwork(network);
+    },
     removeMember(alias) {
       return registry.removeMember(alias);
     },
@@ -6832,6 +6866,9 @@ var projectConfigRepository = {
   setPartOf(partOf) {
     return bound().setPartOf(partOf);
   },
+  setNetwork(network) {
+    return bound().setNetwork(network);
+  },
   removeMember(alias) {
     return bound().removeMember(alias);
   },
@@ -7303,10 +7340,13 @@ var ComponentSpecSchema = import_zod5.z.object({
   /** Other L2 component ids this component collaborates with (facades / standalone blocks). */
   dependsOn: import_zod5.z.array(import_zod5.z.string()).default([]),
   /**
-   * Portal-only, and expected on every Portal: how callers reach its verbs (see
-   * TransportSchema). Replaces the retired portalType, which the loader reads
-   * compatibly for one release (HTTP_API as HTTP). Which process serves which
-   * Portal is implementation: there are no listener mounts.
+   * On a Portal (and expected on every Portal): how callers reach its verbs
+   * (see TransportSchema). Replaces the retired portalType, which the loader
+   * reads compatibly for one release (HTTP_API as HTTP). Which process serves
+   * which Portal is implementation: there are no listener mounts. On an
+   * Adapter, optional: the transport it calls its target Portal over —
+   * inferred from the target when absent, and ADAPTER_TRANSPORT_MISMATCH when
+   * stated and different from the target's. On no other block.
    */
   transport: TransportSchema.optional(),
   /**
@@ -7971,7 +8011,13 @@ var TypeFieldSchema = import_zod5.z.object({
    * For foreign keys, the referenced type/table ID (e.g. "billing.Invoice")
    * and optionally field (e.g. "billing.Invoice.id").
    */
-  references: import_zod5.z.string().optional()
+  references: import_zod5.z.string().optional(),
+  /**
+   * The field's rename trace: every name it held before, oldest first.
+   * Written only by the rename-field tool, never rewritten; the design export
+   * shows it as `formerly`, so a consumer holding the old name can follow it.
+   */
+  previousNames: PreviousNamesSchema.optional()
 });
 var TypeMethodSchema = import_zod5.z.object({
   name: import_zod5.z.string(),
@@ -8121,14 +8167,17 @@ function typeSourceFiles(type) {
 var DESIGN_VIEW_FIELDS = {
   implementation: {
     linkage: ["sourcePath", "simPath", "router", "injectedParams", "conformance", "createdAt", "updatedAt"],
-    design: ["id", "name", "description", "contract", "technologies", "methods", "detail", "previousIds", "lint", "ext", "status"]
+    readiness: ["status"],
+    design: ["id", "name", "description", "contract", "technologies", "methods", "detail", "previousIds", "lint", "ext"]
   },
   implementationMethod: {
     linkage: ["sourcePath", "symbol", "exportedVia", "conformance"],
+    readiness: [],
     design: ["name", "narrative", "detail", "intent", "calls", "ext"]
   },
   type: {
     linkage: ["sourcePath", "symbol", "createdAt", "updatedAt"],
+    readiness: [],
     design: [
       "kind",
       "id",
@@ -8154,10 +8203,12 @@ var DESIGN_VIEW_FIELDS = {
   },
   typeMethod: {
     linkage: ["sourcePath", "symbol"],
+    readiness: [],
     design: ["name", "signature", "params", "returns", "description"]
   },
   component: {
     linkage: ["externalLinks", "createdAt", "updatedAt"],
+    readiness: ["status"],
     design: [
       "id",
       "name",
@@ -8180,10 +8231,33 @@ var DESIGN_VIEW_FIELDS = {
       "variant",
       "previousIds",
       "lint",
-      "ext",
-      "status"
+      "ext"
+    ]
+  },
+  subsystem: {
+    linkage: ["createdAt", "updatedAt"],
+    readiness: ["status"],
+    design: [
+      "id",
+      "name",
+      "description",
+      "parentSystem",
+      "publicInterfaces",
+      "lifecycle",
+      "profile",
+      "projectPath",
+      "targetLanguage",
+      "trustedLinks",
+      "designDepth",
+      "lint",
+      "ext"
     ]
   },
+  interface: {
+    linkage: ["createdAt", "updatedAt"],
+    readiness: ["status"],
+    design: ["id", "name", "description", "component", "methods", "previousIds", "lint", "ext", "implements"]
+  },
   /**
    * A retired listener mount as a stored file may still hold it until doctor
    * --fix migrates it: its `via` was linkage (the router entry, now the
@@ -8191,9 +8265,13 @@ var DESIGN_VIEW_FIELDS = {
    */
   retiredMount: {
     linkage: ["via"],
+    readiness: [],
     design: ["portal", "prefixes"]
   }
 };
+function outOfApproval(kind) {
+  return [...DESIGN_VIEW_FIELDS[kind].linkage, ...DESIGN_VIEW_FIELDS[kind].readiness];
+}
 function withoutFields(value, fields) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return value;
   const out = {};
@@ -8206,20 +8284,26 @@ function eachOf(items, project3) {
   return Array.isArray(items) ? items.map(project3) : items;
 }
 function implementationDesignView(impl) {
-  const view3 = withoutFields(impl, DESIGN_VIEW_FIELDS.implementation.linkage);
+  const view3 = withoutFields(impl, outOfApproval("implementation"));
   if ("methods" in view3) view3.methods = eachOf(view3.methods, (m) => withoutFields(m, DESIGN_VIEW_FIELDS.implementationMethod.linkage));
   return view3;
 }
 function typeDesignView(type) {
-  const view3 = withoutFields(type, DESIGN_VIEW_FIELDS.type.linkage);
+  const view3 = withoutFields(type, outOfApproval("type"));
   if ("methods" in view3) view3.methods = eachOf(view3.methods, (m) => withoutFields(m, DESIGN_VIEW_FIELDS.typeMethod.linkage));
   return view3;
 }
 function componentDesignView(component) {
-  const view3 = withoutFields(component, DESIGN_VIEW_FIELDS.component.linkage);
+  const view3 = withoutFields(component, outOfApproval("component"));
   if ("mounts" in view3) view3.mounts = eachOf(view3.mounts, (m) => withoutFields(m, DESIGN_VIEW_FIELDS.retiredMount.linkage));
   return view3;
 }
+function subsystemDesignView(subsystem) {
+  return withoutFields(subsystem, outOfApproval("subsystem"));
+}
+function interfaceDesignView(contract) {
+  return withoutFields(contract, outOfApproval("interface"));
+}
 function componentEntryFor(component, method) {
   if (component.componentType !== "Portal") return void 0;
   const own2 = component.invokedBy;
@@ -8421,6 +8505,14 @@ var SurfaceContractEntrySchema = import_zod5.z.object({
   /** The entry's export role, call (the default) or implement. */
   role: import_zod5.z.string().optional()
 });
+var SurfaceUnresolvedExportSchema = import_zod5.z.object({
+  /** The public name the entry declares. */
+  id: import_zod5.z.string(),
+  /** Where it re-exports from: the `from` the entry names. */
+  source: import_zod5.z.string(),
+  /** The name the source's rename trace carries the item to, when it records one. */
+  renamedTo: import_zod5.z.string().optional()
+});
 var SurfaceSnapshotSchema = import_zod5.z.object({
   /** Producing project/system name — the snapshot's resolution identity. */
   projectName: import_zod5.z.string(),
@@ -8448,7 +8540,14 @@ var SurfaceSnapshotSchema = import_zod5.z.object({
    * language judges a native-ABI library call against. Absent when the
    * producer declares none, or on snapshots written before it was carried.
    */
-  targetLanguage: import_zod5.z.string().optional()
+  targetLanguage: import_zod5.z.string().optional(),
+  /**
+   * The public names the producer's L0 declares that no longer resolve (a
+   * named re-export whose source dropped or renamed the item), with the
+   * source's rename trace when it has one. Provenance, outside every digest;
+   * absent when every entry resolves.
+   */
+  unresolvedExports: import_zod5.z.array(SurfaceUnresolvedExportSchema).optional()
 });
 var ExternalLockEntrySchema = import_zod5.z.object({
   project: import_zod5.z.string(),
@@ -8483,7 +8582,7 @@ var ParentExcerptSchema = import_zod5.z.object({
 function relationHealth(status) {
   if (status.uses.some((u) => u.state === "changed" || u.state === "removed" || u.state === "renamed")) return "incompatible";
   if (!status.reachable || status.outOfReach || status.uses.some((u) => u.state === "unavailable" || u.state === "unlocked")) return "unavailable";
-  if (status.drifted) return "drifted";
+  if (status.drifted || (status.staleFacts?.length ?? 0) > 0) return "drifted";
   return "ok";
 }
 var NamedOpenApiSpecSchema = import_zod5.z.object({
@@ -8524,7 +8623,8 @@ function sortKeys(v) {
 
 // src/core/statehash.ts
 var CONTENT_ALGORITHM = "sha256";
-var DESIGN_ALGORITHM = "sha256-design";
+var DESIGN_ALGORITHM = "sha256-design-2";
+var EARLIER_DESIGN_ALGORITHM = "sha256-design";
 function inIdentityOrder(specs) {
   return specs.map((spec) => ({ spec, content: canonicalize(spec) })).sort((a, b) => compareOrdinal(a.spec.id, b.spec.id) || compareOrdinal(a.content, b.content)).map((entry) => entry.spec);
 }
@@ -8533,9 +8633,9 @@ function digestTree(keep, reading = {}) {
   const same = (spec) => spec;
   const tree = {
     system: loadSystemSpec(),
-    subsystems: kind(loadSubsystemSpecs()),
+    subsystems: kind(loadSubsystemSpecs().map(reading.subsystem ?? same)),
     components: kind(loadComponentSpecs().map(reading.component ?? same)),
-    interfaces: kind(loadInterfaceSpecs()),
+    interfaces: kind(loadInterfaceSpecs().map(reading.interface ?? same)),
     implementations: kind(loadImplementationSpecs().map(reading.implementation ?? same)),
     types: kind(loadTypeSpecs().map(reading.type ?? same))
   };
@@ -8567,9 +8667,31 @@ function computeOwnDesignStateId() {
     implementation: implementationDesignView,
     component: componentDesignView,
     type: typeDesignView,
+    subsystem: subsystemDesignView,
+    interface: interfaceDesignView,
     algorithm: DESIGN_ALGORITHM
   });
 }
+function approvedStatusKey(kind, id) {
+  return `${kind}:${id}`;
+}
+function computeOwnDesignStateIdAsRecorded(approvedStatus) {
+  const withStatus = (kind, view3) => (spec) => {
+    const status = spec.status;
+    if (status === void 0) return view3(spec);
+    const id = spec.id;
+    const approved = typeof id === "string" ? approvedStatus.get(approvedStatusKey(kind, id)) : void 0;
+    return { ...view3(spec), status: approved ?? status };
+  };
+  return digestTree(ownedByRoot(), {
+    implementation: withStatus("implementation", implementationDesignView),
+    component: withStatus("component", componentDesignView),
+    type: withStatus("type", typeDesignView),
+    subsystem: withStatus("subsystem", subsystemDesignView),
+    interface: withStatus("interface", interfaceDesignView),
+    algorithm: EARLIER_DESIGN_ALGORITHM
+  });
+}
 function isInside(dir, file) {
   const rel2 = path7.relative(dir, file);
   return rel2 !== "" && !rel2.startsWith("..") && !path7.isAbsolute(rel2);
@@ -9815,6 +9937,54 @@ var DIALECTS = /* @__PURE__ */ new Map([
 function typeDialectFor(language) {
   return DIALECTS.get(language.toLowerCase()) ?? null;
 }
+var MAPPING_ONLY = (language) => `(mapping only: wairon's code analyzer does not read ${language} annotations yet, so code conformance does not compare these types \u2014 follow the table by hand)`;
+var MAPPING_ONLY_TABLES = /* @__PURE__ */ new Map([
+  ["rust", [
+    "string \u2192 String (&str for a borrowed parameter)",
+    "int \u2192 i64 (a narrower iN/uN where the contract says so in its description)",
+    "float \u2192 f64",
+    "bool \u2192 bool",
+    "bytes \u2192 Vec<u8> (&[u8] for a borrowed parameter)",
+    "date \u2192 chrono::NaiveDate, datetime \u2192 chrono::DateTime<Utc>, duration \u2192 std::time::Duration",
+    "any \u2192 serde_json::Value",
+    "list<T> \u2192 Vec<T>",
+    "set<T> \u2192 HashSet<T> (BTreeSet<T> where order matters)",
+    "map<K, V> \u2192 HashMap<K, V> (BTreeMap<K, V> where order matters)",
+    "T? \u2192 Option<T>",
+    "A | B \u2192 an enum with one variant per named type",
+    "async T \u2192 async fn returning T",
+    "result<T, E> \u2192 Result<T, E> (result<void, E> \u2192 Result<(), E>)",
+    "an enum E \u2192 enum E { A, B } (unit variants)",
+    "a named scalar E holding P \u2192 a newtype struct E(P)",
+    "a contract (interface) \u2192 a trait; a type method \u2192 an impl method on the struct"
+  ]],
+  ["python", [
+    "string \u2192 str",
+    "int \u2192 int",
+    "float \u2192 float",
+    "bool \u2192 bool",
+    "bytes \u2192 bytes",
+    "date \u2192 datetime.date, datetime \u2192 datetime.datetime, duration \u2192 datetime.timedelta",
+    "any \u2192 typing.Any",
+    "list<T> \u2192 list[T]",
+    "set<T> \u2192 set[T]",
+    "map<K, V> \u2192 dict[K, V]",
+    "T? \u2192 T | None (Optional[T])",
+    "A | B \u2192 A | B",
+    "async T \u2192 async def returning T",
+    "result<T, E> \u2192 T, raising E on failure (result<void, E> \u2192 None)",
+    "an enum E \u2192 class E(enum.Enum)",
+    'a named scalar E holding P \u2192 E = NewType("E", P)',
+    "a contract (interface) \u2192 a typing.Protocol; an entity or value-object \u2192 a @dataclass"
+  ]]
+]);
+function typeMappingFor(language) {
+  const dialect = typeDialectFor(language);
+  if (dialect) return dialect.mappingLines();
+  const key2 = language.toLowerCase();
+  const table = MAPPING_ONLY_TABLES.get(key2);
+  return table ? [...table, MAPPING_ONLY(language)] : null;
+}
 
 // src/models/step-graph.ts
 function stepGraph(method) {
@@ -10285,6 +10455,45 @@ function contentDigest(snapshot) {
   };
   return sha256(canonicalize(contract));
 }
+function factValue(value) {
+  return value === void 0 || value === null ? "" : canonicalize(value);
+}
+function carriedFactChanges(pinned, live) {
+  const changes = [];
+  const differs = (label7, a, b) => {
+    if (factValue(a) !== factValue(b)) changes.push(label7);
+  };
+  differs("the producer's id", pinned.projectId, live.projectId);
+  differs("targetLanguage", pinned.targetLanguage, live.targetLanguage);
+  const liveEntries = new Map(live.interfaces.map((e) => [e.id, e]));
+  for (const entry of pinned.interfaces) {
+    const now = liveEntries.get(entry.id);
+    if (!now) continue;
+    differs(`export kind of ${entry.id}`, entry.type, now.type);
+    differs(`transport of ${entry.id}`, entry.transport, now.transport);
+    differs(`abi of ${entry.id}`, entry.abi, now.abi);
+    differs(`role of ${entry.id}`, entry.role, now.role);
+    differs(`stereotype of ${entry.id}`, entry.componentType, now.componentType);
+    differs(`basePath of ${entry.id}`, entry.basePath, now.basePath);
+    differs(`auth of ${entry.id}`, entry.auth?.scheme, now.auth?.scheme);
+    differs(`rename trace of ${entry.id}`, entry.formerly, now.formerly);
+    const liveMethods = new Map(now.methods.map((m) => [m.name, m]));
+    for (const method of entry.methods) {
+      const nowMethod = liveMethods.get(method.name);
+      if (!nowMethod) continue;
+      differs(`effect of ${entry.id}.${method.name}`, method.effect, nowMethod.effect);
+      differs(`rename trace of ${entry.id}.${method.name}`, method.formerly, nowMethod.formerly);
+    }
+  }
+  const liveTypes = new Map(live.types.map((t) => [t.id, t]));
+  for (const def of pinned.types) {
+    const now = liveTypes.get(def.id);
+    if (now) differs(`rename trace of ${def.id}`, def.formerly, now.formerly);
+  }
+  const unresolved = (snapshot) => [...snapshot.unresolvedExports ?? []].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  differs("the unresolved re-exports", unresolved(pinned), unresolved(live));
+  return changes;
+}
 function memberDigest(snapshot, publicName, member) {
   if (member === "type") {
     const exported = snapshot.exportedTypes?.find((t) => t.id === publicName);
@@ -10318,6 +10527,38 @@ function exportTargetKey(e) {
 
 // src/models/project-family.ts
 var path11 = __toESM(require("path"));
+function directoryKey(dir) {
+  const resolved = path11.resolve(dir);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function relationOf(consumer, producer) {
+  if (consumer.parent === producer.namespace) return "parent";
+  if (producer.parent === consumer.namespace) return "member";
+  if (consumer.parent !== void 0 && consumer.parent === producer.parent) return "sibling";
+  return "family";
+}
+function familyExternal(alias, project3, consumer, producer) {
+  return { alias, project: project3, sourceKind: "family", relation: relationOf(consumer, producer), producer: producer.namespace, directory: producer.directory, audience: "project", role: "external" };
+}
+function bindDeclaredExternal(declared, consumer, nodes) {
+  const unresolved = (problem) => ({ alias: declared.alias, project: declared.project, sourceKind: "unresolved", audience: "instance", problem, role: "external" });
+  if (declared.problem) return unresolved(declared.problem);
+  if (declared.sourceHosted !== void 0) return { alias: declared.alias, project: declared.project, sourceKind: "hosted", hosted: declared.sourceHosted, audience: "instance", role: "external" };
+  if (declared.sourceGit !== void 0) return { alias: declared.alias, project: declared.project, sourceKind: "git", audience: "instance", role: "external" };
+  if (declared.sourcePath !== void 0) {
+    const directory = path11.resolve(consumer.directory, declared.sourcePath);
+    const found = nodes.find((n) => directoryKey(n.directory) === directoryKey(directory));
+    if (!found) return { alias: declared.alias, project: declared.project, sourceKind: "path", directory, audience: "instance", role: "external" };
+    if (found.id !== declared.project) {
+      return unresolved(`the family project at source.path "${declared.sourcePath}" answers to ${found.id === void 0 ? "no id" : `"${found.id}"`}, not "${declared.project}"`);
+    }
+    return familyExternal(declared.alias, declared.project, consumer, found);
+  }
+  const holders = nodes.filter((n) => n.id === declared.project && n !== consumer);
+  if (holders.length === 0) return unresolved(`no project of the family answers to "${declared.project}", and no source.path says where to find it`);
+  if (holders.length > 1) return unresolved(`${holders.length} projects of the family answer to "${declared.project}" (${holders.map((n) => `"${n.namespace || "(the bound root)"}"`).join(", ")}), so the declaration could mean either`);
+  return familyExternal(declared.alias, declared.project, consumer, holders[0]);
+}
 function walkMemberPath(byKey3, start, segments) {
   let node = start;
   for (const segment of segments.slice(0, -1)) {
@@ -10541,7 +10782,9 @@ var DesignFieldSchema = import_zod9.z.object({
   optional: import_zod9.z.boolean(),
   description: import_zod9.z.string().optional(),
   key: import_zod9.z.string().optional(),
-  references: import_zod9.z.string().optional()
+  references: import_zod9.z.string().optional(),
+  /** The field's rename trace, oldest first — present only when it was renamed. */
+  formerly: import_zod9.z.array(import_zod9.z.string()).optional()
 }).passthrough();
 var DeclaredInvocationSchema2 = DeclaredInvocationSchema.passthrough();
 var DesignMethodSchema = import_zod9.z.object({
@@ -16902,7 +17145,10 @@ function typeSection(t, keys) {
       optional: f.optional === true,
       ...f.description !== void 0 ? { description: f.description } : {},
       ...f.key !== void 0 ? { key: f.key } : {},
-      ...f.references !== void 0 ? { references: keys.typeFieldRef(f.references, owner) } : {}
+      ...f.references !== void 0 ? { references: keys.typeFieldRef(f.references, owner) } : {},
+      // The field's rename trace, only when it was renamed: an export of a
+      // never-renamed field reads exactly as before.
+      ...f.previousNames && f.previousNames.length > 0 ? { formerly: [...f.previousNames] } : {}
     })),
     methods: t.methods.map((m) => ({
       key: `${key2}.${m.name}`,
@@ -17161,6 +17407,7 @@ function projectOwnSurface(maxAudience) {
   };
   const projectId = boundProjectId();
   const targetLanguage = system.targetLanguage?.trim().toLowerCase();
+  const unresolvedExports = table.problems.filter((p) => p.kind === "invalid" && p.publicName !== void 0 && p.source !== void 0 && !table.entries.some((e) => e.publicName === p.publicName)).map((p) => ({ id: p.publicName, source: p.source, ...p.renamedTo ? { renamedTo: p.renamedTo } : {} }));
   return canonicalReferences(SurfaceSnapshotSchema.parse({
     projectName: system.name,
     ...projectId ? { projectId } : {},
@@ -17170,7 +17417,8 @@ function projectOwnSurface(maxAudience) {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     interfaces: entries,
     types: closure,
-    ...exportedTypes.length ? { exportedTypes: exportedTypes.map((e) => ({ id: e.publicName, type: closureIdOf(e), audience: e.audience ?? "instance" })) } : {}
+    ...exportedTypes.length ? { exportedTypes: exportedTypes.map((e) => ({ id: e.publicName, type: closureIdOf(e), audience: e.audience ?? "instance" })) } : {},
+    ...unresolvedExports.length ? { unresolvedExports } : {}
   }));
 }
 function canonicalReferences(snapshot) {
@@ -17480,7 +17728,7 @@ function pinBinding(binding, lock) {
   }
   const digest3 = contentDigest(snapshot);
   const pinned = externalsRepository.readSnapshot(external.alias);
-  const snapshotChanged = !pinned || contentDigest(pinned) !== digest3;
+  const snapshotChanged = !pinned || contentDigest(pinned) !== digest3 || pinnedContentKey(pinned) !== pinnedContentKey(snapshot);
   if (snapshotChanged) externalsRepository.saveSnapshot(external.alias, snapshot);
   const { used, missing } = usedDigests(binding.usage, snapshot);
   const entry = {
@@ -17623,7 +17871,15 @@ function sameSignatureAfterRename(live, from, to, digest3) {
 function goneUse(live, publicName, member, digest3) {
   const to = renamedIn(live, publicName, member);
   const at = { publicName, ...member !== void 0 ? { member } : {} };
-  if (!to) return { ...at, state: "removed" };
+  if (!to) {
+    const broken = (live.unresolvedExports ?? []).find((u) => u.id === publicName);
+    if (!broken) return { ...at, state: "removed" };
+    return {
+      ...at,
+      state: "removed",
+      detail: `the producer re-exports it from "${broken.source}", which ${broken.renamedTo ? `renamed it to "${broken.renamedTo}"` : "no longer exports it"}, so the producer's re-export no longer resolves \u2014 ${broken.renamedTo ? `the producer must re-export "${broken.renamedTo}", or depend on "${broken.source}" directly` : "the producer must fix its re-export"}`
+    };
+  }
   const renamedTo = renamedName(to);
   const signature = member === void 0 || digest3 === void 0 ? "" : sameSignatureAfterRename(live, { publicName, member }, to, digest3) ? " (its signature is unchanged)" : " (and its signature changed)";
   return { ...at, state: "renamed", renamedTo, detail: `renamed to "${renamedTo}"${signature} \u2014 follow the rename` };
@@ -17642,13 +17898,19 @@ function compareUses(entry, usage, live) {
       uses.push(now === null ? goneUse(live, publicName, member, digest3) : { publicName, member, state: now === digest3 ? "unchanged" : "changed" });
     }
   }
+  const unlocked = (publicName, member) => {
+    const present = member === void 0 ? liveHas(publicName) : memberDigest(live, publicName, member) !== null;
+    if (!present) return goneUse(live, publicName, member, void 0);
+    return { publicName, ...member !== void 0 ? { member } : {}, state: "unlocked", detail: entry === void 0 ? "used, and present in the live producer, but never pinned \u2014 pin it (`wairon externals pin`) to record what it is judged against" : "used now, but not in the lock \u2014 re-pin" };
+  };
   for (const use of usage?.used ?? []) {
     if (!(use.publicName in locked)) {
-      uses.push({ publicName: use.publicName, state: "unlocked", detail: "used now, but not in the lock \u2014 re-pin" });
+      const gone = use.members.map((m) => unlocked(use.publicName, m)).filter((u) => u.state !== "unlocked");
+      uses.push(...gone.length ? gone : [unlocked(use.publicName)]);
       continue;
     }
     for (const member of use.members) {
-      if (!(member in locked[use.publicName])) uses.push({ publicName: use.publicName, member, state: "unlocked", detail: "used now, but not in the lock \u2014 re-pin" });
+      if (!(member in locked[use.publicName])) uses.push(unlocked(use.publicName, member));
     }
   }
   for (const ref of usage?.unexported ?? []) {
@@ -17700,11 +17962,14 @@ function externalStatus(binding, lock) {
   }
   const drifted = entry !== void 0 ? contentDigest(live) !== entry.digest : void 0;
   const uses = compareUses(entry, binding.usage, live);
+  const snapshot = entry !== void 0 ? externalsRepository.readSnapshot(external.alias) : null;
+  const staleFacts = snapshot ? carriedFactChanges(snapshot, live) : [];
   return {
     ...base,
     reachable: true,
     stale: uses.some((u) => u.state === "changed" || u.state === "removed" || u.state === "renamed"),
     ...drifted !== void 0 ? { drifted } : {},
+    ...staleFacts.length ? { staleFacts } : {},
     uses
   };
 }
@@ -17722,7 +17987,7 @@ function getExternalsStatus(offline) {
 function listExternals() {
   const bindings = resolveDeclared();
   const lock = externalsRepository.readLock();
-  return bindings.map(({ external }) => {
+  const declared = bindings.map(({ external }) => {
     const entry = lock?.externals[external.alias];
     return {
       alias: external.alias,
@@ -17735,6 +18000,20 @@ function listExternals() {
       ...external.problem ? { problem: external.problem } : {}
     };
   });
+  const aliases = new Set(bindings.map((b) => b.external.alias));
+  const orphans = Object.entries(lock?.externals ?? {}).filter(([alias]) => !aliases.has(alias)).map(([alias, entry]) => ({
+    alias,
+    project: entry.project,
+    sourceKind: "unresolved",
+    audience: "instance",
+    lock: entry,
+    problem: `pinned but no longer declared \u2014 \`wairon externals remove ${alias}\` removes the pin`
+  }));
+  return [...declared, ...orphans];
+}
+function pinnedContentKey(snapshot) {
+  const { stateId: _s, generatedAt: _g, origin: _o, ...content } = SurfaceSnapshotSchema.parse(JSON.parse(JSON.stringify(snapshot)));
+  return canonicalize({ ...content, interfaces: content.interfaces.map((e) => ({ ...e, component: lastSegment2(e.component) })) });
 }
 function surfaceContentKey(snapshot) {
   const { stateId, generatedAt, origin, ...content } = snapshot;
@@ -17748,7 +18027,9 @@ function audienceRank2(audience) {
   const idx = levels.indexOf(audience ?? "instance");
   return idx === -1 ? levels.indexOf("instance") : idx;
 }
+var AUDIENCE_RANKING = SURFACE_AUDIENCES.join(" < ");
 var LOCATION_FORMS = "`../sibling`, `hosted:<id>`, `<git url>` or `<git url>#<commit>`";
+var NOT_A_LOCATION = /[\s{}[\]"'`<>|*?]/;
 function refused(alias, why2) {
   return { alias, written: false, declaration: null, refusal: `The external "${alias}" was not declared: ${why2}.` };
 }
@@ -17756,11 +18037,14 @@ function requestProblem(request, config, source, sourceProblem) {
   const { alias } = request;
   if (!EXTERNAL_ALIAS_RE.test(alias)) return `an alias is [a-z0-9-_]+, and "${alias}" is not \u2014 choose one specs can write as \`${alias.toLowerCase().replace(/[^a-z0-9_-]/g, "-")}::name\``;
   if (config?.members?.[alias] !== void 0) return `"${alias}" is already declared under \`members\` \u2014 one alias names one project, so choose another alias`;
-  if (config?.externals?.[alias] !== void 0) return `"${alias}" is already declared under \`externals\` \u2014 choose another alias, or edit that declaration`;
+  if (config?.externals?.[alias] !== void 0) return `"${alias}" is already declared under \`externals\` \u2014 choose another alias, change its imports with \`wairon externals use ${alias} --add <names>\` (sdd_update_external), or remove it first with \`wairon externals remove ${alias}\``;
+  if (request.source !== void 0 && NOT_A_LOCATION.test(request.source.trim())) {
+    return `the source "${request.source}" is not a location (accepted: ${LOCATION_FORMS})`;
+  }
   if (sourceProblem) return `${sourceProblem.replace(/^its /, "the ")} (accepted: ${LOCATION_FORMS})`;
   const git2 = source?.git !== void 0;
   if (!git2 && (request.ref !== void 0 || request.dir !== void 0)) {
-    return `\`ref\` and \`dir\` apply to a git source only \u2014 write the source as ${"`<git url>`"} or ${"`<git url>#<commit>`"}`;
+    return "`ref` and `dir` apply to a git source only \u2014 write the source as `<git url>` or `<git url>#<commit>`";
   }
   if (git2 && request.ref !== void 0 && source?.ref !== void 0 && request.ref !== source.ref) {
     return `the source fixes the ref at "${source.ref}" (its \`#<commit>\`), but \`ref\` says "${request.ref}" \u2014 give one of them`;
@@ -17807,13 +18091,28 @@ function readProducer(binding) {
       const config = loadProjectConfig();
       if (!config) return { why: `${directory} holds no wairon project` };
       const floor = audienceRank2(external.audience);
-      const exported = resolveProjectExports().entries.filter((e) => audienceRank2(e.audience ?? "instance") >= floor).map((e) => e.publicName);
-      return { read: { id: effectiveProjectId(config), exported: [...new Set(exported)] } };
+      const entries = resolveProjectExports().entries;
+      const exported = entries.filter((e) => audienceRank2(e.audience ?? "instance") >= floor).map((e) => e.publicName);
+      const audiences = /* @__PURE__ */ new Map();
+      for (const e of entries) {
+        const audience = e.audience ?? "instance";
+        const held = audiences.get(e.publicName);
+        if (held === void 0 || audienceRank2(audience) > audienceRank2(held)) audiences.set(e.publicName, audience);
+      }
+      return { read: { id: effectiveProjectId(config), exported: [...new Set(exported)], audiences, audience: external.audience } };
     });
   } catch (e) {
     return { why: e instanceof Error ? e.message : String(e) };
   }
 }
+function unexportedReason(name, read2) {
+  const narrower = read2.audiences.get(name);
+  if (narrower !== void 0) {
+    const who = read2.audience === "project" ? "a project of its family" : "a path, git or hosted consumer outside its family";
+    return `the producer exports "${name}" to \`${narrower}\` only, and this project is outside it \u2014 it reads the producer at \`${read2.audience}\` (${who}); audiences, narrowest first: ${AUDIENCE_RANKING} \u2014 widen the export's audience in the producer's L0, or consume it from inside its family`;
+  }
+  return `the producer does not export "${name}" to this project${read2.exported.length ? ` (closest: ${closest(name, read2.exported).map((n) => `"${n}"`).join(", ")})` : " (it exports nothing to this project)"}`;
+}
 function contradiction(request, binding, read2) {
   const declared = request.project ?? request.alias;
   const problem = binding?.external.problem;
@@ -17825,10 +18124,7 @@ function contradiction(request, binding, read2) {
     return `the producer there answers to "${read2.id}", not "${declared}" \u2014 declare \`project: ${read2.id}\`, or use "${read2.id}" as the alias`;
   }
   const missing = (request.use ?? []).filter((u) => u !== "*" && !read2.exported.includes(u));
-  if (missing.length > 0) {
-    return missing.map((u) => `the producer does not export "${u}" to this project${read2.exported.length ? ` (closest: ${closest(u, read2.exported).map((n) => `"${n}"`).join(", ")})` : " (it exports nothing to this project)"}`).join("; ");
-  }
-  return null;
+  return missing.length > 0 ? missing.map((u) => unexportedReason(u, read2)).join("; ") : null;
 }
 function declare(request) {
   const { alias } = request;
@@ -17838,23 +18134,35 @@ function declare(request) {
   if (problem) return refused(alias, problem);
   const declaration2 = declarationOf(request, read2.source);
   const declared = request.project ?? alias;
-  if (request.dryRun) return { alias, written: false, declaration: declaration2, project: declared };
+  let binding;
+  let bindProblem = "it could not be bound";
   try {
-    declareExternal(alias, declaration2);
+    binding = resolveCandidate(alias, declaration2);
   } catch (e) {
-    return refused(alias, (e instanceof Error ? e.message : String(e)).replace(/\.$/, ""));
+    bindProblem = e instanceof Error ? e.message : String(e);
   }
-  const binding = resolveDeclared().find((b) => b.external.alias === alias);
-  const answered = binding ? readProducer(binding) : { why: "it is not among the resolved externals" };
+  const answered = binding ? readProducer(binding) : { why: bindProblem };
   const producer = "read" in answered ? answered.read : null;
   const contradicted = contradiction(request, binding, producer);
-  if (contradicted) {
-    removeExternal(alias);
-    return refused(alias, contradicted);
+  if (contradicted) return refused(alias, contradicted);
+  const why2 = "why" in answered ? answered.why : "unknown";
+  if (request.dryRun) {
+    return {
+      alias,
+      written: false,
+      declaration: declaration2,
+      project: producer?.id ?? declared,
+      ...producer ? {} : { unreachable: `its producer could not be read (${why2}), so nothing would be pinned` }
+    };
+  }
+  try {
+    declareExternal(alias, declaration2);
+  } catch (e) {
+    return refused(alias, (e instanceof Error ? e.message : String(e)).replace(/\.$/, ""));
   }
   let pin2;
   if (request.pin !== false && producer) pin2 = pinExternals([alias])[0];
-  const unreachable = producer ? void 0 : `its producer could not be read (${"why" in answered ? answered.why : "unknown"}), so nothing was pinned \u2014 it reads as unavailable, never a pass, until \`wairon externals pin ${alias}\` succeeds`;
+  const unreachable = producer ? void 0 : `its producer could not be read (${why2}), so nothing was pinned \u2014 it reads as unavailable, never a pass, until \`wairon externals pin ${alias}\` succeeds`;
   return {
     alias,
     written: true,
@@ -17864,6 +18172,77 @@ function declare(request) {
     ...unreachable ? { unreachable } : {}
   };
 }
+function remove(alias, dryRun) {
+  const config = loadProjectConfig();
+  const declared = config?.externals?.[alias] !== void 0;
+  const rows = !declared || dryRun ? listExternals() : [];
+  const pinned = rows.some((r) => r.alias === alias && r.lock !== void 0);
+  if (!declared && !pinned) {
+    const known = rows.map((r) => `"${r.alias}"`);
+    return {
+      alias,
+      removed: false,
+      unpinned: false,
+      refusal: `The external "${alias}" was not removed: it is neither declared nor pinned here \u2014 ${known.length ? `this project's externals are ${known.join(", ")}` : "this project declares no externals"}.`
+    };
+  }
+  if (dryRun) return { alias, removed: false, unpinned: pinned };
+  const removed = declared ? removeExternal(alias) : false;
+  const unpinned = unpin(alias);
+  return { alias, removed, unpinned };
+}
+function currentUse(declaration2) {
+  const use = typeof declaration2 === "object" && declaration2 !== null ? declaration2.use : void 0;
+  return Array.isArray(use) ? use.filter((u) => typeof u === "string") : [];
+}
+function useRefused(alias, use, why2) {
+  return { alias, written: false, use, added: [], removed: [], refusal: `The \`use\` of "${alias}" was not changed: ${why2}.` };
+}
+function updateUse(request) {
+  const { alias } = request;
+  const config = loadProjectConfig();
+  const existing = config?.externals?.[alias];
+  const current2 = currentUse(existing);
+  if (existing === void 0) {
+    const declared = Object.keys(config?.externals ?? {});
+    return useRefused(alias, current2, `"${alias}" is not a declared external \u2014 ${declared.length ? `this project declares ${declared.map((a) => `"${a}"`).join(", ")}` : "this project declares no externals"} (declare it with \`wairon externals add\`)`);
+  }
+  const add2 = [...new Set(request.add ?? [])];
+  const drop = [...new Set(request.remove ?? [])];
+  const bad = [...add2, ...drop].find((u) => !USE_ENTRY_RE.test(u));
+  if (bad !== void 0) return useRefused(alias, current2, `the entry "${bad}" is neither \`*\` nor a public name ([a-z0-9-_]+)`);
+  if (add2.length === 0 && drop.length === 0) return useRefused(alias, current2, "name at least one public name to add or to remove");
+  const kept = current2.filter((u) => !drop.includes(u));
+  const appended = kept.includes("*") ? [] : add2.filter((u) => !kept.includes(u));
+  const next = [...kept, ...appended];
+  const removedNames = current2.filter((u) => drop.includes(u));
+  const named2 = appended.filter((u) => u !== "*");
+  if (named2.length > 0) {
+    const binding = resolveDeclared(true).find((b) => b.external.alias === alias);
+    const answered = binding ? readProducer(binding) : null;
+    if (answered && "read" in answered) {
+      const missing = named2.filter((u) => !answered.read.exported.includes(u));
+      if (missing.length) return useRefused(alias, current2, missing.map((u) => unexportedReason(u, answered.read)).join("; "));
+    }
+  }
+  const same = next.length === current2.length && next.every((u, i) => u === current2[i]);
+  if (request.dryRun || same) return { alias, written: false, use: next, added: appended, removed: removedNames };
+  if (removedNames.length > 0) {
+    const original = typeof existing === "object" && existing !== null ? existing : {};
+    const { use: _old, ...rest } = original;
+    const restated = { ...rest, ...next.length ? { use: next } : {} };
+    removeExternal(alias);
+    try {
+      declareExternal(alias, restated);
+    } catch (e) {
+      declareExternal(alias, original);
+      return useRefused(alias, current2, (e instanceof Error ? e.message : String(e)).replace(/\.$/, ""));
+    }
+    return { alias, written: true, use: next, added: appended, removed: removedNames };
+  }
+  importNames(alias, appended);
+  return { alias, written: true, use: next, added: appended, removed: removedNames };
+}
 
 // src/core/surface-portal.ts
 function exportSurface2(maxAudience, format, outPath, portalId) {
@@ -17902,6 +18281,12 @@ function declareExternal2(request) {
 function pinnedParent2() {
   return pinnedParent();
 }
+function removeExternal2(alias, dryRun) {
+  return remove(alias, dryRun);
+}
+function updateExternalUse(request) {
+  return updateUse(request);
+}
 
 // src/core/family-validation.ts
 var fs11 = __toESM(require("fs"));
@@ -18009,11 +18394,18 @@ function findingChanges(before, after) {
 }
 
 // src/core/rules/reach-model-projector.ts
-function bindingLine(endpoint) {
+function underBase(basePath, path49) {
+  const base = (basePath ?? "").trim().replace(/\/+$/, "");
+  if (base === "" || base === "/") return path49;
+  const head2 = base.startsWith("/") ? base : `/${base}`;
+  if (path49 === head2 || path49.startsWith(`${head2}/`)) return path49;
+  return `${head2}${path49.startsWith("/") ? "" : "/"}${path49}`;
+}
+function bindingLine(endpoint, basePath) {
   if (!endpoint) return void 0;
   switch (endpoint.transport) {
     case "HTTP":
-      return `${endpoint.method} ${endpoint.path}`;
+      return `${endpoint.method} ${underBase(basePath, endpoint.path)}`;
     case "gRPC":
       return `${endpoint.service}/${endpoint.method}`;
     case "GraphQL":
@@ -18053,6 +18445,12 @@ function widestAudience(ctx, portal, interfaceId) {
 function byVerb(a, b) {
   return a.project.localeCompare(b.project) || a.portal.localeCompare(b.portal) || a.verb.localeCompare(b.verb);
 }
+function byPlacement(a, b) {
+  return a.project.localeCompare(b.project) || a.component.localeCompare(b.component);
+}
+function byTopic(a, b) {
+  return a.component.localeCompare(b.component) || a.topic.localeCompare(b.topic) || Number(a.emits) - Number(b.emits);
+}
 function byCall(a, b) {
   return a.fromProject.localeCompare(b.fromProject) || a.fromComponent.localeCompare(b.fromComponent) || a.toPortal.localeCompare(b.toPortal) || a.verb.localeCompare(b.verb) || a.evidence.localeCompare(b.evidence);
 }
@@ -18068,7 +18466,7 @@ function project(ctx, network) {
       for (const m of intf.methods) {
         const entry = componentEntryFor(comp, m.invokedBy);
         if (isOutsideEntry(entry)) outsideEntered = true;
-        const binding = comp.transport === "InProcess" ? void 0 : bindingLine(m.endpoint);
+        const binding = comp.transport === "InProcess" ? void 0 : bindingLine(m.endpoint, comp.basePath);
         const audience = widestAudience(ctx, comp.id, intf.id);
         verbs.push({
           project: "",
@@ -18117,11 +18515,32 @@ function project(ctx, network) {
       }
     }
   }
+  const placements = ctx.components.filter(isOwn2).map((c) => ({
+    project: "",
+    component: c.id,
+    ...c.subsystem !== void 0 ? { subsystem: c.subsystem } : {},
+    componentType: c.componentType
+  }));
+  const topics = [];
+  const addEnd = (component, topic, emits) => {
+    if (!topics.some((t) => t.component === component && t.topic === topic && t.emits === emits)) topics.push({ component, topic, emits });
+  };
+  for (const comp of ctx.components.filter(isOwn2)) {
+    for (const e of comp.emits ?? []) addEnd(comp.id, e.topic, true);
+    for (const e of comp.subscribesTo ?? []) addEnd(comp.id, e.topic, false);
+    for (const intf of ctx.interfacesByComponent.get(comp.id) ?? []) {
+      for (const m of intf.methods) {
+        if (m.endpoint?.transport === "MessageBus") addEnd(comp.id, m.endpoint.topic, m.endpoint.direction === "publish");
+      }
+    }
+  }
   return {
     scope: "own",
     networks: ownNetwork ? [{ ...ownNetwork, gateways: [...ownNetwork.gateways].sort() }] : [],
     verbs: verbs.sort(byVerb),
-    calls: calls.sort(byCall)
+    calls: calls.sort(byCall),
+    placements: placements.sort(byPlacement),
+    topics: topics.sort(byTopic)
   };
 }
 function qualify(projectKey, local) {
@@ -18156,21 +18575,32 @@ function compose(models, family, networks) {
   };
   const verbs = [];
   const calls = [];
+  const placements = [];
+  const topics = [];
   for (const [key2, model] of models) {
+    for (const p of model.placements ?? []) {
+      placements.push({
+        ...p,
+        project: key2,
+        component: qualify(key2, p.component),
+        ...p.subsystem !== void 0 ? { subsystem: qualify(key2, p.subsystem) } : {}
+      });
+    }
+    for (const t of model.topics ?? []) topics.push({ ...t, component: qualify(key2, t.component) });
     const net = innermost(key2);
     for (const v of model.verbs) {
       const { network: _own, ...rest } = v;
-      const placed = {
+      const placed2 = {
         ...rest,
         project: key2,
         portal: qualify(key2, v.portal),
         ...v.subsystem !== void 0 ? { subsystem: qualify(key2, v.subsystem) } : {},
         ...net !== void 0 ? { network: net } : {}
       };
-      verbs.push(placed);
-      if (net !== void 0 && placed.gateway && isOutsideEntry(placed.entry)) {
+      verbs.push(placed2);
+      if (net !== void 0 && placed2.gateway && isOutsideEntry(placed2.entry)) {
         const gateways = boundaries.get(net).gateways;
-        if (!gateways.includes(placed.portal)) gateways.push(placed.portal);
+        if (!gateways.includes(placed2.portal)) gateways.push(placed2.portal);
       }
     }
     for (const c of model.calls) {
@@ -18186,15 +18616,17 @@ function compose(models, family, networks) {
     }
   }
   const portals = new Set(verbs.map((v) => v.portal));
+  const placed = new Map(placements.map((p) => [p.component, p]));
   for (const ref of family.references) {
     if (!["call", "calls", "register", "dispatch"].includes(ref.position) || ref.member === void 0) continue;
     if (!portals.has(ref.target)) continue;
     const net = innermost(ref.consumer);
+    const caller = ref.caller ?? ref.specId;
+    const subsystem = placed.get(caller)?.subsystem;
     calls.push({
       fromProject: ref.consumer,
-      // The component whose implementation writes the call, as the
-      // reference recorded it — never guessed from a matching dependsOn.
-      fromComponent: ref.caller ?? ref.specId,
+      fromComponent: caller,
+      ...subsystem !== void 0 ? { fromSubsystem: subsystem } : {},
       ...net !== void 0 ? { fromNetwork: net } : {},
       toPortal: ref.target,
       verb: ref.member,
@@ -18205,7 +18637,9 @@ function compose(models, family, networks) {
     scope: "family",
     networks: [...boundaries.values()].map((b) => ({ ...b, gateways: [...b.gateways].sort() })).sort((a, b) => depth(a.id) - depth(b.id) || a.id.localeCompare(b.id)),
     verbs: verbs.sort(byVerb),
-    calls: calls.sort(byCall)
+    calls: calls.sort(byCall),
+    placements: placements.sort(byPlacement),
+    topics: topics.sort(byTopic)
   };
 }
 
@@ -18495,6 +18929,8 @@ function run(options) {
     issues.push(...judged.own.issues.map((i) => ({ ...i, project: ref.key })), ...judged.composed.findings);
     projects.push(verdictOf({ namespace: ref.key, directory: ref.directory }, judged.own));
   }
+  const paired = pairTopicsAcrossFamily(issues, models);
+  issues.splice(0, issues.length, ...paired);
   issues.push(...within2(root, ceiling, () => checkMembers(narrowed(family, selected))));
   issues.push(...within2(root, ceiling, () => checkPolicies(narrowed(family, selected))));
   issues.push(...within2(root, ceiling, () => checkReach(narrowed(family, selected), models)));
@@ -18523,7 +18959,11 @@ function howMoved(use) {
     const changed = use.detail?.includes("signature changed") ? " (and its signature changed)" : "";
     return `was renamed to "${use.renamedTo}"${changed}, per the producer's rename trace`;
   }
-  return "is gone from the producer's live export table";
+  return `is gone from the producer's live export table${use.detail ? ` (${use.detail})` : ""}`;
+}
+function staleTail(status) {
+  const facts = status.staleFacts ?? [];
+  return facts.length ? ` Its pinned snapshot is stale: ${facts.join(", ")} changed in the producer, and the rules judge the pin (a library's abi, an entry's transport or role) \u2014 re-pinning refreshes it.` : "";
 }
 function judgeExternal(status, project3, config) {
   const out = [];
@@ -18538,11 +18978,11 @@ function judgeExternal(status, project3, config) {
       project3
     ));
   }
-  if (broken.length === 0 && status.drifted) {
+  if (broken.length === 0 && (status.drifted || (status.staleFacts?.length ?? 0) > 0)) {
     out.push(finding(
       config,
       "EXTERNAL_DRIFTED",
-      `The producer of ${who} changed since ${named(project3)} pinned it, but nothing ${named(project3)} uses changed. Re-pin when convenient (\`wairon externals pin ${status.alias}\`).`,
+      `The producer of ${who} changed since ${named(project3)} pinned it, but nothing ${named(project3)} uses changed.${staleTail(status)} Re-pin when convenient (\`wairon externals pin ${status.alias}\`).`,
       project3
     ));
   }
@@ -18597,18 +19037,18 @@ function adviseOn(status, family, config) {
     case "incompatible": {
       const broken = status.uses.filter(isBroken);
       const users = [...new Set(broken.flatMap((u) => specsUsing(family, status.alias, u.publicName)))].sort();
-      const renamed = broken.some((u) => u.state === "renamed");
+      const renamed2 = broken.some((u) => u.state === "renamed");
       return advisory(
         config,
         "EXTERNAL_LIVE_INCOMPATIBLE",
-        `${who} moved in its live producer since it was pinned: ${broken.map(movedUse).join("; ")}. Used by ${users.length ? users.map((s) => `"${s}"`).join(", ") : "this project's references"}. Adapt the uses${renamed ? " (follow the rename)" : ""}, then re-pin with ${repin(status.alias)}. Advisory: the pin still gates.`
+        `${who} moved in its live producer since it was pinned: ${broken.map(movedUse).join("; ")}. Used by ${users.length ? users.map((s) => `"${s}"`).join(", ") : "this project's references"}. Adapt the uses${renamed2 ? " (follow the rename)" : ""}, then re-pin with ${repin(status.alias)}. Advisory: the pin still gates.`
       );
     }
     case "drifted":
       return advisory(
         config,
         "EXTERNAL_DRIFTED",
-        `The live producer of ${who} moved since it was pinned, but nothing this project uses changed. Re-pin when convenient (${repin(status.alias)}).`
+        `The live producer of ${who} moved since it was pinned, but nothing this project uses changed.${staleTail(status)} Re-pin when convenient (${repin(status.alias)}).`
       );
     case "unavailable": {
       const reason = uncomparedReason(status);
@@ -19138,7 +19578,51 @@ function reachModel(options) {
     models.set(node.namespace, within2(node.directory, ceiling, () => ownReachOf(options)));
   }
   const scoped = narrowed(family, selected);
-  return within2(root, ceiling, () => compose(models, scoped, networksOf(scoped)));
+  return within2(root, ceiling, () => {
+    const model = compose(models, scoped, networksOf(scoped));
+    return { ...model, findings: judgedFindings(model, scoped) };
+  });
+}
+function judgedFindings(model, family) {
+  const nodeOf = new Map(family.nodes.map((n) => [n.namespace, n]));
+  const configs = /* @__PURE__ */ new Map();
+  const allows = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const f of judge(model)) {
+    const project3 = projectOfFinding(model, f);
+    const node = nodeOf.get(project3);
+    if (!configs.has(project3)) configs.set(project3, node ? runWithProjectRoot(node.directory, configOrNull) : null);
+    if (!allows.has(project3)) allows.set(project3, node ? runWithProjectRoot(node.directory, lintAllows) : []);
+    const local = f.specId !== void 0 ? localKey(project3, f.specId) : void 0;
+    const tuned = finding(configs.get(project3) ?? null, f.code, f.message, project3, f.specId);
+    if (!tuned) continue;
+    const allowed = tuned.severity !== "error" && local !== void 0 && (allows.get(project3) ?? []).some((a) => a.specId === local && a.code === f.code && (a.at ?? void 0) === (f.at ?? void 0));
+    if (allowed) continue;
+    out.push({
+      severity: tuned.severity,
+      code: f.code,
+      message: f.message,
+      ...f.specId !== void 0 ? { specId: f.specId } : {},
+      ...f.at !== void 0 ? { at: f.at } : {}
+    });
+  }
+  return out;
+}
+function pairTopicsAcrossFamily(issues, models) {
+  const ends = [...models.entries()].flatMap(([project3, m]) => (m.topics ?? []).map((t) => ({ ...t, project: project3 })));
+  if (ends.length === 0) return [...issues];
+  const pairedElsewhere = (project3, component, emits) => {
+    const own2 = ends.filter((e) => e.project === project3);
+    const mine = own2.filter((e) => e.component === component && e.emits === emits).map((e) => e.topic);
+    const unpaired = mine.filter((t) => !own2.some((o) => o.topic === t && o.emits !== emits));
+    if (unpaired.length === 0) return false;
+    return unpaired.every((t) => ends.some((o) => o.project !== project3 && o.topic === t && o.emits !== emits));
+  };
+  return issues.filter((i) => {
+    if (i.code !== "UNCONSUMED_TOPIC" && i.code !== "UNSOURCED_SUBSCRIPTION") return true;
+    if (i.project === void 0 || i.specId === void 0) return true;
+    return !pairedElsewhere(i.project, i.specId, i.code === "UNCONSUMED_TOPIC");
+  });
 }
 
 // src/core/rules/index.ts
@@ -21096,8 +21580,8 @@ var publicSurfaceBindingRule = {
           ctx.addIssue("error", "PUBLIC_INTERFACE_INVALID_COMPONENT", `Subsystem "${sub.id}" public interface references component "${pi.component}" which does not exist.`, sub.id, isDraftCtx);
           continue;
         }
-        const isSubsystemOwner = backing.subsystem === sub.id || backing.subsystem.startsWith(sub.id + "::");
-        if (!isSubsystemOwner) {
+        const isSubsystemOwner2 = backing.subsystem === sub.id || backing.subsystem.startsWith(sub.id + "::");
+        if (!isSubsystemOwner2) {
           ctx.addIssue("error", "PUBLIC_INTERFACE_FOREIGN_COMPONENT", `Subsystem "${sub.id}" publishes component "${pi.component}", but it belongs to subsystem "${backing.subsystem}". A subsystem may only publish its own components.`, sub.id, isDraftCtx);
         }
       }
@@ -21136,19 +21620,23 @@ var publicSurfaceConsumersRule = {
 var implementsContractsRule = {
   name: "implements-contracts",
   judges: "design",
-  description: "An interface that declares `implements: alias::name` realizes another project's extension point, so it must declare every method of that contract with the same params and returns, read from the export the reference resolves to (a contained member's live table, or a declared external's pin). Whether the reference resolves and names an entry exported with role implement is project-boundaries' finding (EXTERNAL_NOT_EXPORTED); this rule judges the shape once it resolves. Extra methods are the implementer's own and are not reported.",
+  description: "An interface that declares `implements: alias::name` realizes another project's extension point, so it must declare every method of that contract with the same params and returns, read from the export the reference resolves to (a contained member's live table, or a declared external's pin). Types are compared semantically, never by spelling: the producer's own bare name and the consumer's `alias::name` (or the bare name its `use` imports) are one type. Whether the reference resolves and names an entry exported with role implement is project-boundaries' finding (EXTERNAL_NOT_EXPORTED); this rule judges the shape once it resolves. Extra methods are the implementer's own and are not reported.",
   codes: [
     { code: "IMPLEMENTS_MISMATCH", defaultSeverity: "error", summary: "An interface implementing an extension point lacks one of its methods, or declares one with different params or returns" }
   ],
   check(ctx) {
     for (const intf of ctx.interfaces) {
       if (intf.implements === void 0 || !ctx.isSpecInScope(intf.id)) continue;
-      const contract = extensionPoint(ctx, intf.id, intf.implements);
-      if (!contract) continue;
+      const point = extensionPoint(ctx, intf.id, intf.implements);
+      if (!point) continue;
+      const { methods: contract, publicNames } = point;
+      const alias = intf.implements.split("::")[0];
+      const expectedType = (t) => respelled(t, (n) => publicNames.get(lastName(n)) ?? lastName(n));
+      const ownType = (t) => respelled(t, (n) => n.startsWith(`${alias}::`) ? lastName(n.slice(alias.length + 2)) : n);
       const draft = intf.status === "draft" || intf.status === "design" || ctx.isComponentDraft(intf.component);
       for (const expected of contract) {
         const own2 = intf.methods.find((m) => m.name === expected.name);
-        const differs = own2 ? difference(expected, own2) : "is not declared";
+        const differs = own2 ? difference(expected, own2, expectedType, ownType) : "is not declared";
         if (!differs) continue;
         ctx.addIssue(
           "error",
@@ -21163,17 +21651,36 @@ var implementsContractsRule = {
     }
   }
 };
-function difference(expected, own2) {
-  const shape = (m) => (m.params ?? []).map((p) => `${p.type}${p.optional ? "?" : ""}`).join(", ");
-  if (shape(expected) !== shape(own2)) return `params (${shape(own2)}) instead of (${shape(expected)})`;
-  if (expected.returns !== own2.returns) return `returns ${own2.returns} instead of ${expected.returns}`;
+function lastName(name) {
+  return name.split("::").pop().split(".").pop();
+}
+function renamed(expr, rename) {
+  const args = expr.args.map((a) => renamed(a, rename));
+  return expr.form === "named" || expr.form === "applied" ? { ...expr, name: rename(expr.name), args } : { ...expr, args };
+}
+function respelled(text3, rename) {
+  const keep = (name) => isTypeVocabulary(name) ? name : rename(name);
+  const parsed = parseTypeExpression(text3, "returns");
+  if (parsed.expression) return canonicalTypeText(renamed(parsed.expression, keep));
+  return text3.replace(/[A-Za-z_][A-Za-z0-9_-]*(?:(?:::|\.)[A-Za-z_][A-Za-z0-9_-]*)*/g, keep);
+}
+function difference(expected, own2, expectedType, ownType) {
+  const shape = (m, as) => (m.params ?? []).map((p) => `${as(p.type)}${p.optional ? "?" : ""}`).join(", ");
+  const written = (m) => (m.params ?? []).map((p) => `${p.type}${p.optional ? "?" : ""}`).join(", ");
+  if (shape(expected, expectedType) !== shape(own2, ownType)) return `params (${written(own2)}) instead of (${written(expected)})`;
+  if (expectedType(expected.returns) !== ownType(own2.returns)) return `returns ${own2.returns} instead of ${expected.returns}`;
   return void 0;
 }
 function extensionPoint(ctx, specId, ref) {
   const resolution = ctx.resolveCrossProject(specId, "implements", ref);
   if (resolution && resolution.outcome !== "resolved") return void 0;
   const surface = ctx.resolveSurfaceRef(ref);
-  if (surface.kind === "resolved") return surface.entry.role === "implement" ? surface.entry.methods : void 0;
+  if (surface.kind === "resolved") {
+    if (surface.entry.role !== "implement") return void 0;
+    const publicNames2 = /* @__PURE__ */ new Map();
+    for (const t of surface.snapshot.exportedTypes ?? []) publicNames2.set(lastName(t.type), t.id);
+    return { methods: surface.entry.methods, publicNames: publicNames2 };
+  }
   const [alias, name] = ref.split("::");
   if (name === void 0) return void 0;
   const bound2 = ctx.projectFamily?.nodes.find((n) => n.namespace === "");
@@ -21182,8 +21689,13 @@ function extensionPoint(ctx, specId, ref) {
   const table = (ctx.exportTables ?? []).find((t) => t.level === "project" && t.owner === key2);
   const entry = table?.entries.find((e) => e.kind === "component" && e.publicName === name);
   if (!entry || entry.role !== "implement" || !entry.component) return void 0;
-  if (entry.interface) return ctx.interfaceMap.get(entry.interface)?.methods;
-  return ctx.interfaceMethodsOf(entry.component);
+  const methods = entry.interface ? ctx.interfaceMap.get(entry.interface)?.methods : ctx.interfaceMethodsOf(entry.component);
+  if (!methods) return void 0;
+  const publicNames = /* @__PURE__ */ new Map();
+  for (const e of table?.entries ?? []) {
+    if (e.kind === "type" && e.typeDef) publicNames.set(lastName(e.typeDef), e.publicName);
+  }
+  return { methods, publicNames };
 }
 
 // src/core/rules/integrity/public-surface-bound-contract.ts
@@ -21215,13 +21727,14 @@ var publicSurfaceBoundContractRule = {
 var exportTablesRule = {
   name: "export-tables",
   judges: "design",
-  description: "Every level's export table must resolve the way a module resolver resolves `export \u2026 from`. One public name binds one target: EXPORT_ID_DUPLICATE when two wildcards (or two explicit entries) bind a name to different targets, or two public names share one nameKey, since a bare import could not tell them apart; the name is left out. No chain leads back to itself: EXPORT_CYCLE, an error for a named chain that never reaches a component or type, a warning for a wildcard cycle, which resolves to its union. Every entry names a source and an item that exist, that the source exports and, for an own type, that the level owns (a subsystem-owned type at L1, a project-level type with no subsystem for an L0 `{ typeDef }` without `from`), under a public name of [a-z0-9-_]+ (EXPORT_INVALID). Every exported component can serve what its role promises (EXPORT_UNCONSUMABLE, at L0 and for L1 re-exports): an entry consumers call must be a Portal (a gateway being a Portal variant) or an Observer for events, and an entry consumers implement (role implement, an extension point) may also be an Adapter whose realization consumers supply. An L0 entry that re-exports a member's or an external's export never declares a wider audience than that export has (EXPORT_WIDENS_AUDIENCE): a re-export can narrow reach, never widen it. An entry's export kind is derived from its backing Portal's transport and no longer authored, so no rule compares an authored kind with the stereotype; the retired public-surface-declared-type rule and its codes are gone. The rule judges the facts the export resolver recorded in the scan, for the bound root's table and every contained member's, and resolves nothing itself.",
+  description: "Every level's export table must resolve the way a module resolver resolves `export \u2026 from`. One public name binds one target: EXPORT_ID_DUPLICATE when two wildcards (or two explicit entries) bind a name to different targets, or two public names share one nameKey, since a bare import could not tell them apart; the name is left out. No chain leads back to itself: EXPORT_CYCLE, an error for a named chain that never reaches a component or type, a warning for a wildcard cycle, which resolves to its union. Every entry names a source and an item that exist, that the source exports and, for an own type, that the level owns (a subsystem-owned type at L1, a project-level type with no subsystem for an L0 `{ typeDef }` without `from`), under a public name of [a-z0-9-_]+ (EXPORT_INVALID) \u2014 a named re-export whose source renamed the item names the new name. Every exported component can serve what its role promises (EXPORT_UNCONSUMABLE, at L0 and for L1 re-exports): an entry consumers call must be a Portal (a gateway being a Portal variant) or an Observer for events, and an entry consumers implement (role implement, an extension point) may also be an Adapter whose realization consumers supply. An L0 entry that re-exports a member's or an external's export never declares a wider audience than that export has (EXPORT_WIDENS_AUDIENCE): a re-export can narrow reach, never widen it. An own L0 entry exported to `department` is a notice (EXPORT_AUDIENCE_NARROW): outside a hosted instance only the project's family sees it, and a sibling checkout or git consumer \u2014 read at `instance` \u2014 is refused; whether its consumers are hosted cannot be told from the tree, so it never fails the gate. An entry's export kind is derived from its backing Portal's transport and no longer authored, so no rule compares an authored kind with the stereotype; the retired public-surface-declared-type rule and its codes are gone. The rule judges the facts the export resolver recorded in the scan, for the bound root's table and every contained member's, and resolves nothing itself.",
   codes: [
     { code: "EXPORT_ID_DUPLICATE", defaultSeverity: "error", summary: "One public name bound to different targets by two wildcard re-exports or two explicit entries" },
     { code: "EXPORT_CYCLE", defaultSeverity: "error", summary: "A re-export chain leads back to itself (a warning for a wildcard cycle, which resolves to its union)" },
     { code: "EXPORT_INVALID", defaultSeverity: "error", summary: "An export entry names a missing source or item, an item its source does not export or its level does not own, or a malformed public name" },
     { code: "EXPORT_UNCONSUMABLE", defaultSeverity: "error", summary: "An exported component that cannot serve its role: called but neither a Portal nor an Observer, or implemented but neither a Portal nor an Adapter" },
-    { code: "EXPORT_WIDENS_AUDIENCE", defaultSeverity: "error", summary: "An L0 entry declares a wider audience than the member or external export it re-exports" }
+    { code: "EXPORT_WIDENS_AUDIENCE", defaultSeverity: "error", summary: "An L0 entry declares a wider audience than the member or external export it re-exports" },
+    { code: "EXPORT_AUDIENCE_NARROW", defaultSeverity: "notice", summary: "An L0 entry is exported to `department`: outside a hosted instance only this project's family sees it, and a path or git consumer is refused" }
   ],
   check(ctx) {
     const tables = ctx.exportTables;
@@ -21254,6 +21767,19 @@ var exportTablesRule = {
         }
       }
     }
+    const own2 = tables.find((t) => t.level === "project" && t.owner === ctx.system.name);
+    for (const entry of own2?.entries ?? []) {
+      if ((entry.audience ?? "instance") !== "department") continue;
+      ctx.addIssue(
+        "notice",
+        "EXPORT_AUDIENCE_NARROW",
+        `The project's L0 export table exports "${entry.publicName}" to \`department\`. A path, git or hosted consumer outside this project's family reads it at \`instance\` and is refused it (\`externals add\` says so); only this project's family sees it locally, and, on a hosted instance, the units of the owning department \u2014 which of those its consumers are cannot be told from this tree. Audiences, narrowest first: project < department < instance < partner < external. Widen it to \`instance\` if a sibling checkout or a git consumer uses it, or keep it (and allow this notice) when its consumers are hosted department units.`,
+        own2.owner,
+        false,
+        void 0,
+        { at: entry.publicName }
+      );
+    }
   }
 };
 
@@ -21278,10 +21804,11 @@ var externalDeclarationsRule = {
       if (external.sourceKind !== "unresolved") continue;
       if (pinned.get(external.alias)?.snapshot && !external.problem?.startsWith("the `use`") && !isMalformed(external.problem)) continue;
       reported.add(external.alias);
+      const unpinnedOutside = external.problem?.startsWith("no project of the family answers") && !pinned.get(external.alias)?.snapshot;
       ctx.addIssue(
         "notice",
         "EXTERNAL_UNRESOLVED",
-        `This project's .wai/project.yaml declares the external "${external.alias}" (producer "${external.project}"), which does not resolve: ${external.problem}. Fix the alias or the producer id, add \`source: { path: <the producer's root> }\` to say where it lives, or pin it (\`wairon externals pin\`) so this project's gate has something to judge it against.`
+        unpinnedOutside ? `This project's .wai/project.yaml declares the external "${external.alias}" (producer "${external.project}"), which this project's own gate cannot resolve: no project this root contains answers to "${external.project}", and nothing is pinned for it. A parent or sibling is never climbed to from a project's own gate \u2014 its pin is the one thing the gate judges it against. Pin it here (\`wairon externals pin ${external.alias}\`), or give it \`source: { path: <the producer's root> }\`.` : `This project's .wai/project.yaml declares the external "${external.alias}" (producer "${external.project}"), which does not resolve: ${external.problem}. Fix the alias or the producer id, add \`source: { path: <the producer's root> }\` to say where it lives, or pin it (\`wairon externals pin\`) so this project's gate has something to judge it against.`
       );
     }
     for (const problem of family.problems) {
@@ -21477,6 +22004,50 @@ function label(node, namespace) {
   const id = node.id ?? node.name ?? "(no id)";
   return node.namespace === "" ? `"${id}"` : `"${id}" (keyed "${node.namespace}")`;
 }
+function lastSegment3(id) {
+  return id.split("::").pop().split(".").pop();
+}
+function distance2(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const next = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = row[j];
+      row[j] = next;
+    }
+  }
+  return row[b.length];
+}
+function didYouMean(ctx, ref) {
+  const written = lastSegment3(ref.authored);
+  const key2 = nameKey(written);
+  let names = [];
+  let renamedTo;
+  const table = ref.producer !== void 0 ? (ctx.exportTables ?? []).find((t) => t.level === "project" && t.owner === ref.producer) : void 0;
+  if (table) {
+    names = table.entries.map((e) => e.publicName);
+    const traced2 = (holder) => (holder?.previousIds ?? []).some((p) => nameKey(lastSegment3(p)) === key2);
+    for (const e of table.entries) {
+      const holder = e.kind === "type" ? ctx.types.find((t) => t.id === e.typeDef || t.id === `${ref.producer}::${e.typeDef}`) : e.interface !== void 0 ? ctx.interfaceMap.get(e.interface) : ctx.componentMap.get(e.component ?? "");
+      if (traced2(holder)) {
+        renamedTo = e.publicName;
+        break;
+      }
+    }
+  } else {
+    const alias = ref.authored.includes("::") ? ref.authored.split("::")[0] : void 0;
+    const pin2 = alias !== void 0 ? ctx.pinnedExternals.find((p) => p.alias === alias)?.snapshot : void 0;
+    if (pin2) {
+      names = [...pin2.interfaces.map((e) => e.id), ...(pin2.exportedTypes ?? []).map((t) => t.id)];
+      renamedTo = pin2.interfaces.find((e) => (e.formerly ?? []).some((f) => nameKey(f) === key2))?.id ?? (pin2.exportedTypes ?? []).find((t) => (pin2.types.find((d) => d.id === t.type)?.formerly ?? []).some((f) => nameKey(f) === key2))?.id ?? pin2.unresolvedExports?.find((u) => nameKey(u.id) === key2)?.renamedTo;
+    }
+  }
+  if (renamedTo !== void 0 && renamedTo !== written) return ` It was renamed to "${renamedTo}" (the producer's rename trace records "${written}") \u2014 did you mean "${renamedTo}"?`;
+  const close2 = [...new Set(names)].filter((n) => n !== written).sort((a, b) => distance2(written, a) - distance2(written, b) || (a < b ? -1 : 1)).filter((n) => distance2(written, n) <= Math.max(2, Math.floor(written.length / 2))).slice(0, 3);
+  return close2.length ? ` Did you mean ${close2.map((n) => `"${n}"`).join(" or ")}?` : "";
+}
 function declaration(producer) {
   const id = producer?.id;
   if (!id || !PROJECT_ID_RE.test(id)) return "an `externals` entry naming it (it has no usable id yet \u2014 declare one first)";
@@ -21517,7 +22088,7 @@ var projectBoundariesRule = {
           ctx.addIssue(
             "error",
             "EXTERNAL_NOT_EXPORTED",
-            `${where}, which reaches "${resolution.canonicalTarget}" at no public name the referrer may see: ${resolution.reason}. Another project may reach it only through a public name of its L0 table whose audience covers the referrer \u2014 export it from that project's L0 (a project-level type takes one own \`{ typeDef }\` entry) and re-pin, or reach it by a name the producer exports.`,
+            `${where}, which reaches "${resolution.canonicalTarget}" at no public name the referrer may see: ${resolution.reason}.${didYouMean(ctx, ref)} Another project may reach it only through a public name of its L0 table whose audience covers the referrer \u2014 export it from that project's L0 (a project-level type takes one own \`{ typeDef }\` entry) and re-pin, or reach it by a name the producer exports.`,
             ref.specId,
             draft,
             resolution
@@ -22553,10 +23124,10 @@ var portalFieldsRule = {
   name: "portal-fields",
   judges: "design",
   scope: "spec",
-  description: "A Portal declares its transport (the retired portalType is read as it for one release); only an InProcess Portal may declare an abi. Non-Portal components carry no transport, abi, basePath, auth or Portal-level invokedBy entry (auth is inbound transport auth: it belongs on the Portal that exposes the surface; an entry on a non-Portal is entry-declarations' ENTRY_ON_NON_PORTAL). Intrinsic to one component: no tree required.",
+  description: "A Portal declares its transport (the retired portalType is read as it for one release); only an InProcess Portal may declare an abi. An Adapter may declare a transport: the one it calls its target Portal over (adapter-transport judges it against the target). Every other non-Portal component carries no transport, and no non-Portal carries an abi, basePath, auth or Portal-level invokedBy entry (auth is inbound transport auth: it belongs on the Portal that exposes the surface; an entry on a non-Portal is entry-declarations' ENTRY_ON_NON_PORTAL). Intrinsic to one component: no tree required.",
   codes: [
     { code: "MISSING_PORTAL_TRANSPORT", defaultSeverity: "error", summary: "Portal without a transport" },
-    { code: "UNEXPECTED_PORTAL_FIELD", defaultSeverity: "error", summary: "Non-Portal component with transport, abi or basePath, or an abi on a Portal whose transport is not InProcess" },
+    { code: "UNEXPECTED_PORTAL_FIELD", defaultSeverity: "error", summary: "Non-Portal component with an abi or basePath, or a transport on one that is not an Adapter, or an abi on a Portal whose transport is not InProcess" },
     { code: "AUTH_ON_NON_PORTAL", defaultSeverity: "warning", summary: "Non-Portal component declaring auth (auth is inbound transport auth, only meaningful on a Portal)" }
   ],
   check(ctx) {
@@ -22583,11 +23154,12 @@ var portalFieldsRule = {
         }
         continue;
       }
-      if (comp.transport !== void 0 || comp.abi !== void 0 || comp.basePath !== void 0) {
+      const strayTransport = comp.transport !== void 0 && comp.componentType !== "Adapter";
+      if (strayTransport || comp.abi !== void 0 || comp.basePath !== void 0) {
         ctx.addIssue(
           "error",
           "UNEXPECTED_PORTAL_FIELD",
-          `Component "${comp.id}" is a ${comp.componentType}, not a Portal, but has "transport", "abi" or "basePath" configured. They are Portal-only \u2014 drop them, or make this component a Portal.`,
+          `Component "${comp.id}" is a ${comp.componentType}, not a Portal, but has "transport", "abi" or "basePath" configured. abi and basePath are Portal-only, and a transport belongs to a Portal (or to an Adapter, as the one it calls its target over) \u2014 drop them, or make this component a Portal.`,
           comp.id,
           isDraftCtx
         );
@@ -24531,6 +25103,48 @@ var networkBoundariesRule = {
   }
 };
 
+// src/core/rules/wiring/adapter-transport.ts
+var adapterTransportRule = {
+  name: "adapter-transport",
+  judges: "design",
+  description: "An Adapter calls a verb on its target Portal's interface, so its transport is the target's: inferred from the target Portal when the Adapter states none (HTTP for an HTTP API, a database connection for a database Portal, ...). An Adapter MAY state its own transport; when it does and a Portal it calls (one it names in dependsOn, or the target of one of its call, register or dispatch steps or declared calls) has another transport, that is ADAPTER_TRANSPORT_MISMATCH, one finding per target \u2014 so changing a Portal's transport shows its impact on every Adapter that calls it. A Portal the tree cannot resolve (an external one) is not judged here. Reads the components and narratives of the tree.",
+  codes: [
+    { code: "ADAPTER_TRANSPORT_MISMATCH", defaultSeverity: "error", summary: "An Adapter states a transport other than the transport of a Portal it calls" }
+  ],
+  check(ctx) {
+    for (const adapter of ctx.components.filter((c) => c.componentType === "Adapter" && c.transport !== void 0)) {
+      const targets = /* @__PURE__ */ new Map();
+      const consider = (id) => {
+        if (!id) return;
+        const target = ctx.componentMap.get(id);
+        if (target?.componentType === "Portal" && target.transport !== void 0) targets.set(target.id, target);
+      };
+      for (const dep of adapter.dependsOn ?? []) consider(dep);
+      for (const impl of ctx.implementations) {
+        if (ctx.interfaceMap.get(impl.contract)?.component !== adapter.id) continue;
+        for (const method of impl.methods) {
+          for (const step of method.narrative) {
+            if (step.type === "call" || step.type === "register" || step.type === "dispatch") consider(step.targetComponent);
+          }
+          for (const entry of method.calls ?? []) consider(parseDeclaredCall(entry)?.compId);
+        }
+      }
+      for (const target of [...targets.values()].sort((a, b) => a.id.localeCompare(b.id))) {
+        if (target.transport === adapter.transport) continue;
+        ctx.addIssue(
+          "error",
+          "ADAPTER_TRANSPORT_MISMATCH",
+          `Adapter "${adapter.id}" states transport "${adapter.transport}", but it calls Portal "${target.id}", whose transport is "${target.transport}": an Adapter calls its target's verbs over the target's transport. Follow the Portal's transport (set "${target.transport}"), or drop the Adapter's transport to take its target's.`,
+          adapter.id,
+          ctx.isComponentDraft(adapter.id),
+          void 0,
+          { at: target.id }
+        );
+      }
+    }
+  }
+};
+
 // src/core/rules/narrative-graph-projector.ts
 var methodKey = (compId, methodName) => `${compId}#${methodName}`;
 function stepEdges(step, ctx, followRegisterEdges) {
@@ -24729,6 +25343,10 @@ function portalScopeHint(comp) {
 }
 
 // src/core/rules/wiring/invoked-by-description.ts
+function floorNote(caller) {
+  const length = (caller ?? "").trim().length;
+  return ` (the floor: at least 40 characters once trimmed, and more than the method's own name \u2014 this caller has ${length})`;
+}
 var invokedByDescriptionRule = {
   name: "invoked-by-description",
   judges: "design",
@@ -24747,7 +25365,7 @@ var invokedByDescriptionRule = {
         ctx.addIssue(
           "warning",
           "INVOKED_BY_UNDESCRIBED",
-          `Method "${m.name}" on component "${intf.component}" declares invokedBy (${m.invokedBy.kind}) but its "caller" prose is missing or placeholder-thin \u2014 state WHO invokes it and when, so the entrypoint claim stays reviewable.`,
+          `Method "${m.name}" on component "${intf.component}" declares invokedBy (${m.invokedBy.kind}) but its "caller" prose is missing or placeholder-thin${floorNote(m.invokedBy.caller)} \u2014 state WHO invokes it and when, so the entrypoint claim stays reviewable.`,
           intf.id,
           isDraftCtx
         );
@@ -24759,7 +25377,7 @@ var invokedByDescriptionRule = {
       ctx.addIssue(
         "warning",
         "INVOKED_BY_UNDESCRIBED",
-        `Portal "${comp.id}" declares invokedBy (${comp.invokedBy.kind}) for every verb, but its "caller" prose is missing or placeholder-thin \u2014 state WHO reaches the Portal and how, so the entry claim stays reviewable.`,
+        `Portal "${comp.id}" declares invokedBy (${comp.invokedBy.kind}) for every verb, but its "caller" prose is missing or placeholder-thin${floorNote(comp.invokedBy.caller)} \u2014 state WHO reaches the Portal and how, so the entry claim stays reviewable.`,
         comp.id,
         ctx.isComponentDraft(comp.id)
       );
@@ -25314,7 +25932,7 @@ var sourceFileLinkageRule = {
       ctx.addIssue(
         "warning",
         "CONFORMANCE_DEGRADED",
-        `${degradedTsFiles.length} TypeScript/JavaScript source file(s) were analyzed below exact grade \u2014 the TypeScript compiler could not be resolved from the analyzed project or the wairon installation. Structural findings carry their grade, but dependency conformance skips these files. Install "typescript" in the analyzed project to restore exact analysis.`
+        `${degradedTsFiles.length} TypeScript/JavaScript source file(s) were analyzed below exact grade \u2014 no TypeScript compiler API could be loaded from the analyzed project or the wairon installation: either no \`typescript\` package is installed there, or the installed one ships no JavaScript compiler API (TypeScript 7's native compiler has none; this analyzer reads the TypeScript 5.x API). Structural findings carry their grade, but dependency conformance skips these files. To restore exact analysis, make a TypeScript 5.x package resolvable from the analyzed project (\`npm i -D typescript@5\`) \u2014 on TypeScript 7, check \`node -e "console.log(typeof require('typescript').createSourceFile)"\` prints function.`
       );
     }
     for (const impl of ctx.implementations) {
@@ -25535,6 +26153,9 @@ function closedCallSites(code, file, fn, stopAt, container) {
   }
   return out;
 }
+function isRemoteLink(caller, target) {
+  return caller.componentType === "Adapter" && target.componentType === "Portal" && target.transport !== void 0 && target.transport !== "InProcess";
+}
 var anchorKey = (symbol, exportedVia) => exportedVia !== void 0 ? `${exportedVia}.${symbol}` : symbol;
 var bodyKey = (file, symbol, exportedVia) => `${file}|${anchorKey(symbol, exportedVia)}`;
 function resolveCallTarget(ctx, componentId, methodName) {
@@ -25665,6 +26286,7 @@ var callConformanceRule = {
       const missed = [];
       for (const claim of claimsOf(implMethod)) {
         if (!ctx.componentMap.has(claim.component)) continue;
+        if (isRemoteLink(component, ctx.componentMap.get(claim.component))) continue;
         const target = resolveCallTarget(ctx, claim.component, claim.method);
         if (target.bodies.has(bodyKey(here, fnSymbol, implMethod.exportedVia))) continue;
         const sharedBody = targetForwards(code, target);
@@ -25822,9 +26444,11 @@ var hiddenStateRule = {
 var dependencyConformanceRule = {
   name: "dependency-conformance",
   judges: "code",
-  description: "Code\u2194spec Level 2: runtime import edges between component-mapped source files (a component maps to every file its implementations and their methods name) must be justified by declared relations \u2014 a direct dependsOn/owns pair, a shared component, membership in a depended-on pattern, or (across subsystems) a declared edge to the target subsystem's published surface (UNDECLARED_DEPENDENCY). Conversely, a declared dependsOn/owns edge between components realized in different files should be visible as an import between any file of the source and any file of the target (UNREALIZED_DEPENDENCY \u2014 DI indirection can defeat this, hence warning). A type-only import never accuses, but it does realize a declared edge: a constructor-injected collaborator is reached through its type, and `import type` is what dependency injection writes down. Only exact-grade analyzed files participate; chained subprojects validate standalone.",
+  description: "Code\u2194spec Level 2: runtime import edges between component-mapped source files (a component maps to every file its implementations and their methods name) must be justified by declared relations \u2014 a direct dependsOn/owns pair, a shared component, membership in a depended-on pattern, or (across subsystems) a declared edge to the target subsystem's published surface (UNDECLARED_DEPENDENCY). A type-only import alone never accuses \u2014 type coupling is allowed \u2014 but a CALL of a modelled contract method through a collaborator whose declared type comes from another component's file is runtime collaboration whatever the import's form, and the same justification is owed (UNDECLARED_DEPENDENCY on that edge). Conversely, a declared dependsOn/owns edge between components realized in different files should be visible as an import between any file of the source and any file of the target (UNREALIZED_DEPENDENCY \u2014 DI indirection can defeat this, hence warning); a type-only import realizes it, since `import type` is what dependency injection writes down. Two twins of design rules are judged on the same code: a Portal file calling a write- or lifecycle-effect contract method of a Repository, Index, Store or Registry is the persistence shortcut the design rule PORTAL_WRITE_SHORTCUT refuses, unless the Portal's own narrative already claims that call (the design rule's finding then) (PORTAL_WRITE_SHORTCUT_IN_CODE); and a file importing a technology's package \u2014 a bare specifier whose package name is one of the technology's declared tokens (its name, or its `matches` when it declares them), compared exactly, never guessed \u2014 while no component it realizes is that technology's home is the leak TECH_LEAKAGE refuses in the design (TECH_LEAKAGE_IN_CODE). Only exact-grade analyzed files participate; chained subprojects validate standalone.",
   codes: [
-    { code: "UNDECLARED_DEPENDENCY", defaultSeverity: "warning", summary: "A runtime import between component-mapped files has no declared dependsOn/owns (or published-surface) justification" },
+    { code: "UNDECLARED_DEPENDENCY", defaultSeverity: "warning", summary: "A runtime import, or a call through a type-only-imported collaborator, between component-mapped files has no declared dependsOn/owns (or published-surface) justification" },
+    { code: "PORTAL_WRITE_SHORTCUT_IN_CODE", defaultSeverity: "error", summary: "A Portal's code calls a write- or lifecycle-effect method of a data component (Repository, Index, Store, Registry) directly \u2014 the code twin of PORTAL_WRITE_SHORTCUT: mutations route through an Orchestrator" },
+    { code: "TECH_LEAKAGE_IN_CODE", defaultSeverity: "warning", summary: "A source file imports a technology's package although no component it realizes binds that technology \u2014 the code twin of TECH_LEAKAGE" },
     { code: "UNREALIZED_DEPENDENCY", defaultSeverity: "warning", summary: "A declared dependsOn/owns edge between components in different files is realized by no import between any of their files" }
   ],
   check(ctx) {
@@ -25940,6 +26564,149 @@ var dependencyConformanceRule = {
         );
       }
     }
+    const DATA_COMPONENTS2 = /* @__PURE__ */ new Set(["Repository", "Index", "Store", "Registry"]);
+    const calledMethodOf = (componentId, name) => {
+      const methods = ctx.interfaceMethodsOf(componentId);
+      const direct = methods.find((m) => m.name === name);
+      if (direct) return { name: direct.name, effect: direct.effect };
+      for (const impl of realization.implementationsOf(componentId)) {
+        const bound2 = impl.methods.find((m) => m.symbol === name);
+        if (bound2) {
+          const contract = methods.find((m) => m.name === bound2.name);
+          return { name: bound2.name, effect: contract?.effect };
+        }
+      }
+      return void 0;
+    };
+    const claims = (portalId, target, method) => realization.implementationsOf(portalId).some((impl) => impl.methods.some((m) => m.narrative.some((step) => step.targetComponent === target && step.targetMethod === method) || (m.calls ?? []).includes(`${target}.${method}`)));
+    const typedLandings = (site, file) => {
+      const scope = pathKey(site.from ?? file);
+      const facts = code.factsAt(scope);
+      if (!facts || !site.member) return [];
+      let typeNames = [];
+      if (site.field) typeNames = fieldTypesOf(facts, site.field);
+      else if (site.via && !importBindingOf(facts, site.via)) typeNames = localTypesOf(facts, site.via);
+      const out = [];
+      for (const typeName of typeNames) {
+        const typeOnly = facts.typeOnlyBindings?.[typeName];
+        const runtime = typeOnly === void 0 ? importBindingOf(facts, typeName) : void 0;
+        const specifier = typeOnly ?? (runtime && !runtime.namespace ? runtime.from : void 0);
+        if (!specifier) continue;
+        const toPath = resolveImport(scope, specifier, mappedPaths, code.packages);
+        if (toPath && toPath !== scope) out.push({ toPath, typeOnly: typeOnly !== void 0 });
+      }
+      return out;
+    };
+    const calledAt = (toPath, name) => realization.componentsAt(toPath).map((c) => ({ component: c, method: calledMethodOf(c.id, name) })).filter((c) => c.method !== void 0);
+    const reportedEdges = /* @__PURE__ */ new Set();
+    const reportedWrites = /* @__PURE__ */ new Set();
+    for (const fromPath of mappedPaths) {
+      const facts = code.factsAt(fromPath);
+      const fromComponents = realization.componentsAt(fromPath);
+      if (!facts || fromComponents.length === 0) continue;
+      for (const portal of fromComponents.filter((c) => c.componentType === "Portal")) {
+        for (const impl of realization.implementationsOf(portal.id)) {
+          for (const method of impl.methods) {
+            if (pathKey(methodSourceFile(method, impl.sourcePath) ?? "") !== fromPath) continue;
+            const sites = closedCallSites(code, fromPath, method.symbol ?? method.name, void 0, method.exportedVia) ?? [];
+            for (const site of sites) {
+              if (!site.member || pathKey(site.from ?? fromPath) !== fromPath) continue;
+              const landings = /* @__PURE__ */ new Set([...typedLandings(site, fromPath).map((l) => l.toPath), ...code.originOf(site, fromPath)]);
+              for (const toPath of landings) {
+                if (toPath === fromPath) continue;
+                for (const { component: target, method: called } of calledAt(toPath, site.name)) {
+                  if (!DATA_COMPONENTS2.has(target.componentType)) continue;
+                  if (called.effect !== "write" && called.effect !== "lifecycle") continue;
+                  if (claims(portal.id, target.id, called.name)) continue;
+                  const at = `${fromPath} -> ${target.id}.${called.name}`;
+                  if (reportedWrites.has(at)) continue;
+                  reportedWrites.add(at);
+                  ctx.addIssue(
+                    "error",
+                    "PORTAL_WRITE_SHORTCUT_IN_CODE",
+                    `Portal "${portal.id}": its method "${method.name}" in "${fromPath}" calls ${called.effect}-effect method ${target.id}.${called.name} directly (\`${site.via ?? (site.field ? `this.${site.field}` : "<receiver>")}.${site.name}(\u2026)\`), which its design never narrates \u2014 the code twin of PORTAL_WRITE_SHORTCUT. A Portal may reach a data component for READS only: route the ${called.effect === "write" ? "write" : "lifecycle change"} through an Orchestrator that owns the workflow.`,
+                    impl.id,
+                    draftAt(fromPath) || draftAt(toPath),
+                    void 0,
+                    { at }
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+      const runtime = graph2.importsOf(fromPath);
+      for (const sites of Object.values(facts.functionCallSites ?? {})) {
+        for (const site of sites) {
+          for (const { toPath, typeOnly } of typedLandings(site, fromPath)) {
+            if (!typeOnly || runtime.has(toPath)) continue;
+            const called = calledAt(toPath, site.name);
+            if (called.length === 0) continue;
+            const toComponents = realization.componentsAt(toPath);
+            if (edgeJustified(fromComponents, toComponents)) continue;
+            const edge = `${fromPath} -> ${toPath}`;
+            if (reportedEdges.has(edge)) continue;
+            reportedEdges.add(edge);
+            ctx.addIssue(
+              "warning",
+              "UNDECLARED_DEPENDENCY",
+              `"${fromPath}" (realizing ${fromComponents.map((c) => c.id).join(", ")}) calls ${called.map((c) => `${c.component.id}.${c.method.name}`).join(", ")} through a collaborator typed by a type-only import of "${toPath}" (realizing ${toComponents.map((c) => c.id).join(", ")}), but no declared dependsOn/owns edge justifies it \u2014 a call through an injected collaborator is runtime collaboration whatever the import's form. Declare the collaboration on the component that uses it, or route the cross-subsystem hop through the target's published surface.`,
+              realization.implementationsAt(fromPath)[0]?.id,
+              draftAt(fromPath) || draftAt(toPath),
+              void 0,
+              { at: edge }
+            );
+          }
+        }
+      }
+    }
+    const homes = /* @__PURE__ */ new Map();
+    for (const impl of ctx.implementations) {
+      const technologies = impl.technologies ?? [];
+      if (technologies.length === 0) continue;
+      const contract = ctx.interfaceMap.get(impl.contract);
+      const owner = contract ? ctx.componentMap.get(contract.component) : void 0;
+      if (!owner) continue;
+      const members = /* @__PURE__ */ new Set([owner.id, ...owner.owns ?? []]);
+      const facade = ownerOf4.get(owner.id);
+      if (facade) members.add(facade.id);
+      for (const technology of technologies) {
+        for (const token of technologyTokens(technology)) {
+          const key2 = token.toLowerCase();
+          const entry = homes.get(key2) ?? { label: technologyName(technology), home: /* @__PURE__ */ new Set() };
+          for (const id of members) entry.home.add(id);
+          homes.set(key2, entry);
+        }
+      }
+    }
+    if (homes.size > 0) {
+      for (const file of mappedPaths) {
+        const facts = code.factsAt(file);
+        if (!facts) continue;
+        const atFile = realization.componentsAt(file);
+        const specifiers = /* @__PURE__ */ new Set([...facts.imports, ...Object.values(facts.typeOnlyBindings ?? {})]);
+        const reported = /* @__PURE__ */ new Set();
+        for (const specifier of specifiers) {
+          if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("node:")) continue;
+          if (resolveImport(file, specifier, code.paths, code.packages)) continue;
+          const parts = specifier.split("/");
+          const pkg = (specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0]).toLowerCase();
+          const tech = homes.get(pkg);
+          if (!tech || reported.has(pkg) || atFile.some((c) => tech.home.has(c.id))) continue;
+          reported.add(pkg);
+          ctx.addIssue(
+            "warning",
+            "TECH_LEAKAGE_IN_CODE",
+            `"${file}" (realizing ${atFile.map((c) => c.id).join(", ")}) imports "${specifier}", the package of technology "${tech.label}", whose home is ${[...tech.home].join(", ")} \u2014 the code twin of TECH_LEAKAGE. Move the vendor call behind the component that binds it, or bind the technology where it is really used.`,
+            realization.implementationsAt(file)[0]?.id,
+            draftAt(file),
+            void 0,
+            { at: `${file} -> ${pkg}` }
+          );
+        }
+      }
+    }
   }
 };
 
@@ -26613,16 +27380,16 @@ var paramConformanceRule = {
           { at: method.name, covers: undeclared.map((found) => found.unit) }
         );
       }
-      const renamed = agreed(judgements, "renamed");
-      if (renamed.length > 0) {
+      const renamed2 = agreed(judgements, "renamed");
+      if (renamed2.length > 0) {
         ctx.addIssue(
           "warning",
           "PARAM_NAME_MISMATCH",
-          `Method "${method.name}" of contract "${implementation.contract}" and ${subject} agree on position and type but not on name for ${renamed.length} parameter(s) \u2014 ${renamed.map((f) => f.told).join("; ")}. The contract, the ERD and every brief carry one word and the code answers to another, which is a rename nobody recorded rather than a different argument \u2014 the declared type agreeing is what says so. Rename one side to the other.`,
+          `Method "${method.name}" of contract "${implementation.contract}" and ${subject} agree on position and type but not on name for ${renamed2.length} parameter(s) \u2014 ${renamed2.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,
           draftContext4,
           void 0,
-          { at: method.name, covers: renamed.map((found) => found.unit) }
+          { at: method.name, covers: renamed2.map((found) => found.unit) }
         );
       }
       const disagreed = agreed(judgements, "optionality");
@@ -28348,6 +29115,7 @@ var SDD_RULES = [
   invokedByDescriptionRule,
   reachabilityRule,
   networkBoundariesRule,
+  adapterTransportRule,
   unusedTypesRule,
   // The declaration (spec-scoped, refused at the write boundary) before the
   // round-trip consequences it enables.
@@ -28697,7 +29465,9 @@ function resolveTypeScript(projectRoot) {
   for (const base of bases) {
     try {
       const req = (0, import_module2.createRequire)(base);
-      ts = req("typescript");
+      const candidate = req("typescript");
+      if (typeof candidate?.createSourceFile !== "function") continue;
+      ts = candidate;
       break;
     } catch {
     }
@@ -30703,19 +31473,19 @@ function measure(candidate) {
   const config = loadProjectConfig();
   if (!config) throw new Error("Not inside a wairon project: a pack impact is measured on a project \u2014 run `wairon init` first.");
   const entry = candidate.entry;
-  const remove2 = candidate.remove === true;
-  let next = entry !== void 0 ? withPack(config, entry, remove2) : config;
+  const remove3 = candidate.remove === true;
+  let next = entry !== void 0 ? withPack(config, entry, remove3) : config;
   if (candidate.projectType !== void 0) next = { ...next, projectType: candidate.projectType };
   const current2 = entry !== void 0 ? (config.extensions?.packs ?? []).find((e) => sameEntry(e, entry)) : void 0;
   let manifest = null;
-  if (candidate.manifest && !remove2 || entry === void 0) {
+  if (candidate.manifest && !remove3 || entry === void 0) {
     manifest = candidate.manifest ?? null;
   } else {
-    const measured = remove2 ? current2 ?? entry : entry;
+    const measured = remove3 ? current2 ?? entry : entry;
     manifest = manifestOf(measured);
     if (!manifest) throw new Error(`Cannot measure the pack: ${unresolvedReason(config, measured)}`);
   }
-  const previous = !remove2 && current2 !== void 0 ? manifestOf(current2) : null;
+  const previous = !remove3 && current2 !== void 0 ? manifestOf(current2) : null;
   const baseline = defaultsBaseline();
   const doctrine2 = manifest ? doctrineChanges(manifest, baseline) : [];
   const previousDoctrine = previous ? doctrineChanges(previous, baseline) : void 0;
@@ -30731,11 +31501,11 @@ function measure(candidate) {
   return {
     pack: manifest?.name ?? (entry !== void 0 ? entryName(entry) : `projectType ${next.projectType}`),
     ...manifest?.version ? { version: manifest.version } : {},
-    ...!remove2 && current2 !== void 0 && replaces ? { replaces } : {},
-    direction: remove2 ? "remove" : "apply",
+    ...!remove3 && current2 !== void 0 && replaces ? { replaces } : {},
+    direction: remove3 ? "remove" : "apply",
     doctrine: doctrine2,
-    ...previousDoctrine && !remove2 ? { previousDoctrine } : {},
-    governing: governingProfiles(manifest, remove2 ? config : next),
+    ...previousDoctrine && !remove3 ? { previousDoctrine } : {},
+    governing: governingProfiles(manifest, remove3 ? config : next),
     findings: findingChanges(before, after),
     before: totals(config, before),
     after: totals(next, after)
@@ -30749,9 +31519,11 @@ function doctrine(manifest) {
 
 // src/core/rules/gate-identity.ts
 var crypto4 = __toESM(require("crypto"));
-var GATE_ALGORITHM = "sha256+design+doctrine+inputs+members";
+var GATE_ALGORITHM = "sha256+design-2+doctrine+inputs+members";
+var EARLIER_DESIGN_GATE_ALGORITHM = "sha256+design+doctrine+inputs+members";
 var CONTENT_GATE_ALGORITHM = "sha256+content+doctrine+inputs+members";
-var DESIGN_CONTENT_ALGORITHM = "sha256-design";
+var DESIGN_CONTENT_ALGORITHM = "sha256-design-2";
+var EARLIER_DESIGN_CONTENT_ALGORITHM = "sha256-design";
 var byKey2 = (items, key2) => [...items].sort((a, b) => compareOrdinal(key2(a), key2(b)));
 function ruleIdentities(rules) {
   return byKey2(
@@ -30841,7 +31613,8 @@ function computeGateIdentity(content, doctrine2, builtinRules, inputs, gate, mem
     members: byKey2(Object.entries(members), ([alias]) => alias).map(([alias, subject]) => ({ alias, subject }))
   };
   const digest3 = crypto4.createHash("sha256").update(canonicalize(payload)).digest("hex");
-  return { algorithm: content.algorithm === DESIGN_CONTENT_ALGORITHM ? GATE_ALGORITHM : CONTENT_GATE_ALGORITHM, digest: digest3 };
+  const algorithm = content.algorithm === DESIGN_CONTENT_ALGORITHM ? GATE_ALGORITHM : content.algorithm === EARLIER_DESIGN_CONTENT_ALGORITHM ? EARLIER_DESIGN_GATE_ALGORITHM : CONTENT_GATE_ALGORITHM;
+  return { algorithm, digest: digest3 };
 }
 function analyzerDigest(builtinRules, gate) {
   const codeCodes = codeJudgedCodes(builtinRules);
@@ -31140,7 +31913,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend", reachOnly = fals
   }
 }
 function ownReachModel(options) {
-  return runOwnersGate(options ?? {}, options?.projectType ?? "backend", true).reach ?? { scope: "own", networks: [], verbs: [], calls: [] };
+  return runOwnersGate(options ?? {}, options?.projectType ?? "backend", true).reach ?? { scope: "own", networks: [], verbs: [], calls: [], placements: [], topics: [] };
 }
 function reachModel2(options) {
   return reachModel(options);
@@ -31393,7 +32166,16 @@ function computeGateStateId() {
   const record = approvalRecord(getProjectRoot());
   if (!record?.stateId || record.stateId.algorithm === current2.algorithm) return current2;
   const asRecorded = computeGateIdentity(computeOwnStateId(), extensions, builtin, inputs, gate, members);
-  return record.stateId.algorithm === asRecorded.algorithm ? { ...current2, asRecorded } : current2;
+  if (record.stateId.algorithm === asRecorded.algorithm) return { ...current2, asRecorded };
+  const asApproved = computeGateIdentity(
+    computeOwnDesignStateIdAsRecorded(approvedStatuses(record)),
+    extensions,
+    builtin,
+    inputs,
+    gate,
+    members
+  );
+  return record.stateId.algorithm === asApproved.algorithm ? { ...current2, asRecorded: asApproved } : current2;
 }
 var NEVER_SUBJECT = "never";
 function directMemberSubjects() {
@@ -31732,7 +32514,7 @@ function generateSequenceDiagram(componentId, methodName, options) {
   lines.push("sequenceDiagram");
   lines.push("  autonumber");
   const declared = /* @__PURE__ */ new Set();
-  const declare2 = (comp) => {
+  const declare3 = (comp) => {
     const pid = ids.idFor(comp.id);
     if (!declared.has(pid)) {
       declared.add(pid);
@@ -31740,7 +32522,7 @@ function generateSequenceDiagram(componentId, methodName, options) {
     }
     return pid;
   };
-  const caller = declare2(entry);
+  const caller = declare3(entry);
   const walk2 = (comp, method, depth, stack) => {
     const key2 = `${comp.id}#${method}`;
     if (stack.has(key2)) {
@@ -31826,12 +32608,12 @@ function generateSequenceDiagram(componentId, methodName, options) {
             lines.push(`  Note over ${selfId}: ${escapeLabel(`dispatches via unknown "${step.targetComponent}"`)}`);
             break;
           }
-          const portalId = declare2(portal);
+          const portalId = declare3(portal);
           lines.push(step.detach ? `  ${selfId}-)${portalId}: ${escapeLabel(`\u27E8${step.capability ?? "?"}\u27E9`)} \u2014 detached` : `  ${selfId}->>${portalId}: ${escapeLabel(`\u27E8${step.capability ?? "?"}\u27E9`)}`);
           const binding = portal.dispatch?.find((b) => b.capability === step.capability);
           const server = binding ? componentById.get(binding.component) : void 0;
           if (binding && server) {
-            const serverId = declare2(server);
+            const serverId = declare3(server);
             const expandable = depth < maxDepth && !!findMethodImpl(server.id, binding.method) && server.id !== comp.id;
             if (expandable) {
               lines.push(`  ${portalId}->>+${serverId}: ${escapeLabel(binding.method)}()`);
@@ -31850,7 +32632,7 @@ function generateSequenceDiagram(componentId, methodName, options) {
             lines.push(`  Note over ${selfId}: ${escapeLabel(`registers callback on unknown "${step.targetComponent}"`)}`);
             break;
           }
-          const regTargetId = declare2(regTarget);
+          const regTargetId = declare3(regTarget);
           lines.push(`  ${selfId}--)${regTargetId}: ${escapeLabel(`register ${step.targetMethod}()`)}`);
           break;
         }
@@ -31861,7 +32643,7 @@ function generateSequenceDiagram(componentId, methodName, options) {
             lines.push(`  Note over ${selfId}: ${escapeLabel(`calls unknown "${step.targetComponent}"`)}`);
             break;
           }
-          const targetId = declare2(target);
+          const targetId = declare3(target);
           const expandable = depth < maxDepth && !!findMethodImpl(target.id, step.targetMethod) && target.id !== comp.id;
           if (step.detach) {
             lines.push(`  ${selfId}-)${targetId}: ${escapeLabel(step.targetMethod)}() \u2014 detached`);
@@ -31955,10 +32737,6 @@ function diagramSetIndex(files, systemName) {
 // src/core/project-family.ts
 var path20 = __toESM(require("path"));
 var memo = /* @__PURE__ */ new WeakMap();
-function dirKey(dir) {
-  const resolved = path20.resolve(dir);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
 function makeNodes(roots) {
   return roots.map((root) => {
     const id = root.config ? effectiveProjectId(root.config) : null;
@@ -32018,18 +32796,9 @@ function identityProblems(nodes) {
   }
   return problems;
 }
-function relationOf(consumer, producer) {
-  if (consumer.parent === producer.namespace) return "parent";
-  if (producer.parent === consumer.namespace) return "member";
-  if (consumer.parent !== void 0 && consumer.parent === producer.parent) return "sibling";
-  return "family";
-}
-function familyExternal(alias, project3, consumer, producer) {
-  return { alias, project: project3, sourceKind: "family", relation: relationOf(consumer, producer), producer: producer.namespace, directory: producer.directory, audience: "project", role: "external" };
-}
 function bindExternals(node, root, nodes) {
   if (!root.config) return [];
-  return [...declaredExternals(root.config).map((decl) => bindExternal(decl, node, nodes)), ...bindReferencedMembers(node, root)];
+  return [...declaredExternals(root.config).map((decl) => bindDeclaredExternal(decl, node, nodes)), ...bindReferencedMembers(node, root)];
 }
 function bindReferencedMembers(node, root) {
   const out = [];
@@ -32054,25 +32823,6 @@ function bindReferencedMembers(node, root) {
   }
   return out;
 }
-function bindExternal(decl, node, nodes) {
-  const unresolved = (problem) => ({ alias: decl.alias, project: decl.project, sourceKind: "unresolved", audience: "instance", problem, role: "external" });
-  if (decl.problem) return unresolved(decl.problem);
-  if (decl.sourceHosted !== void 0) return { alias: decl.alias, project: decl.project, sourceKind: "hosted", hosted: decl.sourceHosted, audience: "instance", role: "external" };
-  if (decl.sourceGit !== void 0) return { alias: decl.alias, project: decl.project, sourceKind: "git", audience: "instance", role: "external" };
-  if (decl.sourcePath !== void 0) {
-    const directory = path20.resolve(node.directory, decl.sourcePath);
-    const found = nodes.find((n) => dirKey(n.directory) === dirKey(directory));
-    if (!found) return { alias: decl.alias, project: decl.project, sourceKind: "path", directory, audience: "instance", role: "external" };
-    if (found.id !== decl.project) {
-      return unresolved(`the family project at source.path "${decl.sourcePath}" answers to ${found.id === void 0 ? "no id" : `"${found.id}"`}, not "${decl.project}"`);
-    }
-    return familyExternal(decl.alias, decl.project, node, found);
-  }
-  const holders = nodes.filter((n) => n.id === decl.project && n !== node);
-  if (holders.length === 0) return unresolved(`no project of the family answers to "${decl.project}", and no source.path says where to find it`);
-  if (holders.length > 1) return unresolved(`${holders.length} projects of the family answer to "${decl.project}" (${holders.map((n) => `"${n.namespace || "(the bound root)"}"`).join(", ")}), so the declaration could mean either`);
-  return familyExternal(decl.alias, decl.project, node, holders[0]);
-}
 function crossReferences(family, specs) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -32194,6 +32944,7 @@ function projectFamilyGraph() {
 var CONSUMABLE = /* @__PURE__ */ new Set(["Portal", "Observer"]);
 var IMPLEMENTABLE = /* @__PURE__ */ new Set(["Portal", "Adapter"]);
 function exportKindOf(comp, authored) {
+  if (comp.componentType === "Portal" && comp.transport === "InProcess") return "InProcess";
   if (comp.componentType === "Portal" && comp.transport) return transportExportKind(comp.transport);
   return authored;
 }
@@ -32241,6 +32992,54 @@ function checkConsumable(entry, owner, problems) {
     detail: implemented ? `"${entry.publicName}" exports ${entry.componentType} "${entry.component}" for consumers to implement, but an extension point is backed only by a Portal (a webhook or callback contract) or the Adapter holding the port the producer calls` : `"${entry.publicName}" exports ${entry.componentType} "${entry.component}", which no caller across the boundary may reach \u2014 only a Portal (a gateway is a Portal variant) or an Observer can serve one (an Adapter only as an extension point consumers implement, with role implement)`
   });
 }
+function renamedInSource(world, table, request) {
+  const wanted = localName2(request.interface ?? request.component ?? request.typeDef ?? "");
+  if (!wanted) return void 0;
+  const traced2 = (holder) => (holder.previousIds ?? []).some((p) => localName2(p) === wanted);
+  for (const entry of table.entries) {
+    if (request.typeDef !== void 0 && entry.kind === "type") {
+      const holders = world.types.get(entry.typeDef ?? "") ?? [];
+      if (holders.some(traced2)) return entry.publicName;
+    }
+    if (request.interface !== void 0 && entry.interface !== void 0) {
+      const intf = world.interfaces.get(entry.interface);
+      if (intf && traced2(intf)) return entry.publicName;
+    }
+    if (request.component !== void 0 && entry.kind === "component" && entry.component !== void 0) {
+      const comp = world.components.get(entry.component);
+      if (comp && traced2(comp)) return entry.publicName;
+    }
+  }
+  return void 0;
+}
+function followProducerRenames(table, producerOf2) {
+  for (const problem of table.problems) {
+    if (problem.kind !== "invalid" || problem.source === void 0 || problem.renamedTo !== void 0) continue;
+    const requested = /^re-exports "([^"]+)" from /.exec(problem.detail)?.[1];
+    const producer = requested !== void 0 ? producerOf2(problem.source) : void 0;
+    const renamedTo = producer ? publicRenameTrace(producer.table, producer.specs).get(requested) : void 0;
+    if (renamedTo === void 0) continue;
+    problem.renamedTo = renamedTo;
+    problem.detail = problem.detail.replace(" \u2014 another project is reached only through its L0 exports", ` \u2014 it was renamed to "${renamedTo}" there (did you mean "${renamedTo}"?): re-export the new name`);
+  }
+}
+function publicRenameTrace(table, specs) {
+  const trace = /* @__PURE__ */ new Map();
+  const byId = (list) => list.reduce((m, x) => m.set(x.id, [...m.get(x.id) ?? [], x]), /* @__PURE__ */ new Map());
+  const components = byId(specs.components);
+  const interfaces = byId(specs.interfaces);
+  const types = byId(specs.types);
+  for (const entry of table.entries) {
+    const holders = entry.kind === "type" ? types.get(entry.typeDef ?? "") ?? [] : entry.interface !== void 0 ? interfaces.get(entry.interface) ?? [] : components.get(entry.component ?? "") ?? [];
+    for (const holder of holders) {
+      for (const former of holder.previousIds ?? []) {
+        const name = localName2(former);
+        if (name !== entry.publicName && !trace.has(name)) trace.set(name, entry.publicName);
+      }
+    }
+  }
+  return trace;
+}
 function findInSource(world, source, table, request) {
   if (request.typeDef) {
     const type = lookupType(world, request.typeDef, source.id);
@@ -32269,7 +33068,15 @@ function bindNamed(world, owner, source, sourceTable, request, publicName, inCyc
   const { found, item } = findInSource(world, source, sourceTable, request);
   const what = request.typeDef ? `type "${request.typeDef}"` : `component "${request.component}"${request.interface ? ` (interface "${request.interface}")` : ""}`;
   if (!item) {
-    problems.push({ kind: "invalid", owner, detail: `re-exports ${what} from "${source.id}", which has no such item` });
+    const renamedTo = renamedInSource(world, sourceTable, request);
+    problems.push({
+      kind: "invalid",
+      owner,
+      ...request.as !== void 0 ? { publicName: request.as } : {},
+      detail: `re-exports ${what} from "${source.id}", which has no such item${renamedTo ? ` \u2014 it was renamed to "${renamedTo}" there (did you mean "${renamedTo}"?)` : ""}`,
+      ...renamedTo ? { renamedTo } : {},
+      source: source.id
+    });
     return void 0;
   }
   const name = publicName(item);
@@ -32336,7 +33143,7 @@ function subsystemCandidates(world, sub, tables, group, problems) {
         sub.id,
         source,
         sourceTable,
-        { component: pi.component, interface: pi.interface, typeDef: pi.typeDef },
+        { component: pi.component, interface: pi.interface, typeDef: pi.typeDef, ...pi.as !== void 0 ? { as: pi.as } : {} },
         (item) => pi.as ?? localName2(pi.interface ?? item.typeDef ?? item.component ?? ""),
         group.has(source.id),
         problems
@@ -32542,7 +33349,14 @@ function bindFromProject(owner, e, source, table, index, problems) {
   const requested = named2 ? localName2(e.interface ?? e.component ?? e.typeDef) : void 0;
   const picked = named2 ? table.entries.filter((x) => x.publicName === requested) : table.entries;
   if (named2 && picked.length === 0) {
-    problems.push({ kind: "invalid", owner, publicName: e.as ?? e.id ?? requested, detail: `re-exports "${requested}" from ${source.label}, whose export table has no such public name \u2014 another project is reached only through its L0 exports` });
+    const from = e.from ?? e.subsystem;
+    problems.push({
+      kind: "invalid",
+      owner,
+      publicName: e.as ?? e.id ?? requested,
+      detail: `re-exports "${requested}" from ${source.label}, whose export table has no such public name \u2014 another project is reached only through its L0 exports`,
+      ...from !== void 0 ? { source: from } : {}
+    });
     return [];
   }
   const declared = e.audience ?? "instance";
@@ -32572,7 +33386,7 @@ function bindFromSubsystem(world, owner, e, subsystem, subsystemTables, index, p
       owner,
       subsystem,
       sourceTable,
-      { component: e.component, interface: e.interface, typeDef: e.typeDef },
+      { component: e.component, interface: e.interface, typeDef: e.typeDef, ...(e.as ?? e.id) !== void 0 ? { as: e.as ?? e.id } : {} },
       // The default public name is the item's own LOCAL id: a member's L0 is
       // read with its ids keyed under its project, and its entry names the
       // item as the member wrote it.
@@ -32735,7 +33549,7 @@ function sameParams2(a, b) {
   const right = b ?? [];
   return left.length === right.length && left.every((p, i) => p.name === right[i].name && p.type === right[i].type && !!p.optional === !!right[i].optional);
 }
-function tablesOf(interfaces, components, types, references) {
+function tablesOf(interfaces, components, types, references, exportMethods = /* @__PURE__ */ new Map()) {
   const methodsOf = /* @__PURE__ */ new Map();
   for (const intf of interfaces) methodsOf.set(intf.component, [...methodsOf.get(intf.component) ?? [], ...intf.methods]);
   const boundTypes = /* @__PURE__ */ new Map();
@@ -32743,7 +33557,7 @@ function tablesOf(interfaces, components, types, references) {
     if (ref.position !== "type" || ref.binding === "outside" || ref.binding === "unresolved") continue;
     boundTypes.set(`${ref.specId}|${ref.authored}`, ref.resolved);
   }
-  return { methodsOf, componentKeys: new Set(components.map((c) => c.id)), types, boundTypes };
+  return { methodsOf, componentKeys: new Set(components.map((c) => c.id)), types, boundTypes, exportMethods };
 }
 function methodReading(tables, intf, value) {
   const dot = value.lastIndexOf(".");
@@ -32759,6 +33573,11 @@ function methodReading(tables, intf, value) {
   }
   return null;
 }
+function exportReading(tables, intf, value) {
+  if (!value.includes("::")) return null;
+  const method = tables.exportMethods.get(`${namespaceOf2(intf.id)}|${value}`);
+  return method ? { target: value, method } : null;
+}
 function typeReading(tables, intf, value) {
   const bound2 = value.includes("::") ? tables.boundTypes.get(`${intf.id}|${value}`) : void 0;
   const named2 = bound2 !== void 0 ? tables.types.filter((t) => t.id === bound2) : tables.types.filter((t) => t.id === value || typeMatchesRef(t, value));
@@ -32783,7 +33602,9 @@ function restatedFact(base, stored, params, returns) {
 function resolveSourced(tables, intf, stored, facts) {
   const source = stored.signatureFrom;
   const base = { interfaceId: intf.id, component: intf.component, method: stored.name, source };
-  const hit = methodReading(tables, intf, source);
+  const local = methodReading(tables, intf, source);
+  const external = local ? null : exportReading(tables, intf, source);
+  const hit = local ?? external;
   const { signature, other } = typeReading(tables, intf, source);
   if (hit && signature) {
     facts.sources.push({ ...base, outcome: "ambiguous", candidates: [hit.target, typeTarget(signature)] });
@@ -32797,7 +33618,7 @@ function resolveSourced(tables, intf, stored, facts) {
     facts.sources.push({ ...base, form: "method", target: hit.target, outcome: "chained", detail: hit.method.signatureFrom });
     return unresolvedMethod(stored);
   }
-  const form = hit ? "method" : "signature";
+  const form = external ? "export" : hit ? "method" : "signature";
   const target = hit ? hit.target : typeTarget(signature);
   const params = hit ? hit.method.params : signature.params;
   const returns = hit ? hit.method.returns : signature.returns ?? "unknown";
@@ -32816,10 +33637,10 @@ function withDerivedText(method, stored, specId, kind, facts) {
   if (stored !== void 0 && stored !== derived) facts.staleTexts.push({ specId, kind, method: method.name, stored, derived });
   return { ...method, signature: derived };
 }
-function resolveTree(interfaces, components, types, references = []) {
+function resolveTree(interfaces, components, types, references = [], exportMethods = /* @__PURE__ */ new Map()) {
   const intfs = interfaces.map((i) => ({ ...i, methods: i.methods.map((m) => ({ ...m })) }));
   const typeCopies = types.map((t) => ({ ...t, methods: t.methods.map((m) => ({ ...m })) }));
-  const tables = tablesOf(intfs, [...components], typeCopies, references);
+  const tables = tablesOf(intfs, [...components], typeCopies, references, exportMethods);
   const facts = emptySignatureFacts();
   const sourced = intfs.map((intf) => ({
     ...intf,
@@ -32871,6 +33692,13 @@ function assertSpecWritesPermitted(owners, what) {
     `SubsystemWriteDenied: ${what} would change ${denied.length === 1 ? "a spec" : "specs"} this request may not change \u2014 ${denied.join("; ")}. Nothing was written.`
   );
 }
+var TOLERATED_KEYS = /* @__PURE__ */ new Set(["schemaVersion"]);
+var UNKNOWN_KEY_HINTS = {
+  "system.exports": "The L0 export table is `publicInterfaces` (sdd_set_public_interfaces writes it).",
+  "system.export": "The L0 export table is `publicInterfaces` (sdd_set_public_interfaces writes it).",
+  "subsystem.exports": "A subsystem publishes through `publicInterfaces`.",
+  "component.type": "A component's stereotype is `componentType`."
+};
 function unknownKeysIn(raw, parsed, at, out) {
   if (Array.isArray(raw)) {
     if (!Array.isArray(parsed) || parsed.length !== raw.length) return;
@@ -33165,11 +33993,11 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
         continue;
       }
       if (member.form === "members" && !projectContentAt(childDir)) continue;
-      const dirKey3 = chainDirKey(childDir);
-      if (listed.has(dirKey3)) continue;
-      listed.add(dirKey3);
+      const dirKey2 = chainDirKey(childDir);
+      if (listed.has(dirKey2)) continue;
+      listed.add(dirKey2);
       inspection.roots.push(path21.relative(root, childDir).split(path21.sep).join("/"));
-      walk2(childDir, key2, /* @__PURE__ */ new Set([...ancestors, dirKey3]), depth + 1);
+      walk2(childDir, key2, /* @__PURE__ */ new Set([...ancestors, dirKey2]), depth + 1);
     }
   };
   walk2(root, "", /* @__PURE__ */ new Set([chainDirKey(root)]), 0);
@@ -33592,6 +34420,70 @@ function keyedSystem(system, key2, subsystems) {
     })
   };
 }
+function referrerSpelling(text3, rename) {
+  if (text3 === void 0) return void 0;
+  const parsed = parseTypeExpression(text3, "returns");
+  if (!parsed.expression) return text3;
+  const walk2 = (expr) => {
+    const args = expr.args.map(walk2);
+    return (expr.form === "named" || expr.form === "applied") && !isTypeVocabulary(expr.name) ? { ...expr, name: rename(expr.name), args } : { ...expr, args };
+  };
+  return canonicalTypeText(walk2(parsed.expression));
+}
+function spelledForReferrer(method, rename) {
+  const { signatureFrom: _source, ...rest } = method;
+  return {
+    ...rest,
+    returns: referrerSpelling(method.returns, rename) ?? method.returns,
+    ...method.params ? { params: method.params.map((p) => ({ ...p, type: referrerSpelling(p.type, rename) ?? p.type })) } : {}
+  };
+}
+function exportMethodsOf(raws) {
+  const out = /* @__PURE__ */ new Map();
+  const byKey3 = new Map(raws.map((r) => [r.record.namespace, r]));
+  const last = (id) => id.split("::").pop().split(".").pop();
+  for (const raw of raws) {
+    const ns = raw.record.namespace;
+    for (const [alias, key2] of raw.record.aliases) {
+      const producer = byKey3.get(key2);
+      const table = producer?.record.exports;
+      if (!producer || !table) continue;
+      const typeNames = /* @__PURE__ */ new Map();
+      for (const e of table.entries) if (e.kind === "type" && e.typeDef) typeNames.set(last(e.typeDef), e.publicName);
+      const rename = (name) => `${alias}::${typeNames.get(last(name)) ?? last(name)}`;
+      for (const entry of table.entries) {
+        if (entry.kind !== "component" || !entry.component) continue;
+        const contracts = producer.index.interfaces.filter((i) => entry.interface ? i.id === entry.interface : i.component === entry.component);
+        for (const method of contracts.flatMap((i) => i.methods)) {
+          if (method.signatureFrom !== void 0) continue;
+          out.set(`${ns}|${alias}::${entry.publicName}.${method.name}`, spelledForReferrer(method, rename));
+        }
+      }
+    }
+    const config = raw.record.config;
+    if (!config) continue;
+    for (const declared of declaredExternals(config)) {
+      if (declared.problem || raw.record.aliases.has(declared.alias)) continue;
+      let snapshot;
+      try {
+        const file = path21.join(aiPathsAt(raw.dir).root(), "externals", `${declared.alias}.yaml`);
+        if (!fs15.existsSync(file)) continue;
+        snapshot = SurfaceSnapshotSchema.parse(readYamlFile(file));
+      } catch {
+        continue;
+      }
+      const publicOf = new Map((snapshot.exportedTypes ?? []).map((t) => [t.type, t.id]));
+      const closure = new Set(snapshot.types.map((t) => t.id));
+      const rename = (name) => closure.has(name) ? `${declared.alias}::${publicOf.get(name) ?? last(name)}` : name;
+      for (const entry of snapshot.interfaces) {
+        for (const method of entry.methods) {
+          out.set(`${ns}|${declared.alias}::${entry.id}.${method.name}`, spelledForReferrer(method, rename));
+        }
+      }
+    }
+  }
+  return out;
+}
 function resolveFamilyTables(raws) {
   const byKey3 = new Map(raws.map((r) => [r.record.namespace, r]));
   const done = /* @__PURE__ */ new Set();
@@ -33621,6 +34513,11 @@ function resolveFamilyTables(raws) {
         producerTables,
         audienceOf
       });
+      followProducerRenames(raw.record.exports, (source) => {
+        const key3 = raw.record.aliases.get(source);
+        const producer = key3 !== void 0 ? byKey3.get(key3) : void 0;
+        return producer?.record.exports ? { table: producer.record.exports, specs: producer.index } : void 0;
+      });
       done.add(key2);
       return raw.record.exports;
     } finally {
@@ -34063,8 +34960,8 @@ function publicInterfaceKey(o) {
   if (from || typeDef) {
     const item = typeDef ? `type ${typeDef}` : str(o.component) ?? "*";
     const narrowed2 = str(o.interface) ? `.${String(o.interface)}` : "";
-    const renamed = str(o.as) ? ` as ${String(o.as)}` : "";
-    return `${from ? `${from}:` : ""}${item}${narrowed2}${renamed}`;
+    const renamed2 = str(o.as) ? ` as ${String(o.as)}` : "";
+    return `${from ? `${from}:` : ""}${item}${narrowed2}${renamed2}`;
   }
   const component = str(o.component);
   if (component) return str(o.interface) ? `${component}.${String(o.interface)}` : component;
@@ -34517,7 +35414,7 @@ var SpecWorkspace = class {
       index.retiredReach.push(...raw.index.retiredReach.map((fact) => ({ ...fact, specId: keyIn(raw.record.namespace, fact.specId) })));
     }
     readRetiredReachAcrossSpecs(index);
-    const signatures = resolveTree(index.interfaces, index.components, index.types, raws.flatMap((r) => r.record.authoredReferences));
+    const signatures = resolveTree(index.interfaces, index.components, index.types, raws.flatMap((r) => r.record.authoredReferences), exportMethodsOf(raws));
     index.interfaces = signatures.interfaces;
     index.types = signatures.types;
     index.signatures = {
@@ -34535,6 +35432,7 @@ var SpecWorkspace = class {
   readRoot(dir, parent, member, ancestors, maxDepth, depth, raws, taken) {
     const config = configAt(dir);
     this.scanVisitedConfigFiles.push(aiPathsAt(dir).projectConfig());
+    if (!parent && config) this.reportUnknownConfigKeys(aiPathsAt(dir).projectConfig(), rawConfigAt(dir), config);
     const id = config ? effectiveProjectId(config) : null;
     const aliasPath = parent && member ? keyIn(parent.aliasPath, member.alias) : "";
     const key2 = !parent ? "" : id && !taken.has(id) ? id : aliasPath;
@@ -34639,6 +35537,7 @@ var SpecWorkspace = class {
         const doc = readSpecFile(systemYaml);
         if (doc && typeof doc === "object") raw.index.retiredReach.push(...readRetiredReachForms("system", doc));
         raw.rawSystem = SystemSpecSchema.parse(doc);
+        this.reportUnknownKeys(systemYaml, "system", doc, raw.rawSystem, keyIn(raw.record.namespace, "system"));
       } catch {
         raw.rawSystem = null;
       }
@@ -34820,6 +35719,42 @@ var SpecWorkspace = class {
       this.memberProblem(raw, "kind-mismatch", decl.alias, `the part "${decl.alias}" says it is a part of "${partOf.project}", but "${ownId}" declares it \u2014 correct \`partOf.project\` to "${ownId}" ${whereToEdit(decl, dir)}`);
     }
   }
+  /**
+   * A spec file's keys its schema does not know — which the parse drops, so
+   * they would mean nothing without a word — reported as UNKNOWN_SPEC_KEY,
+   * once per file. A retired reachability form is read compatibly and
+   * reported by its own rule, so a component's `mounts` is no unknown key.
+   */
+  reportUnknownKeys(file, kind, doc, parsed, specId) {
+    const unknown = [];
+    unknownKeysIn(doc, parsed, "", unknown);
+    const keys = unknown.map((entry) => entry.slice(0, entry.indexOf(":"))).filter((key2) => !(kind === "component" && key2.startsWith("mounts")) && !TOLERATED_KEYS.has(key2));
+    if (keys.length === 0) return;
+    const hint = keys.map((key2) => UNKNOWN_KEY_HINTS[`${kind}.${key2}`]).filter(Boolean);
+    this.loaderIssues.push({
+      severity: "warning",
+      code: "UNKNOWN_SPEC_KEY",
+      message: `Spec file "${file}" holds ${keys.length === 1 ? "a key" : "keys"} its ${kind} schema does not know, which ${keys.length === 1 ? "is" : "are"} ignored: ${keys.join(", ")}. ${hint.length ? `${hint.join(" ")} ` : ""}Remove ${keys.length === 1 ? "it" : "them"}, or move what ${keys.length === 1 ? "it means" : "they mean"} into a field the schema has \u2014 a spec edited through the sdd_* tools never holds one.`,
+      specId
+    });
+  }
+  /**
+   * The bound root's .wai/project.yaml keys its schema does not know, reported
+   * as UNKNOWN_CONFIG_KEY (a warning): the configuration's parse drops them, so
+   * a misspelt setting would otherwise silently configure nothing.
+   */
+  reportUnknownConfigKeys(file, raw, config) {
+    if (!raw) return;
+    const unknown = [];
+    unknownKeysIn(raw, config, "", unknown);
+    const keys = unknown.map((entry) => entry.slice(0, entry.indexOf(":")));
+    if (keys.length === 0) return;
+    this.loaderIssues.push({
+      severity: "warning",
+      code: "UNKNOWN_CONFIG_KEY",
+      message: `"${file}" holds ${keys.length === 1 ? "a setting" : "settings"} wairon does not know, which ${keys.length === 1 ? "is" : "are"} ignored: ${keys.join(", ")}. Check the spelling against docs/cli.md (configuration) \u2014 a misspelt setting configures nothing.`
+    });
+  }
   /**
    * Read every spec document under a specs directory into a root's index, as
    * written: the root's own (`systemYaml` is its L0, skipped here) or a part's
@@ -34868,6 +35803,7 @@ var SpecWorkspace = class {
         if ("parentSystem" in doc) {
           detectedType = "subsystem";
           const parsed = SubsystemSpecSchema.parse(doc);
+          this.reportUnknownKeys(file, "subsystem", doc, parsed, keyIn(key2, parsed.id));
           if (!(parsed.projectPath && parsed.projectPath.trim() !== "")) {
             index.retiredReach.push(...readRetiredReachForms("subsystem", doc));
           }
@@ -34877,17 +35813,20 @@ var SpecWorkspace = class {
           detectedType = "component";
           const facts = readRetiredReachForms("component", doc);
           const parsed = attachRetiredMounts(ComponentSpecSchema.parse(doc), doc);
+          this.reportUnknownKeys(file, "component", doc, parsed, keyIn(key2, parsed.id));
           index.retiredReach.push(...facts);
           keep("component", index.components, parsed, file);
         } else if ("component" in doc) {
           detectedType = "interface";
           const facts = readRetiredReachForms("interface", doc);
           const parsed = InterfaceSpecSchema.parse(doc);
+          this.reportUnknownKeys(file, "interface", doc, parsed, keyIn(key2, parsed.id));
           index.retiredReach.push(...facts);
           keep("interface", index.interfaces, parsed, file);
         } else if ("contract" in doc) {
           detectedType = "implementation";
           const parsed = ImplementationSpecSchema.parse(doc);
+          this.reportUnknownKeys(file, "implementation", doc, parsed, keyIn(key2, parsed.id));
           const normalizeSourcePath = (p) => path21.relative(raw.dir, path21.resolve(baseDir, p)).replace(/\\/g, "/");
           if (parsed.sourcePath) parsed.sourcePath = normalizeSourcePath(parsed.sourcePath);
           for (const method of parsed.methods) {
@@ -34901,7 +35840,9 @@ var SpecWorkspace = class {
             keep("group", index.groups, GroupSpecSchema.parse(doc), file);
           } else {
             detectedType = "type";
-            keep("type", index.types, TypeSpecSchema.parse(doc), file);
+            const parsed = TypeSpecSchema.parse(doc);
+            this.reportUnknownKeys(file, "type", doc, parsed, keyIn(key2, parsed.id));
+            keep("type", index.types, parsed, file);
           }
         }
         if (detectedType === "spec") {
@@ -36434,8 +37375,8 @@ var SpecWorkspace = class {
     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);
+    const respelled2 = new Set(read2.respellings.map((r) => r.path));
+    const fromFile = this.scanAll().typeSpellings.respellings.filter((r) => r.specId === merged.id && r.kind === kind && !respelled2.has(r.path) && typePositionText(merged, r.path) === r.stored);
     return [...read2.respellings, ...fromFile];
   }
   /**
@@ -36562,6 +37503,18 @@ var SpecWorkspace = class {
     if (!result) {
       throw new Error(`Spec of kind "${kind}" with ID "${id}" does not exist. Define it first.`);
     }
+    if (kind !== "system") {
+      const stored = String(result.id ?? id);
+      const member = this.getSubprojectPrefix(stored) ?? this.getSubprojectPrefix(id);
+      if (member !== null && this.rootCovering(member)?.legacyMount === null) {
+        const local = stored.startsWith(`${member}::`) ? stored.slice(member.length + 2) : stored;
+        const dir = this.resolveSubprojectForNamespace(member);
+        const folder = dir ? path21.relative(this.rootDir, dir).split(path21.sep).join("/") || "." : void 0;
+        throw new Error(
+          `chained-spec: "${stored}" lives in another project; update it from that project's own root. It belongs to the member project "${member}"${folder ? ` at ${folder}` : ""}: open a session in that folder (its own guide and .mcp.json \u2014 run \`wairon generate\` and \`wairon mcp install --backend claude\` there first if it has none) and call sdd_update_spec ${kind} ${local} there. Nothing was written.`
+        );
+      }
+    }
     if (kind === "system" && id && id !== "system" && id !== result.name) {
       throw new Error(
         `kind "system" targets the singleton L0 spec (system name "${result.name}") \u2014 pass id "system" or the system name, got "${id}". For a subsystem, use kind "subsystem".`
@@ -36821,12 +37774,12 @@ var SpecWorkspace = class {
             1,
             capture
           ));
-          const { action, remove: remove2, captureJumps, ...cleanStep } = deltaStep;
+          const { action, remove: remove3, captureJumps, ...cleanStep } = deltaStep;
           steps.push(withUnset(pinDeltaJumps(cleanStep), deltaStep));
         } else {
           const idx = steps.findIndex((s) => s.stepNumber === stepNum);
           if (idx !== -1) {
-            const { action, remove: remove2, ...rawStep } = deltaStep;
+            const { action, remove: remove3, ...rawStep } = deltaStep;
             const stored = steps[idx];
             const cleanStep = pinDeltaJumps(rawStep, stored[DELTA_JUMP_PINS]);
             const merged = withUnset(retargetByLabel(mergeElement(stored, cleanStep), cleanStep), deltaStep);
@@ -36834,7 +37787,7 @@ var SpecWorkspace = class {
             rebuilt[DELTA_JUMP_PINS] = cleanStep[DELTA_JUMP_PINS];
             steps[idx] = rebuilt;
           } else {
-            const { action, remove: remove2, ...cleanStep } = deltaStep;
+            const { action, remove: remove3, ...cleanStep } = deltaStep;
             steps.push(withUnset(pinDeltaJumps(cleanStep), deltaStep));
           }
         }
@@ -36931,7 +37884,7 @@ var SpecWorkspace = class {
           merged.push(withUnset(deltaItem, deltaItem));
         }
       }
-      return merged.map(({ action, remove: remove2, ...item }) => item);
+      return merged.map(({ action, remove: remove3, ...item }) => item);
     };
     const mergePublicInterfaces = (existing, delta2) => {
       const merged = [...existing];
@@ -36977,7 +37930,7 @@ var SpecWorkspace = class {
           merged.push(withUnset(deltaItem, deltaItem));
         }
       }
-      return merged.map((item) => item && typeof item === "object" ? (({ action, remove: remove2, ...rest }) => rest)(item) : item);
+      return merged.map((item) => item && typeof item === "object" ? (({ action, remove: remove3, ...rest }) => rest)(item) : item);
     };
     const isIdentifiedArray = (field, a, b) => a.every((i) => identityKeyOf(field, i) !== null) && b.every((i) => identityKeyOf(field, i) !== null);
     const mergeDelta = (existing, delta2) => {
@@ -37965,6 +38918,9 @@ function setProjectType(projectType) {
 function describeProject(name, description) {
   projectConfigRepository.describeProject(name, description);
 }
+function setNetwork(network) {
+  return projectConfigRepository.setNetwork(network);
+}
 function recordProfileSelection(selection) {
   projectConfigRepository.recordProfileSelection(selection);
 }
@@ -38167,7 +39123,7 @@ function resolveHosted(external) {
   const root = lookup2(external.hosted);
   return root === null ? unresolved(`the hosted producer \`${external.hosted}\` is unknown or outside this request's reach`) : { ...external, directory: path23.resolve(root) };
 }
-function dirKey2(dir) {
+function dirKey(dir) {
   const resolved = path23.resolve(dir);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
@@ -38179,11 +39135,11 @@ function climb(bound2) {
     top = path23.resolve(parent.parentRoot);
   }
   const reach2 = getRequestParentReach();
-  const stoppedAtNarrowedCeiling = !!reach2?.narrowed && reach2.topRoot !== void 0 && dirKey2(top) === dirKey2(reach2.topRoot);
+  const stoppedAtNarrowedCeiling = !!reach2?.narrowed && reach2.topRoot !== void 0 && dirKey(top) === dirKey(reach2.topRoot);
   return { top, whole: !(reach2 && !reach2.parentReach) && !stoppedAtNarrowedCeiling };
 }
 function consumerNode(family, bound2) {
-  return family.nodes.find((n) => dirKey2(n.directory) === dirKey2(bound2));
+  return family.nodes.find((n) => dirKey(n.directory) === dirKey(bound2));
 }
 function gitDeclarationOf(config, external) {
   if (!config) return null;
@@ -38214,7 +39170,7 @@ function resolveGit(external, config, offline) {
 }
 var NOT_COMPARED_OFFLINE = "not compared offline \u2014 `wairon externals status` fetches it";
 function consumerConfig(bound2) {
-  return listProjectRoots().find((r) => dirKey2(r.directory) === dirKey2(bound2))?.config ?? null;
+  return listProjectRoots().find((r) => dirKey(r.directory) === dirKey(bound2))?.config ?? null;
 }
 function resolveDeclared(offline) {
   const bound2 = path23.resolve(getProjectRoot());
@@ -38250,6 +39206,51 @@ function headAcross2(consumerDir, external) {
   const head2 = head(external.directory);
   return head2 ? { ...external, commit: head2 } : external;
 }
+function resolveCandidate(alias, declaration2) {
+  const bound2 = path23.resolve(getProjectRoot());
+  const { top, whole } = climb(bound2);
+  const config = consumerConfig(bound2);
+  const answer = (root) => runWithProjectRoot(root, () => {
+    const family = graph();
+    const node = consumerNode(family, bound2);
+    if (!node) return null;
+    const [declared] = declaredExternals({ externals: { [alias]: declaration2 }, ...config?.members ? { members: config.members } : {} });
+    const candidate = bindDeclaredExternal(declared, node, family.nodes);
+    const external = candidate.sourceKind === "git" ? resolveGit(candidate, { externals: { [alias]: declaration2 } }, false) : headAcross2(node.directory, resolveHosted(candidate));
+    return { external, reachable: whole };
+  });
+  return answer(top) ?? answer(bound2) ?? {
+    external: { alias, project: declaration2.project ?? alias, sourceKind: "unresolved", audience: "instance", role: "external", problem: "the bound project is not in the family graph its root reads" },
+    reachable: whole
+  };
+}
+function listConsumers() {
+  const bound2 = path23.resolve(getProjectRoot());
+  const { top } = climb(bound2);
+  return runWithProjectRoot(top, () => {
+    const family = graph();
+    const producer = consumerNode(family, bound2);
+    if (!producer) return [];
+    const consumers = [];
+    for (const node of family.nodes) {
+      if (node === producer) continue;
+      const external = node.externals.find((e) => e.sourceKind === "family" && e.producer === producer.namespace);
+      const memberAlias = [...node.aliases.entries()].find(([alias2, key2]) => key2 === producer.namespace && !node.externals.some((e) => e.alias === alias2))?.[0];
+      const alias = external?.alias ?? memberAlias;
+      if (alias === void 0) continue;
+      const usage = exportUsage(node.namespace, producer.namespace);
+      consumers.push({
+        project: node.id ?? node.namespace,
+        key: node.namespace,
+        directory: node.directory,
+        alias,
+        section: external ? "externals" : "members",
+        names: usage.used.map((u) => u.publicName).sort()
+      });
+    }
+    return consumers.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+  });
+}
 
 // src/core/part-context.ts
 var crypto6 = __toESM(require("crypto"));
@@ -39073,7 +40074,7 @@ function promoteMember(alias, id) {
     patchKeepingStamp(s.file, (raw) => raw.parentSystem === projectName ? false : (raw.parentSystem = projectName, true));
   }
   if (declaration2?.as === "part") projectConfigRepository.updateMember(alias, { as: "" });
-  const result = { respelled: [], memberRespelled: [], exported: [], imported: [], consumersDropped: [] };
+  const result = { respelled: [], memberRespelled: [], exported: [], imported: [], consumersDropped: [], entriesDeclared: [], topicsCrossing: [] };
   const parentSide = rewriteRefsIn(crossing.in.map((c) => c.spec).filter(unique), (ref, position) => INTO_MEMBER_POSITIONS.has(position) && crossing.insideTargets.has(ref) ? `${alias}::${ref}` : ref, { result, member: false });
   const climbs = climbsOf(family, crossing.insideIds, parentId).map;
   const climbing = inside.filter((s) => family.authoredReferences.some((r) => r.form === "super" && r.specId === s.id));
@@ -39081,6 +40082,8 @@ function promoteMember(alias, id) {
   const qualified = respellQualified(inside, outside, { alias, parentId, newId }, result);
   invalidateSpecCache();
   dropCrossingConsumers(inside, outside, result);
+  declareCrossingEntries(inside, outside, parentId || parentName, result);
+  recordCrossingTopics(inside, outside, parentId || parentName, result);
   if (crossing.out.length > 0 || qualified.out.length > 0 || [...climbs.values()].some((t) => t.startsWith(`${parentId}::`))) runWithProjectRoot(dir, () => projectConfigRepository.declareExternal(parentId, {}));
   for (const s of inside.filter((x) => x.kind === "subsystem")) restateReExports(s.id, alias);
   exportCrossings([...crossing.out, ...qualified.out], dir, alias, parentId, "out", result);
@@ -39106,6 +40109,92 @@ function promoteMember(alias, id) {
   invalidateSpecCache();
   return result;
 }
+function callsInto2(callers, portals) {
+  const componentOf = new Map(callers.filter((s) => s.kind === "interface").map((s) => [s.id, String(s.raw.component ?? "")]));
+  const out = /* @__PURE__ */ new Map();
+  const add2 = (target, verb, caller) => {
+    const portal = target?.includes("::") ? target.slice(target.lastIndexOf("::") + 2) : target;
+    if (!portal || !verb || !portals.has(portal)) return;
+    const verbs = out.get(portal) ?? /* @__PURE__ */ new Map();
+    verbs.set(verb, /* @__PURE__ */ new Set([...verbs.get(verb) ?? [], caller]));
+    out.set(portal, verbs);
+  };
+  for (const impl of callers.filter((s) => s.kind === "implementation")) {
+    const caller = componentOf.get(String(impl.raw.contract ?? ""));
+    if (!caller) continue;
+    for (const method of Array.isArray(impl.raw.methods) ? impl.raw.methods : []) {
+      for (const step of Array.isArray(method?.narrative) ? method.narrative : []) {
+        if (step?.type === "call" || step?.type === "register") add2(step.targetComponent, step.targetMethod, caller);
+      }
+      for (const entry of Array.isArray(method?.calls) ? method.calls : []) {
+        const call = typeof entry === "string" ? parseDeclaredCall(entry) : null;
+        if (call) add2(call.compId, call.methodName, caller);
+      }
+    }
+  }
+  return out;
+}
+function declareCrossingEntries(inside, outside, parent, result) {
+  const portals = new Map(inside.filter((s) => s.kind === "component" && s.raw.componentType === "Portal").map((s) => [s.id, s]));
+  const called = callsInto2(outside, new Set(portals.keys()));
+  for (const [portalId, verbs] of [...called].sort(([a], [b]) => a.localeCompare(b))) {
+    const portal = portals.get(portalId);
+    if (portal.raw.invokedBy?.kind === "entry") continue;
+    const transport = portal.raw.transport;
+    const network = transport !== void 0 && transportKind(transport) === "network";
+    for (const contract of inside.filter((s) => s.kind === "interface" && s.raw.component === portalId)) {
+      patchKeepingStamp(contract.file, (raw) => {
+        let changed = false;
+        for (const method of Array.isArray(raw.methods) ? raw.methods : []) {
+          const callers = verbs.get(method?.name);
+          if (!callers || method.invokedBy !== void 0) continue;
+          const names = [...callers].sort().join(", ");
+          method.invokedBy = {
+            kind: "entry",
+            ...network ? { scope: "network" } : {},
+            caller: `${names} of ${parent}, calling ${portalId}.${method.name} across the project boundary (modelled calls in ${parent}; declared when this project was promoted out of it)`
+          };
+          result.entriesDeclared.push(`${portalId}.${method.name}: entry${network ? " (network)" : ""} \u2014 called by ${names} of ${parent}`);
+          changed = true;
+        }
+        return changed;
+      });
+    }
+  }
+}
+function topicEnds(specs) {
+  const emits = /* @__PURE__ */ new Map();
+  const subscribes = /* @__PURE__ */ new Map();
+  const add2 = (into, topic, component) => {
+    if (typeof topic !== "string" || topic === "") return;
+    into.set(topic, /* @__PURE__ */ new Set([...into.get(topic) ?? [], component]));
+  };
+  for (const c of specs.filter((s) => s.kind === "component")) {
+    for (const e of Array.isArray(c.raw.emits) ? c.raw.emits : []) add2(emits, e?.topic, c.id);
+    for (const e of Array.isArray(c.raw.subscribesTo) ? c.raw.subscribesTo : []) add2(subscribes, e?.topic, c.id);
+  }
+  for (const i of specs.filter((s) => s.kind === "interface")) {
+    for (const m of Array.isArray(i.raw.methods) ? i.raw.methods : []) {
+      const ep = m?.endpoint;
+      if (ep?.transport !== "MessageBus") continue;
+      add2(ep.direction === "publish" ? emits : subscribes, ep.topic, String(i.raw.component ?? i.id));
+    }
+  }
+  return { emits, subscribes };
+}
+function recordCrossingTopics(inside, outside, parent, result) {
+  const mine = topicEnds(inside);
+  const theirs = topicEnds(outside);
+  const list = (ids) => [...ids ?? []].sort().join(", ");
+  for (const [topic, emitters] of [...mine.emits].sort(([a], [b]) => a.localeCompare(b))) {
+    if (mine.subscribes.has(topic) || !theirs.subscribes.has(topic)) continue;
+    result.topicsCrossing.push(`${topic}: emitted by ${list(emitters)} (the new project), consumed in ${parent} by ${list(theirs.subscribes.get(topic))} \u2014 the family run pairs it; the new project's own gate alone reports UNCONSUMED_TOPIC`);
+  }
+  for (const [topic, subscribers] of [...mine.subscribes].sort(([a], [b]) => a.localeCompare(b))) {
+    if (mine.emits.has(topic) || !theirs.emits.has(topic)) continue;
+    result.topicsCrossing.push(`${topic}: consumed by ${list(subscribers)} (the new project), emitted in ${parent} by ${list(theirs.emits.get(topic))} \u2014 the family run pairs it; the new project's own gate alone reports UNSOURCED_SUBSCRIPTION`);
+  }
+}
 function recordRespelling(result, edit4, member) {
   if (edit4.from === edit4.to) return;
   const list = member ? result.memberRespelled : result.respelled;
@@ -40027,7 +41116,9 @@ function rebaseImplementationPaths(specsDir, fromRoot, toRoot, only) {
     } catch {
       continue;
     }
-    if (!raw || typeof raw !== "object" || !("contract" in raw)) continue;
+    if (!raw || typeof raw !== "object") continue;
+    const isImplementation = "contract" in raw;
+    if (!isImplementation && specKind(raw) !== "type") continue;
     let changed = false;
     const rebase = (holder, key2) => {
       const p = holder[key2];
@@ -40038,7 +41129,7 @@ function rebaseImplementationPaths(specsDir, fromRoot, toRoot, only) {
         changed = true;
       }
     };
-    for (const key2 of ["sourcePath", "simPath"]) rebase(raw, key2);
+    for (const key2 of isImplementation ? ["sourcePath", "simPath"] : ["sourcePath"]) rebase(raw, key2);
     if (Array.isArray(raw.methods)) {
       for (const method of raw.methods) {
         if (method && typeof method === "object") rebase(method, "sourcePath");
@@ -40088,13 +41179,13 @@ function renameComponent(componentId, newId) {
   const contracts = interfaces.filter((i) => i.component === componentId);
   const movingInterface = contracts.find((i) => i.id === `i${componentId}`);
   const movingImplementation = implementations.find((impl) => impl.id === `${componentId}_impl` && contracts.some((i) => i.id === impl.contract));
-  const renamed = [
+  const renamed2 = [
     { kind: "component", from: componentId, to: newId },
     ...movingInterface ? [{ kind: "interface", from: movingInterface.id, to: interfaceId }] : [],
     ...movingImplementation ? [{ kind: "implementation", from: movingImplementation.id, to: implementationId }] : []
   ];
   const rename = {
-    specs: renamed.map(({ from, to }) => ({ from, to })),
+    specs: renamed2.map(({ from, to }) => ({ from, to })),
     components: [{ from: componentId, to: newId }]
   };
   const registerEdits = projectConfigRepository.rekeyCarried(rename, true);
@@ -40109,18 +41200,18 @@ function renameComponent(componentId, newId) {
   const derivesName = (entry) => entry.interface !== void 0 ? movingInterface !== void 0 && entry.interface === movingInterface.id : entry.typeDef === void 0 && entry.component === componentId;
   const keptDry = keepPublicNames(specsDir, derivesName, true);
   assertSpecsInReach(
-    [...renamed.map(({ kind, from }) => ({ kind, id: from })), ...keptDry.specs, ...rewriteRefFields(specsDir, remap, void 0, true), ...rekeyLintAllows(specsDir, rename, true)],
+    [...renamed2.map(({ kind, from }) => ({ kind, id: from })), ...keptDry.specs, ...rewriteRefFields(specsDir, remap, void 0, true), ...rekeyLintAllows(specsDir, rename, true)],
     `renaming component "${componentId}"`,
     Array.isArray(registerEdits) && registerEdits.length > 0
   );
   const kept = keepPublicNames(specsDir, derivesName);
   const rewrittenRefs = [...kept.specs, ...rewriteRefFields(specsDir, remap)];
   const allowsRekeyed = rekeyLintAllows(specsDir, rename);
-  const rewritten = [...new Set([...rewrittenRefs, ...allowsRekeyed].filter((spec) => !renamed.some((moved) => moved.kind === spec.kind && moved.from === spec.id)).map((spec) => spec.id))];
+  const rewritten = [...new Set([...rewrittenRefs, ...allowsRekeyed].filter((spec) => !renamed2.some((moved) => moved.kind === spec.kind && moved.from === spec.id)).map((spec) => spec.id))];
   invalidateSpecCache();
   moveRenamedSpecs(componentId, newId, component, movingInterface, movingImplementation);
   const carried = projectConfigRepository.rekeyCarried(rename);
-  return { renamed, rewritten, carried, keptPublicNames: kept.names };
+  return { renamed: renamed2, rewritten, carried, keptPublicNames: kept.names };
 }
 function moveRenamedSpecs(componentId, newId, component, movingInterface, movingImplementation) {
   const interfaceId = `i${newId}`;
@@ -40269,7 +41360,7 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   }
   const implementations = loadImplementationSpecs();
   const movingContracts = new Set(moving.map((i) => i.id));
-  const renamed = [];
+  const renamed2 = [];
   const rename = {
     methods: [{
       component: componentId,
@@ -40304,7 +41395,7 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
         ...m.params === void 0 && m.signatureFrom === void 0 ? { signature: renameInSignature(m.signature, methodName, newName) } : {}
       } : m)
     });
-    renamed.push(contract.id);
+    renamed2.push(contract.id);
   }
   let pinnedSymbol;
   for (const implementation of implementations) {
@@ -40317,7 +41408,7 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
       ...implementation,
       methods: implementation.methods.map((m) => m.name === methodName ? { ...m, name: newName, ...pin2 ? { symbol: methodName } : {} } : m)
     });
-    renamed.push(implementation.id);
+    renamed2.push(implementation.id);
   }
   invalidateSpecCache();
   const specsDir = aiPathsAt(getProjectRoot()).specsDir();
@@ -40331,7 +41422,7 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
     component: componentId,
     from: methodName,
     to: newName,
-    renamed,
+    renamed: renamed2,
     rewritten,
     mentions,
     ...pinnedSymbol ? { pinnedSymbol } : {},
@@ -40522,9 +41613,9 @@ function renameType(typeId, newId) {
     Array.isArray(registerEdits) && registerEdits.length > 0
   );
   const kept = keepPublicNames(specsDir, derivesName);
-  const respelled = respellAll(false);
+  const respelled2 = respellAll(false);
   const allowsRekeyed = rekeyLintAllows(specsDir, rename);
-  const rewritten = [...new Set([...kept.specs, ...respelled, ...allowsRekeyed].filter((spec) => !(spec.kind === "type" && spec.id === oldId)).map((spec) => spec.id))];
+  const rewritten = [...new Set([...kept.specs, ...respelled2, ...allowsRekeyed].filter((spec) => !(spec.kind === "type" && spec.id === oldId)).map((spec) => spec.id))];
   invalidateSpecCache();
   const moved = loadTypeSpecs().find((t) => t.id === oldId && (t.subsystem ?? "") === (type.subsystem ?? "")) ?? type;
   saveSpec("type", { ...moved, id: newId, previousIds: traced(moved.previousIds, oldId) });
@@ -40541,6 +41632,81 @@ function renameType(typeId, newId) {
     carried
   };
 }
+function renameField(typeId, field, newName) {
+  const all = loadTypeSpecs();
+  const cut = typeId.lastIndexOf("::");
+  const qualifier = cut >= 0 ? typeId.slice(0, cut) : void 0;
+  const ownSubsystem = qualifier !== void 0 && loadSubsystemSpecs().some((s) => s.id === qualifier);
+  if (qualifier !== void 0 && !ownSubsystem) {
+    throw new WaironError(`chained-type: "${typeId}" lives in another project; rename its field from that project's own root. ${memberRootWay(typeId, `sdd_rename_field ${typeId.slice(cut + 2)} ${field} <new name>`)}`);
+  }
+  const type = qualifier !== void 0 ? all.find((t) => t.id === typeId.slice(cut + 2) && t.subsystem === qualifier) ?? null : loadTypeSpec(typeId);
+  if (!type) throw new WaironError(`type-missing: no type has the id "${typeId}".`);
+  if (type.id.includes("::")) {
+    throw new WaironError(`chained-type: "${type.id}" lives in another project; rename its field from that project's own root.`);
+  }
+  const fields = type.fields ?? [];
+  const moving = fields.find((f) => f.name === field);
+  if (!moving) {
+    throw new WaironError(`field-missing: type "${type.id}" declares no field "${field}"${fields.length ? ` (it declares ${fields.map((f) => f.name).join(", ")})` : ""}.`);
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(newName)) {
+    throw new WaironError(`invalid-name: "${newName}" is not an identifier (a letter or underscore, then letters, digits or underscores).`);
+  }
+  const taken = fields.find((f) => f !== moving && f.name === newName);
+  if (taken) throw new WaironError(`name-taken: type "${type.id}" already has a field "${newName}".`);
+  const retired = fields.find((f) => f !== moving && (f.previousNames ?? []).includes(newName));
+  if (retired) {
+    throw new WaironError(`name-retired: field "${retired.name}" of type "${type.id}" lists "${newName}" in its previousNames \u2014 the name is retired on this type. Unsetting that previousNames releases it.`);
+  }
+  if (newName === field) return { type: qualifiedTypeId(type), from: field, to: newName, rewritten: [] };
+  const others = all.filter((t) => t !== type);
+  const namesField = (ref, owner) => {
+    if (typeof ref !== "string") return false;
+    const dot = ref.lastIndexOf(".");
+    if (dot <= 0 || ref.slice(dot + 1) !== field) return false;
+    const head2 = ref.slice(0, dot);
+    if (!typeMatchesRef(type, head2)) return false;
+    if (!others.some((t) => typeMatchesRef(t, head2))) return true;
+    return (owner ?? "") === (type.subsystem ?? "");
+  };
+  const specsDir = aiPathsAt(getProjectRoot()).specsDir();
+  const respell = (dryRun) => {
+    const out = [];
+    for (const file of listFilesRecursive(specsDir, ".yaml")) {
+      let raw;
+      try {
+        raw = readYamlFile(file);
+      } catch {
+        continue;
+      }
+      if (!raw || typeof raw !== "object" || specKind(raw) !== "type") continue;
+      if (raw.id === type.id && (raw.subsystem ?? "") === (type.subsystem ?? "")) continue;
+      const owner = typeof raw.subsystem === "string" ? raw.subsystem : void 0;
+      let changed = false;
+      for (const f of Array.isArray(raw.fields) ? raw.fields : []) {
+        if (!namesField(f?.references, owner)) continue;
+        f.references = `${f.references.slice(0, f.references.lastIndexOf("."))}.${newName}`;
+        changed = true;
+      }
+      if (!changed) continue;
+      if (!dryRun) writeYamlFile(file, raw);
+      out.push({ kind: "type", id: String(raw.id) });
+    }
+    return out;
+  };
+  assertSpecsInReach([{ kind: "type", id: type.id }, ...respell(true)], `renaming field "${field}" of type "${typeId}"`, false);
+  const rewritten = respell(false).map((spec) => spec.id);
+  invalidateSpecCache();
+  const stored = loadTypeSpecs().find((t) => t.id === type.id && (t.subsystem ?? "") === (type.subsystem ?? "")) ?? type;
+  const renamed2 = (stored.fields ?? []).map((f) => {
+    const self = namesField(f.references, type.subsystem) ? { references: `${f.references.slice(0, f.references.lastIndexOf("."))}.${newName}` } : {};
+    return f.name === field ? { ...f, ...self, name: newName, previousNames: [...f.previousNames ?? [], field] } : { ...f, ...self };
+  });
+  saveSpec("type", { ...stored, fields: renamed2 });
+  invalidateSpecCache();
+  return { type: qualifiedTypeId(type), from: field, to: newName, rewritten };
+}
 function typeFileOf(id, type) {
   return getTypePath(id, type.subsystem, type.group);
 }
@@ -41458,17 +42624,25 @@ function composeAgentBrief(agentId) {
     domainName: "",
     variantGuidance: record.variantGuidance ?? ""
   });
-  const codeFence = codeFenceOf(record);
+  const ownFence = codeFenceOf(record);
+  const shared = ownFence && isSubsystemOwner(record) ? sharedProjectFiles(ownFence) : [];
+  const codeFence = ownFence ? [...ownFence, ...shared] : ownFence;
   if (codeFence) {
     const shown2 = (p) => /[*?]/.test(p) || fs20.existsSync(path29.resolve(getProjectRoot(), p)) ? `- \`${p}\`` : `- \`${p}\` (planned \u2014 create it)`;
+    const own2 = ownFence ?? [];
+    const sharedSection = shared.length > 0 ? `
+Shared with the other subsystem owners (the project's setup and shared code; coordinate edits):
+
+${shared.map(shown2).join("\n")}
+` : "";
     instructions = `${instructions.trimEnd()}
 
 ## Code write fence
 
-${codeFence.length > 0 ? `Write code only here (and tests beside it, as the project lays tests out):
+${own2.length > 0 ? `Write code only here (and tests beside it, as the project lays tests out):
 
-${codeFence.map(shown2).join("\n")}
-` : "No spec names a code location yet, so no code location is declared. The spawning session should declare the planned `sourcePath` on the implementation now \u2014 it is code linkage, not part of the approval, so declaring it costs no re-lock \u2014 and that file is then this agent's fence.\n"}`;
+${own2.map(shown2).join("\n")}
+` : "No spec names a code location yet, so no code location is declared. The spawning session should declare the planned `sourcePath` on the implementation now \u2014 it is code linkage, not part of the approval, so declaring it costs no re-lock \u2014 and that file is then this agent's fence.\n"}${sharedSection}`;
   }
   const guidance = loadAgentOverride(agentId);
   if (guidance !== null) {
@@ -41480,8 +42654,7 @@ ${guidance.trim()}
 `;
   }
   const language = implementationLanguage(record);
-  const dialect = language ? typeDialectFor(language) : null;
-  const typeMapping = dialect ? dialect.mappingLines() : void 0;
+  const typeMapping = (language ? typeMappingFor(language) : null) ?? void 0;
   if (typeMapping) {
     instructions = `${instructions.trimEnd()}
 
@@ -41492,6 +42665,19 @@ Contracts speak wairon's neutral type grammar; write each type in ${language} as
 ${typeMapping.map((line) => `- ${line}`).join("\n")}
 `;
   }
+  const externals = externalsUsedBy(record);
+  let readPaths = record.readPaths;
+  if (externals.length > 0) {
+    instructions = `${instructions.trimEnd()}
+
+## Externals used
+
+These components reach other projects through \`alias::name\`; code against the pinned snapshot, never the producer's source:
+
+${externals.map(describeExternal).join("\n")}
+`;
+    readPaths = [.../* @__PURE__ */ new Set([...record.readPaths, ...externals.map((e) => e.pin)])];
+  }
   const profile = deriveExecutionProfile(record);
   const budget = resolveBudget(profile, config.execution, record.id);
   return {
@@ -41500,7 +42686,7 @@ ${typeMapping.map((line) => `- ${line}`).join("\n")}
     template: record.template,
     domainRoot: record.domainRoot,
     ownedPaths: record.ownedPaths,
-    readPaths: record.readPaths,
+    readPaths,
     instructions,
     variantGuidance: record.variantGuidance || void 0,
     ...typeMapping ? { typeMapping } : {},
@@ -41520,8 +42706,8 @@ function codeLocationsOf(impl) {
   return files;
 }
 function codeFenceOf(record) {
-  const implementsComponents = record.template === "implementer" || record.template === "domain-owner" && record.creationReason.startsWith("Automatically inferred from L1");
-  if (!implementsComponents) return null;
+  const implementsComponents2 = record.template === "implementer" || record.template === "domain-owner" && record.creationReason.startsWith("Automatically inferred from L1");
+  if (!implementsComponents2) return null;
   const files = record.ownedPaths.filter((p) => !p.startsWith(".wai/") && !p.includes("/.wai/") && !/[*?]/.test(p));
   if (files.length === 0) return [];
   const dirs = files.map((f) => path29.posix.dirname(f.replace(/\\/g, "/")));
@@ -41543,7 +42729,7 @@ function implementationLanguage(record) {
   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();
+      if (typeMappingFor(name)) return name.toLowerCase();
     }
   }
   for (const impl of implementations) {
@@ -41556,7 +42742,13 @@ function implementationLanguage(record) {
     const language = languageOfSourcePath(file);
     if (language) return language;
   }
-  return void 0;
+  if (!implementsComponents(record)) return void 0;
+  const subsystem = loadSubsystemSpecs().find((s) => record.ownedPaths.some((p) => p.includes(`/${s.id}/`) || p.endsWith(`/${s.id}.yaml`)));
+  const declared = subsystem?.targetLanguage ?? loadSystemSpec()?.targetLanguage;
+  return declared ? declared.toLowerCase() : void 0;
+}
+function implementsComponents(record) {
+  return record.template === "implementer" || isSubsystemOwner(record);
 }
 function memberHop(agentId) {
   const at = agentId.indexOf("::");
@@ -41587,6 +42779,103 @@ function loadRegistry() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function isSubsystemOwner(record) {
+  return record.template === "domain-owner" && record.creationReason.startsWith("Automatically inferred from L1");
+}
+var SHARED_SETUP_FILES = [
+  "package.json",
+  "package-lock.json",
+  "tsconfig.json",
+  "Cargo.toml",
+  "Cargo.lock",
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt",
+  "go.mod"
+];
+var SHARED_ROOT_FILES = ["src/lib.rs", "src/main.rs", "src/index.ts", "src/__init__.py"];
+function sharedProjectFiles(fence) {
+  const root = getProjectRoot();
+  const claimed = new Set(fence);
+  for (const impl of loadImplementationSpecs()) for (const file of implementationSourceFiles(impl)) claimed.add(file);
+  const out = [];
+  const add2 = (file) => {
+    if (!claimed.has(file) && !out.includes(file)) out.push(file);
+  };
+  for (const file of [...SHARED_SETUP_FILES, ...SHARED_ROOT_FILES]) {
+    if (fs20.existsSync(path29.join(root, file))) add2(file);
+  }
+  for (const type of loadTypeSpecs()) {
+    if (type.subsystem) continue;
+    for (const file of typeSourceFiles(type)) add2(file);
+  }
+  return out;
+}
+function implementedComponents(record) {
+  const owned = new Set(record.ownedPaths);
+  const components = loadComponentSpecs();
+  const contractOwner = new Map(loadInterfaceSpecs().map((i) => [i.id, i.component]));
+  const ids = /* @__PURE__ */ new Set();
+  for (const impl of loadImplementationSpecs()) {
+    if (!implementationSourceFiles(impl).some((file) => owned.has(file))) continue;
+    const component = contractOwner.get(impl.contract);
+    if (component) ids.add(component);
+  }
+  if (record.id.endsWith("-implementer")) ids.add(record.id.slice(0, -"-implementer".length));
+  return components.filter((c) => ids.has(c.id));
+}
+function externalsUsedBy(record) {
+  const components = implementedComponents(record);
+  if (components.length === 0) return [];
+  const ids = new Set(components.map((c) => c.id));
+  const refs = [];
+  for (const c of components) refs.push(...c.dependsOn, ...c.owns ?? []);
+  const contracts = loadInterfaceSpecs().filter((i) => ids.has(i.component));
+  for (const contract of contracts) if (contract.implements) refs.push(contract.implements);
+  const contractIds = new Set(contracts.map((i) => i.id));
+  for (const impl of loadImplementationSpecs()) {
+    if (!contractIds.has(impl.contract)) continue;
+    for (const method of impl.methods) {
+      for (const step of method.narrative) if (step.targetComponent) refs.push(step.targetComponent);
+      for (const call of method.calls ?? []) refs.push(call.slice(0, call.lastIndexOf(".")));
+    }
+  }
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const cut = ref.indexOf("::");
+    if (cut <= 0) continue;
+    const alias = ref.slice(0, cut);
+    const names = byAlias.get(alias) ?? /* @__PURE__ */ new Set();
+    names.add(ref.slice(cut + 2));
+    byAlias.set(alias, names);
+  }
+  const root = getProjectRoot();
+  const out = [];
+  for (const [alias, names] of [...byAlias].sort(([a], [b]) => a.localeCompare(b))) {
+    const pin2 = `.wai/externals/${alias}.yaml`;
+    const bindings = /* @__PURE__ */ new Map();
+    let pinned = false;
+    try {
+      const doc = readYamlFile(path29.join(root, pin2));
+      pinned = !!doc;
+      for (const entry of doc?.interfaces ?? []) {
+        if (entry.id && names.has(entry.id)) bindings.set(entry.id, { transport: entry.transport, abi: entry.abi });
+      }
+    } catch {
+    }
+    out.push({ alias, names: [...names].sort(), pin: pin2, pinned, bindings });
+  }
+  return out;
+}
+function describeExternal(use) {
+  const names = use.names.map((name) => {
+    const binding = use.bindings.get(name);
+    const how = [binding?.transport ? `transport ${binding.transport}` : "", binding?.abi ? `abi ${binding.abi}` : ""].filter(Boolean).join(", ");
+    return `\`${use.alias}::${name}\`${how ? ` (${how})` : ""}`;
+  });
+  return `- **${use.alias}** \u2014 uses ${names.join(", ")}; pinned snapshot \`${use.pin}\`${use.pinned ? "" : " (not pinned yet \u2014 run `wairon externals pin` before coding against it)"}`;
+}
 
 // src/exporters/generate.ts
 var path33 = __toESM(require("path"));
@@ -42432,10 +43721,10 @@ function migrate(apply3) {
         rewrite(id, "retired-allow", `allow of ${a.code}${at} removed`, `${a.code} is retired with the rule that reported it.`);
         continue;
       }
-      const renamed = RENAMED_CODES[a.code];
-      if (renamed !== void 0) {
-        rewrite(id, "retired-allow", `allow of ${a.code}${at} rekeyed to ${renamed}`, `${a.code} is renamed ${renamed}.`);
-        kept.push({ ...a, code: renamed });
+      const renamed2 = RENAMED_CODES[a.code];
+      if (renamed2 !== void 0) {
+        rewrite(id, "retired-allow", `allow of ${a.code}${at} rekeyed to ${renamed2}`, `${a.code} is renamed ${renamed2}.`);
+        kept.push({ ...a, code: renamed2 });
         continue;
       }
       kept.push(a);
@@ -42485,23 +43774,59 @@ function designDigest(kind, content) {
   const key2 = `${kind ?? ""}\0${content}`;
   const memo2 = designDigestMemo.get(key2);
   if (memo2 !== void 0) return memo2;
+  const parsed = parsedSpec(content);
+  if (!parsed) return digest(content);
+  const out = viewDigest(designViewOf(kind, parsed));
+  if (designDigestMemo.size > 2e4) designDigestMemo.clear();
+  designDigestMemo.set(key2, out);
+  return out;
+}
+var STATUS_CANDIDATES = [void 0, "draft", "design", "complete"];
+function designViewOf(kind, parsed) {
+  switch (kind) {
+    case "implementation":
+      return implementationDesignView(parsed);
+    case "type":
+      return typeDesignView(parsed);
+    case "component":
+      return componentDesignView(parsed);
+    case "subsystem":
+      return subsystemDesignView(parsed);
+    case "interface":
+      return interfaceDesignView(parsed);
+    default:
+      return parsed;
+  }
+}
+function parsedSpec(content) {
   let parsed;
   try {
     parsed = parseYaml(content);
   } catch {
-    return digest(content);
+    return null;
   }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return digest(content);
-  const view3 = kind === "implementation" ? implementationDesignView(parsed) : kind === "type" ? typeDesignView(parsed) : kind === "component" ? componentDesignView(parsed) : parsed;
-  const out = crypto7.createHash("sha256").update(canonicalize(view3), "utf8").digest("hex");
-  if (designDigestMemo.size > 2e4) designDigestMemo.clear();
-  designDigestMemo.set(key2, out);
-  return out;
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+}
+function viewDigest(view3) {
+  return crypto7.createHash("sha256").update(canonicalize(view3), "utf8").digest("hex");
+}
+function statusApprovedIn(kind, content, recorded) {
+  const parsed = parsedSpec(content);
+  if (!parsed) return void 0;
+  const view3 = designViewOf(kind, parsed);
+  for (const status of STATUS_CANDIDATES) {
+    const candidate = status === void 0 ? view3 : { ...view3, status };
+    if (viewDigest(candidate) === recorded) return status ?? null;
+  }
+  return void 0;
+}
+function designMatches(kind, content, current2, recorded) {
+  return current2 === recorded || statusApprovedIn(kind, content, recorded) !== void 0;
 }
 function linkedKindsByFile() {
   const paths = scanAllSpecs().paths;
   const kinds = /* @__PURE__ */ new Map();
-  for (const kind of ["implementation", "type", "component"]) {
+  for (const kind of ["implementation", "type", "component", "subsystem", "interface"]) {
     for (const file of Object.values(paths[kind])) kinds.set(path35.resolve(file), kind);
   }
   return kinds;
@@ -42560,15 +43885,24 @@ function diffAgainstApproval(root = getProjectRoot()) {
   const record = approvalRecord(root);
   const approved = record?.specs ?? null;
   if (!approved) return null;
-  const current2 = currentSpecDigests(root, readingOf(record));
+  const reading = readingOf(record);
+  const files = new Map(ownSpecFiles2(root).map((f) => [f.key, f]));
+  const current2 = {};
+  for (const [key2, file] of files) current2[key2] = digestIn(reading, file.kind, file.content);
   const added = [];
   const changed = [];
   const removed = [];
   const unchangedPaths = [];
+  const same = (rel2, before, now) => {
+    if (before === now) return true;
+    if (reading !== "design") return false;
+    const file = files.get(rel2);
+    return designMatches(file.kind, file.content, now, before);
+  };
   for (const [rel2, d] of Object.entries(current2)) {
     const before = approved[rel2];
     if (before === void 0) added.push(rel2);
-    else if (before !== d) changed.push(rel2);
+    else if (!same(rel2, before, d)) changed.push(rel2);
     else unchangedPaths.push(rel2);
   }
   for (const rel2 of Object.keys(approved)) {
@@ -42591,23 +43925,38 @@ function settledSpecPaths(root = getProjectRoot()) {
 var REEXPRESSED_BY = "wairon doctor --fix";
 function reexpress(gate) {
   const record = readLockRecord();
+  if (!record) return null;
+  const fromReading = readingOf(record);
   const asRecorded = gate.asRecorded;
-  const holds = !!asRecorded && record?.stateId.algorithm === asRecorded.algorithm && record.stateId.digest === asRecorded.digest;
-  if (!record || record.specsReading === "design" || !holds) return null;
-  const specs = captureApprovedSpecs();
-  return {
-    ...record,
-    stateId: { algorithm: gate.algorithm, digest: gate.digest },
-    specs,
-    specsReading: "design",
-    format: 3,
-    reexpressed: {
-      at: (/* @__PURE__ */ new Date()).toISOString(),
-      fromAlgorithm: record.stateId.algorithm,
-      fromReading: "content",
-      by: REEXPRESSED_BY
-    }
-  };
+  const holds = !!asRecorded && record.stateId.algorithm === asRecorded.algorithm && record.stateId.digest === asRecorded.digest;
+  const reexpressed = { at: (/* @__PURE__ */ new Date()).toISOString(), fromAlgorithm: record.stateId.algorithm, fromReading, by: REEXPRESSED_BY };
+  if (holds) {
+    return {
+      ...record,
+      stateId: { algorithm: gate.algorithm, digest: gate.digest },
+      specs: captureApprovedSpecs(),
+      specsReading: "design",
+      format: 3,
+      reexpressed
+    };
+  }
+  if (fromReading !== "content" || !record.specs) return null;
+  const diff2 = diffAgainstApproval();
+  if (!diff2 || diffSize(diff2) > 0) return null;
+  return { ...record, specs: captureApprovedSpecs(), specsReading: "design", format: 3, reexpressed };
+}
+function approvedStatuses(record, root = getProjectRoot()) {
+  const out = /* @__PURE__ */ new Map();
+  if (record.specsReading !== "design" || !record.specs) return out;
+  for (const file of ownSpecFiles2(root)) {
+    const recorded = record.specs[file.key];
+    if (recorded === void 0 || !file.kind) continue;
+    const approved = statusApprovedIn(file.kind, file.content, recorded);
+    if (approved === void 0) continue;
+    const id = parsedSpec(file.content)?.id;
+    if (typeof id === "string") out.set(`${file.kind}:${id}`, approved ?? "complete");
+  }
+  return out;
 }
 function approvalVerdict(approvals) {
   const quiet = { text: "", drifted: false };
@@ -42615,10 +43964,10 @@ function approvalVerdict(approvals) {
     const approval = approvalRecord();
     if (!approval) return quiet;
     const by = describeApprover(approval.lockedBy);
-    const notes = memberNotes(approvals ?? [], approval);
+    const diff2 = diffAgainstApproval();
+    const notes = memberNotes(approvals ?? [], approval, diff2);
     const pinDrift = notes.drift;
     const childNote = notes.text;
-    const diff2 = diffAgainstApproval();
     if (!diff2) {
       return {
         text: `
@@ -42665,14 +44014,16 @@ function isContentReadingRecord(record) {
 var REEXPRESS_HINT = "This approval predates lock format 3 and is read in its original reading; `wairon doctor --fix` carries it into the design reading without a review (the approval stays the approver's), after which adding or moving a sourcePath never drifts it.";
 var FORMAT2_STALE_NOTE = "it was taken before code linkage (sourcePath, symbol, simPath and the like) left the approval, and something it covered moved since \u2014 the design, or only code linkage, which this record can no longer tell apart. One `wairon lock` clears it for good: from then on linkage never drifts the approval";
 var GATE_UPGRADE_NOTE = "the gate identity gained inputs in this release (members' composition subjects, `composition`; code conformance moved beside the claim)";
-function memberNotes(approvals, record) {
+var GATE_MOVED_NOTE = "no own spec file changed since it was taken \u2014 not even its code linkage \u2014 so what moved is the gate it was judged under: the design rules this wairon release judges by, or the project's rule tuning, `composition`, network declaration, consumed contracts or a member's approval. One `wairon lock` re-approves the unchanged design under the current gate";
+function memberNotes(approvals, record, diff2) {
   const own2 = approvals.find((a) => a.key === "");
   const direct = approvals.filter((a) => a.parent === "" && a.as !== "part");
   const moved = direct.filter((a) => a.pinned === "moved");
   const unapproved = direct.filter((a) => a.state !== "approved");
   const lines = [];
   if (own2?.upgraded) {
-    lines.push(record && record.format === 2 ? `This approval no longer matches: ${FORMAT2_STALE_NOTE}.` : `This approval was taken under an earlier gate identity \u2014 ${GATE_UPGRADE_NOTE}. Re-lock once.`);
+    const by = record?.validatorVersion ? ` (taken by wairon ${record.validatorVersion})` : "";
+    lines.push(diff2 && diffSize(diff2) === 0 ? `This approval no longer matches${by}: ${GATE_MOVED_NOTE}.` : record && record.format === 2 ? `This approval no longer matches: ${FORMAT2_STALE_NOTE}.` : `This approval was taken under an earlier gate identity \u2014 ${GATE_UPGRADE_NOTE}. Re-lock once.`);
   }
   if (moved.length) {
     lines.push(`${moved.length} member pin(s) moved since approval: ${moved.map((a) => a.alias ?? a.key).join(", ")} \u2014 re-lock to approve them.`);
@@ -42774,17 +44125,17 @@ This project uses **wairon**. System specs live under \`.wai/specs/\` (L0 System
   - **Deprecated forms** (they still resolve for one release, are reported, and \`wairon doctor --fix\` rewrites them): a leading \`::\` (\`::shared::error-type\`), \`super::\` (\`super::sibling_comp\`), member paths (\`billing::invoice::invoice_portal\`), and an L1 subsystem carrying \`projectPath\` (\`DEPRECATED_MOUNT_FORM\`).
 - **Do not run the \`wairon\` CLI**: Use \`sdd_validate_tree\` and \`sdd_get_status\` instead of CLI commands.
 - **Handoff to implementation**: Once design is complete and validates cleanly, tell the human: *"The specs are complete and validate. Please run \`wairon lock\` to approve them, and commit \`.wai/lock.json\`."* The lock records the approval; it does not rewrite spec files or their \`status\`. No session restart is needed after the lock \u2014 delegate implementation right away via the \`sdd-delegate\` skill.
-- **Approval, not status**: a design is ready to implement when it is APPROVED \u2014 \`sdd_get_status\` reports the approval state (approved, or which specs changed since), and \`wairon lock-check\` gives the same verdict in CI. A spec's \`status\` (draft/design/complete) is authoring readiness only; never wait for it to become \`complete\`.
+- **Approval, not status**: a design is ready to implement when it is APPROVED \u2014 \`sdd_get_status\` reports the approval state (approved, or which specs changed since), and \`wairon lock-check\` gives the same verdict in CI. A spec's \`status\` (draft/design/complete) is authoring readiness only; never wait for it to become \`complete\`. It is left out of the approval, so promoting a status never reopens an approved design.
 - **Code linkage is not approval**: the lock approves the DESIGN. Where it is realized \u2014 \`sourcePath\`, \`symbol\`, \`exportedVia\`, \`simPath\`, \`injectedParams\`, conformance tiers, timestamps \u2014 is outside the approved digests, so setting or changing it never asks for a re-lock. Declare each implementation's planned \`sourcePath\` at design time: a named file not written yet is \`SOURCE_FILE_PLANNED\` (a notice), at method level as at implementation level; once the component's realization begins (any file it names exists), a contract method naming no file is \`METHOD_SOURCE_PATH_MISSING\` (warning) and one its existing file does not hold is \`UNREALIZED_METHOD\`. \`rules.conformance.requireCode: true\` makes the planned and unlinked notices errors. Briefs fence planned files, marked \`(planned \u2014 create it)\`.
-- **Externals \u2014 the pin gates, live drift is visible**: declare a project this one consumes with \`sdd_add_external\` (alias, and a source \`../sibling\`, \`hosted:<id>\`, \`<git url>\` or \`<git url>#<commit>\`) \u2014 never by hand-editing \`.wai/project.yaml\`; it is checked against the producer and pinned. The owner's gate judges every external against its pin. \`sdd_validate_tree\` and \`sdd_get_status\` also compare each external with its LIVE producer, offline, as ADVISORY findings (\`advisory: true\`): \`EXTERNAL_LIVE_INCOMPATIBLE\` (a used member changed, was renamed \u2014 the new name is given \u2014 or is gone), \`EXTERNAL_DRIFTED\`, \`EXTERNAL_LIVE_UNCOMPARED\`. They never make the tree invalid or fail \`--ci\`; the fix is to adapt the uses, then ask the human to re-pin (\`wairon externals pin <alias>\`). A git producer is compared live only by \`wairon externals status\` \u2014 the opt-in live CI gate (exit 1 incompatible, 2 not compared, 0 otherwise).
+- **Externals \u2014 the pin gates, live drift is visible**: declare a project this one consumes with \`sdd_add_external\` (alias, and a source \`../sibling\`, \`hosted:<id>\`, \`<git url>\` or \`<git url>#<commit>\`) \u2014 never by hand-editing \`.wai/project.yaml\`; it is checked against the producer and pinned. Change its \`use\` imports with \`sdd_update_external\` and remove it (declaration and pin together) with \`sdd_remove_external\`. A name the producer exports to a narrower audience (\`project\` < \`department\` < \`instance\` < \`partner\` < \`external\`) than this project is read at is refused, naming both. The owner's gate judges every external against its pin. \`sdd_validate_tree\` and \`sdd_get_status\` also compare each external with its LIVE producer, offline, as ADVISORY findings (\`advisory: true\`): \`EXTERNAL_LIVE_INCOMPATIBLE\` (a used member changed, was renamed \u2014 the new name is given \u2014 or is gone), \`EXTERNAL_DRIFTED\`, \`EXTERNAL_LIVE_UNCOMPARED\`. They never make the tree invalid or fail \`--ci\`; the fix is to adapt the uses, then ask the human to re-pin (\`wairon externals pin <alias>\`). A git producer is compared live only by \`wairon externals status\` \u2014 the opt-in live CI gate (exit 1 incompatible, 2 not compared, 0 otherwise).
 - **To implement code**: Delegate via the \`sdd-delegate\` skill: fetch the component's live brief with the \`sdd_get_agent_brief\` MCP tool (or the \`wairon-agent://\` resource) and spawn a subagent from it. Briefs are composed per call from the current spec tree, so they are always current \u2014 never wait for a restart. Implementations must match L3 interfaces and L5 narratives exactly. Generated agent files under \`.claude/agents/\` are an optional materialized view of the same topology \u2014 the live briefs are canonical.
 
 ### Rules (enforced by \`sdd_validate_tree\`)
 1. **Design before code**: Complete spec and pass validator before writing source code.
 2. **Human-in-the-loop**: Ask user approval for each spec layer before proceeding.
 3. **Spec consistency**: If a 1:1 narrative match is incorrect or conflicts with L0 requirements, escalate a spec revision first. Never ship mismatched code.
-4. **No persistence shortcuts & strict layers**: A Portal must never depend directly on a Store, Registry, or Adapter. Portal reads MAY go through a Repository/Index facade (passthrough reads need no per-entity Orchestrator ceremony), but a Portal narrative call or dispatch-table binding that reaches a write-effect facade method is an error (\`PORTAL_WRITE_SHORTCUT\`) \u2014 writes always route through an Orchestrator. Held domain state always lives in a dedicated data component, never as fields inside an Orchestrator. Two sanctioned shapes: the RECOMMENDED Repository pattern (owns Store + Registry + Index; consumers depend on the facade), or \u2014 for genuinely simple state \u2014 a deliberately standalone Store (workflow-layer consumers only, acknowledged with a lint.allow reason on the UNOWNED_STORE warning). Never combine Store/Registry/Index roles into one component, and never fold state into a consuming component because a link was refused.
-5. **Every Portal verb is reached**: a modelled caller reaches it (a \`call\` step along \`dependsOn\`, \`alias::portal.verb\` across projects), or it is an **entry** \u2014 callers outside the design reach it: \`invokedBy: { kind: entry, caller }\` on the Portal (every verb inherits it) or on one verb. Declare an entry only for real outside callers (browsers, a CLI user, an AI tool over stdio, applications linking a library) \u2014 **never invent one to silence an \`UNUSED_*\` finding**: model the caller, or remove the verb. A Portal states one \`transport\` (\`HTTP\`, \`gRPC\`, \`GraphQL\`, \`MessageBus\`, \`CLI\`, \`IPC\`, \`NamedPipe\`, \`JSONRPC\` for stdio JSON-RPC, \`InProcess\` for a library, which binds no endpoint). A project may declare \`network\` in \`project.yaml\`: an entry's \`scope\` is then \`outside\` (default) or \`network\` (sibling services), and inside a network only a \`gateway\` Portal is entered from outside. Another project's \`InProcess\` library is called directly from any component \u2014 no client Adapter \u2014 within the purity (\`effect\`) and language-bridge (\`abi\`) checks.
+4. **No persistence shortcuts & strict layers**: A Portal must never depend directly on a Store, Registry, or Adapter. Portal reads MAY go through a Repository/Index facade (passthrough reads need no per-entity Orchestrator ceremony), but a Portal narrative call or dispatch-table binding that reaches a write-effect facade method is an error (\`PORTAL_WRITE_SHORTCUT\`) \u2014 writes always route through an Orchestrator. Held domain state always lives in a dedicated data component, never as fields inside an Orchestrator. Design the SMALLEST sound shape: genuinely simple state (keyed reads and writes) is one standalone Store \u2014 the sanctioned shape, with workflow-layer consumers and a lint.allow reason on the UNOWNED_STORE warning \u2014 and the Repository pattern (a facade owning Store + Registry + one Index per real lookup) is for state with real lookup or index needs. Never split Store/Registry/Index for simple state, never combine their roles into one component, and never fold state into a consuming component because a link was refused.
+5. **Every Portal verb is reached**: a modelled caller reaches it (a \`call\` step along \`dependsOn\`, \`alias::portal.verb\` across projects), or it is an **entry** \u2014 callers outside the design reach it: \`invokedBy: { kind: entry, caller }\` on the Portal (every verb inherits it) or on one verb. Declare an entry only for real outside callers (browsers, a CLI user, an AI tool over stdio, applications linking a library) \u2014 **never invent one to silence an \`UNUSED_*\` finding**: model the caller, or remove the verb. A Portal states one \`transport\` (\`HTTP\`, \`gRPC\`, \`GraphQL\`, \`MessageBus\`, \`CLI\`, \`IPC\`, \`NamedPipe\`, \`JSONRPC\` for stdio JSON-RPC, \`InProcess\` for a library, which binds no endpoint). A project may declare a network (\`sdd_set_network\`; the human runs \`wairon network declare\` \u2014 never a hand edit of \`project.yaml\`): an entry's \`scope\` is then \`outside\` (default) or \`network\` (sibling services), and inside a network only a \`gateway\` Portal is entered from outside. Another project's \`InProcess\` library is called directly from any component \u2014 no client Adapter \u2014 within the purity (\`effect\`) and language-bridge (\`abi\`) checks.
 6. **Naming follows the target language**: methods are named in the project's method casing (camelCase for TypeScript/Java, snake_case for Rust/Python, from \`targetLanguage\` unless \`rules.naming\` says otherwise); a wire name that differs (an HTTP path, a CLI command, a JSON-RPC method) belongs on the method's \`endpoint\`, never in the method name.
 
 ### Component Vocabulary
@@ -43073,7 +44424,7 @@ function getStatusReport(options = {}, decor) {
   const mark = fillDecor(decor);
   scanAllSpecs({ memberDepth: options.memberDepth });
   const system = loadSystemSpec();
-  const loaderErrors = getLoaderIssues();
+  const loaderErrors = getLoaderIssues().filter((issue2) => issue2.severity === "error");
   if (loaderErrors.length > 0) {
     let errText2 = "Failed to parse specification files:\n";
     for (const issue2 of loaderErrors) {
@@ -43087,7 +44438,10 @@ function getStatusReport(options = {}, decor) {
   const partLine = partOf ? `${mark.layer("system", "\u25CF Part of:")} ${mark.emphasis(partOf.project)} ${parentPinState(partOf.project)}
 ` : "";
   if (!system && !partOf) {
-    return { text: "L0 System specification (system.yaml) is missing.", failed: true };
+    if (!pathExists(fromProjectRoot(".wai/project.yaml"))) {
+      return { text: `No wairon project binds this folder (no .wai/project.yaml at ${fromProjectRoot(".")}): there is no design to report.`, failed: true };
+    }
+    return { text: "This project has no L0 System spec yet (.wai/specs/.index.yaml): its design has not been started.", failed: true };
   }
   let subsystems = loadSubsystemSpecs();
   let components = loadComponentSpecs();
@@ -43107,6 +44461,13 @@ function getStatusReport(options = {}, decor) {
   }
   let output = "";
   const componentScores = /* @__PURE__ */ new Map();
+  const family = graph();
+  const ownerOf4 = (key2) => family.owners.get(key2) ?? "";
+  const sourceExists = (specId, file) => {
+    const owner = ownerOf4(specId);
+    const dir = owner === "" ? void 0 : family.nodes.find((n) => n.namespace === owner)?.directory;
+    return pathExists(dir ? path37.resolve(dir, file) : fromProjectRoot(file));
+  };
   for (const comp of components) {
     let score = 20;
     const intf = interfaces.find((i) => i.component === comp.id);
@@ -43117,7 +44478,7 @@ function getStatusReport(options = {}, decor) {
     if (impl) {
       score += 30;
       const sourceFiles = implementationSourceFiles(impl);
-      if (sourceFiles.length > 0 && sourceFiles.every((f) => pathExists(fromProjectRoot(f)))) {
+      if (sourceFiles.length > 0 && sourceFiles.every((f) => sourceExists(impl.id, f))) {
         score += 20;
       }
     }
@@ -43147,13 +44508,6 @@ function getStatusReport(options = {}, decor) {
   const systemScore = subsystems.length > 0 ? Math.round(totalSubsystemsScore / subsystems.length) : 0;
   output += system ? `${mark.layer("system", "\u25CF System:")} ${mark.emphasis(system.name)} ${mark.score(systemScore, `(${systemScore}% Complete)`)}
 ` : partLine;
-  const family = graph();
-  const ownerOf4 = (key2) => family.owners.get(key2) ?? "";
-  const sourceExists = (specId, file) => {
-    const owner = ownerOf4(specId);
-    const dir = owner === "" ? void 0 : family.nodes.find((n) => n.namespace === owner)?.directory;
-    return pathExists(dir ? path37.resolve(dir, file) : fromProjectRoot(file));
-  };
   const holdsShown = (ns) => subsystems.some((s) => ownerOf4(s.id) === ns) || family.nodes.some((n) => n.parent === ns && n.namespace !== ns && holdsShown(n.namespace));
   const partMark = /* @__PURE__ */ new Map();
   for (const node of family.nodes) {
@@ -43194,7 +44548,7 @@ function getStatusReport(options = {}, decor) {
         const methodsWithOwnPath = impl.methods.filter((m) => m.sourcePath);
         let pathStr;
         if (impl.sourcePath) {
-          pathStr = sourceExists(impl.id, impl.sourcePath) ? mark.present(` -> ${impl.sourcePath}`) : mark.missing(` -> ${impl.sourcePath} (File Missing!)`);
+          pathStr = sourceExists(impl.id, impl.sourcePath) ? mark.present(` -> ${impl.sourcePath}`) : mark.draft(` -> ${impl.sourcePath} (planned \u2014 not written yet)`);
         } else if (methodsWithOwnPath.length > 0) {
           pathStr = "";
         } else {
@@ -43208,7 +44562,7 @@ function getStatusReport(options = {}, decor) {
           const isLastMethod = k === methodsWithOwnPath.length - 1;
           const methodPrefix = isLastMethod ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
           const methodPath = method.sourcePath;
-          const methodLine = sourceExists(impl.id, methodPath) ? mark.present(`method ${method.name} -> ${methodPath}`) : mark.missing(`method ${method.name} -> ${methodPath} (File Missing!)`);
+          const methodLine = sourceExists(impl.id, methodPath) ? mark.present(`method ${method.name} -> ${methodPath}`) : mark.draft(`method ${method.name} -> ${methodPath} (planned \u2014 not written yet)`);
           output += `${mark.structure(methodIndent + methodPrefix)}${methodLine}
 `;
         }
@@ -43816,6 +45170,15 @@ function carryInto(restatement, existing, candidate) {
       carried.push(`previousNames (${String(method.name)})`);
     }
   }
+  if (restatement.kind === "type" && Array.isArray(candidate.fields)) {
+    const stored = existing.fields ?? [];
+    for (const field of candidate.fields) {
+      const prev = stored.find((p) => p.name === field.name);
+      if (prev?.previousNames === void 0 || field.previousNames !== void 0) continue;
+      field.previousNames = prev.previousNames;
+      carried.push(`previousNames (field ${String(field.name)})`);
+    }
+  }
   carried.push(...carryUnexpressed(existing, candidate, [...restatement.fields, "createdAt"]));
   return carried;
 }
@@ -44133,7 +45496,7 @@ function buildServerInstructions3() {
 }
 
 // src/network/adapters/files.ts
-var import_yaml14 = require("yaml");
+var import_yaml15 = require("yaml");
 
 // src/network/types.ts
 function workload(party) {
@@ -44214,6 +45577,23 @@ function addFlow(flows3, flow) {
 function byCalleeThenCaller(a, b) {
   return (a.to.project ?? "").localeCompare(b.to.project ?? "") || key(a.to).localeCompare(key(b.to)) || key(a.from).localeCompare(key(b.from));
 }
+function findingLine(f) {
+  return `${f.code}: ${f.message}`;
+}
+function markFlows(flows3, f) {
+  if (f.specId === void 0) return;
+  const onVerb = (flow) => flow.from.scope !== void 0 && flow.to.component === f.specId && (f.at === void 0 || flow.to.verb === f.at);
+  const onCall = (flow) => flow.from.scope === void 0 && flow.from.component === f.specId && f.at !== void 0 && flow.evidence.includes(`call ${f.at}`);
+  for (const flow of flows3.filter((x) => onVerb(x) || onCall(x))) {
+    const field = f.severity === "error" ? "refusedBy" : "flaggedBy";
+    const list = flow[field] ?? [];
+    if (!list.includes(findingLine(f))) list.push(findingLine(f));
+    flow[field] = list;
+  }
+}
+function isRefused(flow) {
+  return (flow.refusedBy?.length ?? 0) > 0;
+}
 function project2(model) {
   const flows3 = /* @__PURE__ */ new Map();
   for (const verb of model.verbs.filter((v) => transportKind(v.transport) === "network")) {
@@ -44226,7 +45606,9 @@ function project2(model) {
     }
     addFlow(flows3, outsideFlow(model, verb));
   }
-  return [...flows3.values()].sort(byCalleeThenCaller);
+  const marked = [...flows3.values()];
+  for (const f of model.findings ?? []) markFlows(marked, f);
+  return marked.sort(byCalleeThenCaller);
 }
 function networkName2(id) {
   return id === "" ? "(root network)" : id;
@@ -44236,24 +45618,89 @@ function chainOf(flow) {
   for (const network of flow.crosses) lines.push(`enters network ${networkName2(network)}`);
   if (flow.via !== void 0) lines.push(`through gateway ${flow.via}`);
   lines.push(`reaches ${key(flow.to)} over ${flow.transport}${flow.binding ? ` (${flow.binding})` : ""}`);
+  for (const flag of flow.flaggedBy ?? []) lines.push(`marked by the gate: ${flag}`);
   return lines;
 }
-function notAllowed(flows3, from, to) {
-  const nearest = flows3.filter((f) => isNamed(f.to, to)).slice(0, 10);
+function verbParty(v) {
+  return { project: v.project, ...v.subsystem !== void 0 ? { subsystem: v.subsystem } : {}, component: v.portal, verb: v.verb };
+}
+function reachesOverNetwork(model, to) {
+  return model.verbs.some((v) => transportKind(v.transport) === "network" && isNamed(verbParty(v), to));
+}
+function isKnown(model, name) {
+  if (name === "outside" || name === "network") return true;
+  if (name.startsWith("network:")) return model.networks.some((n) => n.id === name.slice("network:".length));
+  const placed = (model.placements ?? []).some((p) => isNamed({ project: p.project, ...p.subsystem !== void 0 ? { subsystem: p.subsystem } : {}, component: p.component }, name));
+  return placed || model.verbs.some((v) => isNamed(verbParty(v), name)) || model.calls.some((c) => isNamed(callerOf(c), name));
+}
+function notAllowed(model, flows3, refused3, from, to) {
+  if (refused3.length > 0) {
+    const refusedBy = [...new Set(refused3.flatMap((f) => f.refusedBy ?? []))];
+    const chain2 = [`the design names ${refused3.length === 1 ? "a flow" : `${refused3.length} flows`} from ${from} to ${to}, but the gate refuses ${refused3.length === 1 ? "it" : "them"}: nothing admits it until the design passes \`wairon validate\``];
+    for (const f of refused3) chain2.push(`refused: ${key(f.from)} -> ${key(f.to)} over ${f.transport}${f.binding ? ` (${f.binding})` : ""}`);
+    for (const line of refusedBy) chain2.push(`  ${line}`);
+    return { allowed: false, flows: [], chain: chain2, refusedBy };
+  }
+  if (!reachesOverNetwork(model, to)) {
+    return {
+      allowed: false,
+      flows: [],
+      inProcess: true,
+      chain: [
+        `${to} takes no network flow: it is reached in-process (a direct call, or a local transport, inside one process), so the design neither allows nor forbids a network flow to it`,
+        "network flows are made only by verbs of Portals with a network transport (HTTP, gRPC, GraphQL, MessageBus, Custom)"
+      ]
+    };
+  }
+  const nearest = flows3.filter((f) => isNamed(f.to, to) && !isRefused(f)).slice(0, 10);
   const chain = [`nothing in the design allows ${from} to reach ${to}`];
   if (nearest.length === 0) chain.push(`no flow reaches ${to} at all`);
   for (const f of nearest) chain.push(`allowed instead: ${key(f.from)} -> ${key(f.to)} over ${f.transport}`);
   return { allowed: false, flows: [], chain };
 }
-function explain(flows3, from, to) {
+function explain(flows3, from, to, model) {
+  const unknown = [from, to].filter((n) => !isKnown(model, n));
+  if (unknown.length > 0) {
+    return {
+      allowed: false,
+      flows: [],
+      unknown,
+      chain: [
+        ...unknown.map((n) => `unknown party "${n}": nothing in the design is named so`),
+        "name a party as outside, network[:<id>], a project, a subsystem or a component, and a callee also as portal.verb; a subsystem of this project is named bare (a project is reached as <alias>::<name>)"
+      ]
+    };
+  }
   const selected = flows3.filter((f) => isNamed(f.from, from) && isNamed(f.to, to));
-  if (selected.length === 0) return notAllowed(flows3, from, to);
-  const chain = selected.flatMap((f, i) => [...selected.length > 1 ? [`flow ${i + 1}:`] : [], ...chainOf(f)]);
-  return { allowed: true, flows: selected, chain };
+  const admitted = selected.filter((f) => !isRefused(f));
+  if (admitted.length === 0) return notAllowed(model, flows3, selected.filter(isRefused), from, to);
+  const chain = admitted.flatMap((f, i) => [...admitted.length > 1 ? [`flow ${i + 1}:`] : [], ...chainOf(f)]);
+  return { allowed: true, flows: admitted, chain };
 }
 
 // src/network/codec.ts
-var COLUMNS = ["from", "to", "transport", "binding", "crosses", "via", "evidence"];
+var COLUMNS = ["from", "to", "transport", "binding", "crosses", "via", "evidence", "gate"];
+function refusedFlow(flow) {
+  return (flow.refusedBy?.length ?? 0) > 0;
+}
+function codeOf(line) {
+  const cut = line.indexOf(":");
+  return cut === -1 ? line : line.slice(0, cut);
+}
+function gateCell(flow) {
+  if (refusedFlow(flow)) return `REFUSED: ${[...new Set(flow.refusedBy.map(codeOf))].join("; ")}`;
+  return [...new Set((flow.flaggedBy ?? []).map(codeOf))].join("; ");
+}
+function gateFindingsOf(flows3) {
+  const errors = /* @__PURE__ */ new Set();
+  const flags = /* @__PURE__ */ new Set();
+  for (const f of flows3) {
+    for (const line of f.refusedBy ?? []) errors.add(line);
+    for (const line of f.flaggedBy ?? []) flags.add(line);
+  }
+  const withSeverity = (line, severity) => `${codeOf(line)} (${severity})${line.slice(codeOf(line).length)}`;
+  return [...[...errors].map((l) => withSeverity(l, "error")), ...[...flags].map((l) => withSeverity(l, "warning"))];
+}
 function networkName3(id) {
   return id === "" ? "(root network)" : id;
 }
@@ -44265,7 +45712,8 @@ function cells(flow) {
     flow.binding ?? "",
     flow.crosses.map(networkName3).join("; "),
     flow.via ?? "",
-    flow.evidence.join("; ")
+    flow.evidence.join("; "),
+    gateCell(flow)
   ];
 }
 function sortedKeys2(value) {
@@ -44282,16 +45730,19 @@ function markdownOf(flows3) {
   const escape = (cell) => cell === "" ? " " : cell.replace(/\|/g, "\\|").replace(/\n/g, " ");
   const rows = flows3.map((f) => `| ${cells(f).map(escape).join(" | ")} |`);
   const header = [`| ${COLUMNS.join(" | ")} |`, `|${COLUMNS.map(() => "---").join("|")}|`];
-  return [...header, ...rows].join("\n") + "\n" + (flows3.length === 0 ? "\n_No network-transport flows: in-process and local verbs never produce one._\n" : "");
+  const refused3 = flows3.filter(refusedFlow);
+  const warning = refused3.length > 0 ? [`> **The design fails the gate:** ${refused3.length} row(s) marked REFUSED are refused by \`wairon validate\`, not allowed. Fix the design before trusting this matrix.`, ...gateFindingsOf(flows3).map((l) => `> - ${l.replace(/\n/g, " ")}`), ""] : [];
+  return [...warning, ...header, ...rows].join("\n") + "\n" + (flows3.length === 0 ? "\n_No network-transport flows: in-process and local verbs never produce one._\n" : "");
 }
 function encodeFlows(flows3, format) {
+  const gate = { gateFindings: gateFindingsOf(flows3), refused: flows3.some(refusedFlow) };
   switch (format) {
     case "json":
-      return { format, content: JSON.stringify(sortedKeys2(flows3), null, 2) + "\n", unbound: [] };
+      return { format, content: JSON.stringify(sortedKeys2(flows3), null, 2) + "\n", unbound: [], ...gate };
     case "csv":
-      return { format, content: csvOf(flows3), unbound: [] };
+      return { format, content: csvOf(flows3), unbound: [], ...gate };
     default:
-      return { format: "markdown", content: markdownOf(flows3), unbound: [] };
+      return { format: "markdown", content: markdownOf(flows3), unbound: [], ...gate };
   }
 }
 
@@ -44304,7 +45755,7 @@ function flows(options, format) {
 function why(options, from, to) {
   const model = reachModel2(options);
   const matrix = project2(model);
-  return explain(matrix, from, to);
+  return explain(matrix, from, to, model);
 }
 
 // src/mcp/network.ts
@@ -44320,6 +45771,10 @@ function flows2(to) {
 function explain2(from, to) {
   return why({}, from, to);
 }
+function declare2(declared, description) {
+  const network = declared ? description ? { description } : {} : null;
+  return setNetwork(network);
+}
 
 // src/migrations/orchestrator.ts
 var path47 = __toESM(require("path"));
@@ -45629,7 +47084,7 @@ function place(path49, bytes) {
     throw e;
   }
 }
-function remove(path49) {
+function remove2(path49) {
   retrying("remove", path49, () => {
     try {
       fs25.unlinkSync(path49);
@@ -46806,6 +48261,12 @@ function recordCrossing(plan6, bound2, member, result) {
   for (const line of crossed.exported) plan6.edits.push({ project: bound2, kind: "export", detail: `export ${line}` });
   for (const line of crossed.imported) plan6.edits.push({ project: bound2, kind: "external", detail: `import: ${line}` });
   for (const line of crossed.consumersDropped) plan6.edits.push({ project: bound2, kind: "reference", detail: `consumers across the boundary to ${member} dropped: ${line}` });
+  for (const line of crossed.entriesDeclared ?? []) plan6.edits.push({ project: member, kind: "reference", detail: `entry declared for the callers left across the boundary \u2014 ${line}` });
+  const topics = crossed.topicsCrossing ?? [];
+  if (topics.length > 0) {
+    plan6.notes.push(`${topics.length} topic(s) now cross the boundary to "${member}"; the family run (\`wairon validate\` at ${label6(bound2)}) pairs them, while "${member}" validated alone reports them:`);
+    for (const line of topics) plan6.notes.push(`  ${line}`);
+  }
 }
 function writeOne3(rehearsal, w) {
   const args = w.args;
@@ -47238,7 +48699,7 @@ function swap(journals) {
 function swapEntry(journal, entry) {
   const target = liveOf(journal.owner, entry.path);
   if (entry.action === "delete") {
-    guarded(journal, `remove ${target}`, () => remove(target));
+    guarded(journal, `remove ${target}`, () => remove2(target));
     guarded(journal, `prune ${path46.dirname(target)}`, () => {
       for (const d of prune2(path46.dirname(target), journal.owner)) if (!journal.dirsRemoved.includes(d)) journal.dirsRemoved.push(d);
     });
@@ -47280,7 +48741,7 @@ function restoreOwner(journal) {
   }
   for (const entry of journal.entries.filter((e) => e.action === "create")) {
     const target = liveOf(journal.owner, entry.path);
-    if (digest2(target) === entry.stagedDigest) attempt(() => remove(target));
+    if (digest2(target) === entry.stagedDigest) attempt(() => remove2(target));
   }
   for (const d of [...journal.dirsCreated].sort((a, b) => b.length - a.length)) attempt(() => prune2(d, path46.dirname(d)));
   for (const entry of journal.entries) {
@@ -47580,8 +49041,8 @@ function relockOf(plan6, changes) {
   const moved = movedOf(plan6);
   const relocated = moved !== null && approvalRecord(moved.from) !== null ? [moved.to] : [];
   if (plan6.request.verb !== "rename") return [...owners.filter((owner) => approvalRecord(owner) !== null), ...relocated];
-  const renamed = plan6.edits.find((e) => e.write?.call === "renameId")?.write?.root;
-  const first = renamed !== void 0 ? path47.resolve(renamed) : void 0;
+  const renamed2 = plan6.edits.find((e) => e.write?.call === "renameId")?.write?.root;
+  const first = renamed2 !== void 0 ? path47.resolve(renamed2) : void 0;
   return [...owners.filter((o) => o === first), ...owners.filter((o) => o !== first)];
 }
 function apply(plan6) {
@@ -47801,11 +49262,27 @@ var externalAdditionOutput = {
   unreachable: import_zod12.z.string().optional().describe("Set when the declaration was written but its producer could not be read: why, and that nothing was pinned."),
   ...staleServerOutput
 };
+var externalRemovalOutput = {
+  alias: import_zod12.z.string(),
+  removed: import_zod12.z.boolean().describe("Whether .wai/project.yaml no longer carries the declaration because this call took it out."),
+  unpinned: import_zod12.z.boolean().describe("Whether the alias's lock entry and pinned snapshot were removed (or would be, on a dry run)."),
+  refusal: import_zod12.z.string().optional().describe("Why nothing was removed, in one sentence."),
+  ...staleServerOutput
+};
+var externalUseChangeOutput = {
+  alias: import_zod12.z.string(),
+  written: import_zod12.z.boolean().describe("Whether .wai/project.yaml now carries the changed `use` (false on a refusal, a dry run and when nothing changed)."),
+  use: import_zod12.z.array(import_zod12.z.string()).describe("The `use` list after the change, in order."),
+  added: import_zod12.z.array(import_zod12.z.string()).describe("The names this change imports that were not imported before."),
+  removed: import_zod12.z.array(import_zod12.z.string()).describe("The names this change stops importing."),
+  refusal: import_zod12.z.string().optional().describe("Why nothing was written, in one sentence."),
+  ...staleServerOutput
+};
 function additionAnswer(request, addition) {
   if (addition.refusal) {
     return { ...structured(addition.refusal, { ...addition }), isError: true };
   }
-  const summary = request.dryRun ? `Dry run: would declare "${addition.alias}" \u2192 ${addition.project ?? addition.alias} as ${JSON.stringify(addition.declaration)}; the producer is checked and the external pinned on the real run. Nothing was written.` : `Declared "${addition.alias}" \u2192 ${addition.project ?? addition.alias} as ${JSON.stringify(addition.declaration)}` + (addition.pin ? `; pin ${addition.pin.outcome}${addition.pin.detail ? ` \u2014 ${addition.pin.detail}` : ""}` : "") + (addition.unreachable ? `. Declared but not pinned: ${addition.unreachable}` : "") + ".";
+  const summary = request.dryRun ? `Dry run: would declare "${addition.alias}" \u2192 ${addition.project ?? addition.alias} as ${JSON.stringify(addition.declaration)}${addition.unreachable ? `; ${addition.unreachable}` : "; the producer was read and agrees"}. Nothing was written.` : `Declared "${addition.alias}" \u2192 ${addition.project ?? addition.alias} as ${JSON.stringify(addition.declaration)}` + (addition.pin ? `; pin ${addition.pin.outcome}${addition.pin.detail ? ` \u2014 ${addition.pin.detail}` : ""}` : "") + (addition.unreachable ? `. Declared but not pinned: ${addition.unreachable}` : "") + ".";
   return structured(summary, { ...addition });
 }
 var flowPartyOutput = import_zod12.z.object({
@@ -47824,7 +49301,9 @@ var networkFlowOutput = import_zod12.z.object({
   crosses: import_zod12.z.array(import_zod12.z.string()),
   via: import_zod12.z.string().optional(),
   evidence: import_zod12.z.array(import_zod12.z.string()),
-  verbs: import_zod12.z.array(import_zod12.z.string()).optional()
+  verbs: import_zod12.z.array(import_zod12.z.string()).optional(),
+  refusedBy: import_zod12.z.array(import_zod12.z.string()).optional().describe("The gate's error findings on this flow (`CODE: message`): the design refuses it, so it is never allowed."),
+  flaggedBy: import_zod12.z.array(import_zod12.z.string()).optional().describe("The gate's warnings and notices on this flow (`CODE: message`): allowed, but marked.")
 });
 var networkFlowsOutput = {
   flows: import_zod12.z.array(networkFlowOutput).describe("One allowed flow per row: who reaches which Portal verb, over which transport and binding, through which networks and gateway, on what evidence."),
@@ -47833,7 +49312,15 @@ var networkFlowsOutput = {
 var flowExplanationOutput = {
   allowed: import_zod12.z.boolean().describe("Whether any flow of the design allows it."),
   flows: import_zod12.z.array(networkFlowOutput).describe("The flows that allow it."),
-  chain: import_zod12.z.array(import_zod12.z.string()).describe("Each step of the justification, one line each; when not allowed, what reaches the callee instead."),
+  chain: import_zod12.z.array(import_zod12.z.string()).describe("Each step of the justification, one line each; when not allowed, why not: refused by the gate, in-process, an unknown party, or what reaches the callee instead."),
+  inProcess: import_zod12.z.boolean().optional().describe("True when the callee takes no network flow at all: it is reached in-process, never over the network."),
+  unknown: import_zod12.z.array(import_zod12.z.string()).optional().describe("The party names the design does not know: a typo, not a refusal."),
+  refusedBy: import_zod12.z.array(import_zod12.z.string()).optional().describe("The gate's error findings on the flows between the pair: the design names them, the gate refuses them."),
+  ...staleServerOutput
+};
+var networkDeclarationOutput = {
+  written: import_zod12.z.boolean().describe("Whether .wai/project.yaml changed: false when it already read that way."),
+  declared: import_zod12.z.boolean().describe("Whether the project now declares a network."),
   ...staleServerOutput
 };
 function flowLine(f) {
@@ -48338,6 +49825,7 @@ var SPEC_WRITE_TOOLS = /* @__PURE__ */ new Set([
   "sdd_rename_component",
   "sdd_rename_method",
   "sdd_rename_type",
+  "sdd_rename_field",
   "sdd_add_component",
   "sdd_define_interface",
   "sdd_set_endpoints",
@@ -48884,6 +50372,27 @@ ${renderChangeReport(report3)}`,
       }
     }
   );
+  reg(
+    server,
+    "sdd_rename_field",
+    {
+      description: "Rename a field of a type and respell every reference to it in the bound tree: a foreign key's `references: <type>.<field>` naming it from any type (the type's own self-references included). The field keeps its place, type and description under the new name, and its old name joins the field's rename trace (previousNames), which the design export shows as `formerly` so a consumer holding the old name can follow the move. Rename traces and prose are never rewritten. Refuses, writing nothing: a type that does not exist (type-missing), one in another project (chained-type), a field the type does not declare (field-missing), a new name that is not an identifier (invalid-name), and a name another field of the type holds (name-taken) or retired (name-retired \u2014 unsetting the holder's previousNames releases it). Returns the type, from and to, and the specs rewritten. The approval reads the type as changed until the next `wairon lock`, as with any edit.",
+      inputSchema: {
+        id: import_zod12.z.string().describe("The type whose field is renamed (qualified by its owning subsystem if needed, `subsystem::id`)"),
+        field: import_zod12.z.string().describe("The field's name as it stands"),
+        newName: import_zod12.z.string().describe("Its new name: an identifier")
+      }
+    },
+    ({ id, field, newName }) => {
+      try {
+        const bare = id.startsWith("::") ? id.slice(2) : id;
+        const resolved = loadTypeSpec(bare) ? bare : id;
+        return json(renameField(resolved, field, newName));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
   reg(
     server,
     "sdd_move_methods",
@@ -48916,7 +50425,7 @@ ${renderChangeReport(report3)}`,
     componentType: import_zod12.z.enum(["Portal", "Orchestrator", "Supervisor", "Actor", "Store", "Index", "Query", "Registry", "Adapter", "Observer", "Repository"]).describe("The building block, or the pattern Repository. Specialist and Gateway are retired and cannot be authored: logic is an Orchestrator with a dependencyClass, a gateway is a Portal with the gateway variant"),
     owns: import_zod12.z.array(import_zod12.z.string()).optional().describe("Member block ids privately owned by this component (patterns only)"),
     dependsOn: import_zod12.z.array(import_zod12.z.string()).optional().describe("IDs of other components this collaborates with (facades or standalone blocks)"),
-    transport: import_zod12.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "JSONRPC", "InProcess", "Custom"]).optional().describe("Portal-only, and expected on every Portal: how callers reach its verbs, one vocabulary with the endpoint discriminator. Network: HTTP, gRPC, GraphQL, MessageBus, Custom. Local: CLI, NamedPipe, IPC, JSONRPC (JSON-RPC over stdio, e.g. a language server or stdio MCP). InProcess: a library (or FFI/DLL with an abi), whose verbs are its contract methods and bind no endpoint. Replaces the retired portalType (HTTP_API is HTTP). OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
+    transport: import_zod12.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "JSONRPC", "InProcess", "Custom"]).optional().describe("Expected on every Portal: how callers reach its verbs, one vocabulary with the endpoint discriminator. Network: HTTP, gRPC, GraphQL, MessageBus, Custom. Local: CLI, NamedPipe, IPC, JSONRPC (JSON-RPC over stdio, e.g. a language server or stdio MCP). InProcess: a library (or FFI/DLL with an abi), whose verbs are its contract methods and bind no endpoint. Replaces the retired portalType (HTTP_API is HTTP). On an Adapter, optional: the transport it calls its target Portal over \u2014 omit it and it is taken from the Portals its dependsOn names when they share one; a stated one that differs from the target's is ADAPTER_TRANSPORT_MISMATCH. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
     abi: import_zod12.z.string().optional().describe(`Portal-only, InProcess only: how a foreign language links this library \u2014 "c" (a C-ABI shared library, DLL or FFI) or "wasm" (a WebAssembly component). Omit for a native API in the project's targetLanguage.`),
     invokedBy: import_zod12.z.object({
       kind: import_zod12.z.enum(["entry"]).describe("entry: callers outside the design reach every verb of this Portal over its transport"),
@@ -48959,6 +50468,13 @@ ${renderChangeReport(report3)}`,
         if (invokedBy?.scope !== void 0 && transport !== void 0 && transportKind(transport) !== "network") {
           return errText(`Component "${id}": an entry scope applies only to a network transport, and "${transport}" is ${transportKind(transport)} \u2014 drop the scope.`);
         }
+        let inferredTransport;
+        if (componentType === "Adapter" && transport === void 0) {
+          const portals = (dependsOn ?? []).map((dep) => loadComponentSpec(dep)).filter((c) => c?.componentType === "Portal" && c.transport !== void 0);
+          const kinds = [...new Set(portals.map((p) => p.transport))];
+          if (kinds.length === 1) inferredTransport = kinds[0];
+        }
+        const statedTransport = transport ?? inferredTransport;
         const restatement = {
           kind: "component",
           spec: {
@@ -48969,7 +50485,7 @@ ${renderChangeReport(report3)}`,
             componentType,
             owns: owns ?? [],
             dependsOn: dependsOn ?? [],
-            ...transport ? { transport } : {},
+            ...statedTransport ? { transport: statedTransport } : {},
             ...abi ? { abi } : {},
             ...invokedBy ? { invokedBy } : {},
             ...basePath ? { basePath } : {},
@@ -48984,8 +50500,9 @@ ${renderChangeReport(report3)}`,
           status
         };
         const receipt = writeSpec(restatement);
+        const inferred = inferredTransport ? ` Its transport, ${inferredTransport}, was taken from the Portal it calls (an Adapter calls its target's verbs over the target's transport).` : "";
         return writeReceipt(
-          `Successfully ${receipt.replacedExisting ? "re-authored" : "added"} L2 Component Spec "${name}" (${id}, ${componentType}).`,
+          `Successfully ${receipt.replacedExisting ? "re-authored" : "added"} L2 Component Spec "${name}" (${id}, ${componentType}).${inferred}`,
           receipt
         );
       } catch (e) {
@@ -49641,6 +51158,58 @@ ${testsBlock}` : ""}`, deletion);
       }
     }
   );
+  reg(
+    server,
+    "sdd_remove_external",
+    {
+      description: "Remove one external of the bound project: its declaration in .wai/project.yaml and its pin (the lock entry and the pinned snapshot) together, so no orphaned pin is left; an orphaned pin alone (a declaration someone deleted by hand) is removed too. Refused in one sentence when the alias is neither declared nor pinned. References to the alias are the validator's to report afterwards. Use it instead of editing .wai/project.yaml by hand. A tree-scoped write.",
+      inputSchema: {
+        alias: import_zod12.z.string().describe("The external to remove"),
+        dryRun: import_zod12.z.boolean().optional().describe("Answer what would be removed, writing nothing")
+      },
+      outputSchema: externalRemovalOutput
+    },
+    ({ alias, dryRun }) => {
+      try {
+        const removal = removeExternal2(alias, dryRun);
+        if (removal.refusal) return { ...structured(removal.refusal, { ...removal }), isError: true };
+        const what = [removal.removed || dryRun ? "its declaration" : "", removal.unpinned ? "its pin (lock entry and snapshot)" : ""].filter(Boolean).join(" and ") || "nothing more";
+        return structured(dryRun ? `Dry run: would remove "${alias}" \u2014 ${what}. Nothing was written.` : `Removed "${alias}": ${what}.`, { ...removal });
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_update_external",
+    {
+      description: "Add and remove `use` imports of one declared external, so this project's specs may name the producer's public names bare \u2014 e.g. so an `implements` of another project's trait may spell the producer's types as the producer does. An added name is checked against what the producer exports to this project (refused naming the closest exported names, or the audience that keeps it out). The pin is untouched. Use it instead of editing .wai/project.yaml by hand. A tree-scoped write.",
+      inputSchema: {
+        alias: import_zod12.z.string().describe("The declared external whose `use` changes"),
+        addUse: import_zod12.z.array(import_zod12.z.string()).optional().describe("Public names to import bare (`*` for all)"),
+        removeUse: import_zod12.z.array(import_zod12.z.string()).optional().describe("Names to stop importing"),
+        dryRun: import_zod12.z.boolean().optional().describe("Answer the resulting list, writing nothing")
+      },
+      outputSchema: externalUseChangeOutput
+    },
+    ({ alias, addUse, removeUse, dryRun }) => {
+      try {
+        const change = updateExternalUse({
+          alias,
+          ...addUse !== void 0 ? { add: addUse } : {},
+          ...removeUse !== void 0 ? { remove: removeUse } : {},
+          ...dryRun ? { dryRun: true } : {}
+        });
+        if (change.refusal) return { ...structured(change.refusal, { ...change }), isError: true };
+        const moved = [change.added.length ? `+ ${change.added.join(", ")}` : "", change.removed.length ? `- ${change.removed.join(", ")}` : ""].filter(Boolean).join("; ") || "no change";
+        const list = change.use.length ? change.use.join(", ") : "(none)";
+        return structured(`${dryRun ? "Dry run: " : ""}${alias}.use ${dryRun ? "would be" : change.written ? "is now" : "is already"} [${list}] (${moved}).`, { ...change });
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
   reg(
     server,
     "sdd_get_network_flows",
@@ -49675,13 +51244,35 @@ ${testsBlock}` : ""}`, deletion);
     ({ from, to }) => {
       try {
         const explanation = explain2(from, to);
-        const head2 = explanation.allowed ? `${from} may reach ${to}:` : `${from} may NOT reach ${to}:`;
+        const head2 = explanation.allowed ? `${from} may reach ${to}:` : explanation.unknown?.length ? `unknown party: ${explanation.unknown.join(", ")}:` : explanation.refusedBy?.length ? `${from} may NOT reach ${to} \u2014 the gate refuses the flow:` : explanation.inProcess ? `${to} is reached in-process \u2014 never a network flow:` : `${from} may NOT reach ${to}:`;
         return structured([head2, ...explanation.chain.map((l) => `  ${l}`)].join("\n"), { ...explanation });
       } catch (e) {
         return errMessage(e);
       }
     }
   );
+  reg(
+    server,
+    "sdd_set_network",
+    {
+      description: "Declare (declared: true, with an optional description) or remove (declared: false) the bound project's `network` in .wai/project.yaml: that this project and every member below it form one isolated network boundary. It changes which rules fire (GATEWAY_BYPASSED, ENTRY_UNPROVEN, ...), so run sdd_validate_tree after it; it is part of the gate identity, so the human re-locks. Use it instead of editing .wai/project.yaml by hand. A project-scoped write.",
+      inputSchema: {
+        declared: import_zod12.z.boolean().describe("true declares the network, false removes the declaration"),
+        description: import_zod12.z.string().optional().describe("What the network encloses, in the project's words (shown on the network diagram); only with declared: true")
+      },
+      outputSchema: networkDeclarationOutput
+    },
+    ({ declared, description }) => {
+      try {
+        if (!declared && description !== void 0) return errText("sdd_set_network: a description goes with declared: true \u2014 removing the declaration takes none.");
+        const written = declare2(declared, description ?? null);
+        const text3 = declared ? written ? `Declared this project's network${description ? ` ("${description}")` : ""}. Run sdd_validate_tree: the network rules now judge the design. The human re-locks once it validates.` : "This project already declares that network: nothing was written." : written ? "Removed this project's network declaration. Run sdd_validate_tree; the human re-locks." : "This project declares no network: nothing was removed.";
+        return structured(text3, { written, declared });
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
   reg(
     server,
     "sdd_get_agent_brief",
@@ -49883,6 +51474,7 @@ function loadProjectConfig3() {
   SurfaceSnapshotSchema,
   SurfaceTypeDefSchema,
   SurfaceTypeExportSchema,
+  SurfaceUnresolvedExportSchema,
   SwitchCaseSchema,
   SystemPublicInterfaceSchema,
   SystemSpecSchema,
@@ -49916,12 +51508,14 @@ function loadProjectConfig3() {
   approvalKeyIn,
   approvalRecord,
   approvalVerdict,
+  approvedStatuses,
   assertContainedProjectPath,
   assertProjectInitialized,
   attachRetiredMounts,
   backendCommand,
   backfillChainedSubprojectConfigs,
   backupBeside,
+  bindDeclaredExternal,
   bodySitesOf,
   buildCanvasDataModel,
   buildProjectGraph,
@@ -49933,6 +51527,7 @@ function loadProjectConfig3() {
   canonicalTypeRef,
   canonicalTypeText,
   captureApprovedSpecs,
+  carriedFactChanges,
   carryRetiredReachForms,
   checkDeclarativePack,
   clearLoaderIssues,
@@ -49944,6 +51539,7 @@ function loadProjectConfig3() {
   composeRuleSequence,
   computeGateStateId,
   computeOwnDesignId,
+  computeOwnDesignIdAsRecorded,
   computeOwnStateId,
   computeStateId,
   computeStateIdAt,
@@ -50047,6 +51643,7 @@ function loadProjectConfig3() {
   injectGuide,
   installPackFromDirectory,
   interfaceCanonicalTypes,
+  interfaceDesignView,
   interfaceGenericParameters,
   internalizeMember,
   isDraftSubsystem,
@@ -50066,6 +51663,7 @@ function loadProjectConfig3() {
   languageOfSourcePath,
   lineEndingFor,
   listDirectChainedSubprojects,
+  listExternalConsumers,
   listExternals,
   listFiles,
   listFilesRecursive,
@@ -50167,6 +51765,7 @@ function loadProjectConfig3() {
   removeSnapshot,
   renameAlias,
   renameComponent,
+  renameField,
   renameId,
   renameMethod,
   renameType,
@@ -50181,6 +51780,7 @@ function loadProjectConfig3() {
   resolveChainingParent,
   resolveDomains,
   resolveExpectedOutputPaths,
+  resolveExternalCandidate,
   resolveExternals,
   resolveImport,
   resolveInstalledPack,
@@ -50209,6 +51809,7 @@ function loadProjectConfig3() {
   setExecutionTier,
   setId,
   setLogLevel,
+  setNetwork,
   setProjectRoot,
   setProjectType,
   settledSpecPaths,
@@ -50222,6 +51823,7 @@ function loadProjectConfig3() {
   stepGraph,
   storedMethodSignature,
   storedTypeMethod,
+  subsystemDesignView,
   syncContextFiles,
   technologyName,
   technologyTokens,
@@ -50235,6 +51837,7 @@ function loadProjectConfig3() {
   typeDialectFor,
   typeGenericParameters,
   typeIsMany,
+  typeMappingFor,
   typeMatchesRef,
   typeNamedRefs,
   typeProblemEnumProposal,