@wairon/cli 5.1.1-dev.11 → 5.1.1-dev.13

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.11";
+    WAIRON_VERSION = "5.1.1-dev.13";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -3554,17 +3554,43 @@ function isExternalNamespaceRef(ctx, ref) {
   if (sep9 === -1) return false;
   return !ctx.subsystemIds.has(ref.slice(0, sep9));
 }
+function isProvidedBy(snapshot, provider) {
+  return snapshot.projectName === provider || snapshot.projectName.split("::").pop() === provider;
+}
+function sameContract(a, b) {
+  return a.component.split("::").pop() === b.component.split("::").pop() && JSON.stringify(a.methods) === JSON.stringify(b.methods) && JSON.stringify(a.dispatch ?? []) === JSON.stringify(b.dispatch ?? []);
+}
 function resolveSurfaceRef(ctx, ref, fromSubsystem) {
-  const local = ref.split("::").filter((seg) => seg && seg !== "super").pop();
-  if (!local) return null;
+  const segments = ref.split("::").filter((seg) => seg && seg !== "super");
+  const local = segments.pop();
+  if (!local) return { kind: "unresolved" };
+  const provider = segments.pop();
   const mountPools = fromSubsystem ? enclosingMounts(ctx, fromSubsystem).reverse().map((ns) => ctx.mountSurfaceSnapshots.find((m) => m.namespace === ns)?.snapshots ?? []) : [];
   for (const pool of [...mountPools, ctx.surfaceSnapshots]) {
+    const candidates = [];
     for (const snapshot of pool) {
+      if (provider !== void 0 && !isProvidedBy(snapshot, provider)) continue;
       const entry = snapshot.interfaces.find((e) => e.component === local || e.id === local);
-      if (entry) return { snapshot, entry };
+      if (entry) candidates.push({ snapshot, entry });
+    }
+    if (candidates.length === 0) continue;
+    const [first] = candidates;
+    if (candidates.every((c) => sameContract(c.entry, first.entry))) {
+      return { kind: "resolved", ...first };
     }
+    return { kind: "ambiguous", providers: [...new Set(candidates.map((c) => c.snapshot.projectName))] };
   }
-  return null;
+  return { kind: "unresolved" };
+}
+function reportAmbiguousSurfaceRef(ctx, subject, ref, providers, specId, isDraftContext) {
+  const local = ref.split("::").filter((seg) => seg && seg !== "super").pop() ?? ref;
+  ctx.addIssue(
+    "error",
+    "SURFACE_REF_AMBIGUOUS",
+    `${subject} cross-tree component "${ref}", which the surface snapshots of ${providers.map((p) => `"${p}"`).join(", ")} expose with different contracts \u2014 the reference matches more than one declared contract, so none of them can judge it. Name the provider it means (super::<provider>::${local}), or remove the snapshot that no longer applies.`,
+    specId,
+    isDraftContext
+  );
 }
 function enclosingMounts(ctx, subsystemId) {
   const mounts = [];
@@ -3655,6 +3681,7 @@ var init_contracts = __esm({
         { code: "INVALID_TARGET_COMPONENT_REFERENCE", defaultSeverity: "error", summary: "Call/register step targets a non-existent component" },
         { code: "CROSS_TREE_REF_UNRESOLVED", defaultSeverity: "warning", summary: "Cross-tree reference (super::/:: form) with no surface snapshot covering it \u2014 only the parent project can verify it" },
         { code: "SURFACE_REF_NOT_EXPOSED", defaultSeverity: "error", summary: "Cross-tree reference resolves to a surface snapshot that does not expose the called method/capability" },
+        { code: "SURFACE_REF_AMBIGUOUS", defaultSeverity: "error", summary: "Cross-tree call/dispatch/register target matched by surface snapshots of several providers with different contracts" },
         { code: "UNDECLARED_DEPENDENCY_CALL", defaultSeverity: "error", summary: "Call step targets a component the caller does not depend on or own" },
         { code: "INVALID_TARGET_METHOD_REFERENCE", defaultSeverity: "error", summary: "Call step targets a method not on any target interface" },
         { code: "NARRATIVE_SEMANTIC_UNBACKED", defaultSeverity: "warning", summary: "Narrative asserts a guarantee the called contract does not declare" }
@@ -3709,7 +3736,18 @@ var init_contracts = __esm({
                 if (!dispatchTarget) {
                   if (isCrossTreeForm || isCollapsedForm) {
                     const resolved = resolveSurfaceRef(ctx, step.targetComponent, fromSubsystem);
-                    if (resolved) {
+                    if (resolved.kind === "ambiguous") {
+                      reportAmbiguousSurfaceRef(
+                        ctx,
+                        `Method "${implMethod.name}" in implementation "${impl.id}" dispatches (step ${step.stepNumber}) through`,
+                        step.targetComponent,
+                        resolved.providers,
+                        impl.id,
+                        isDraftCtx
+                      );
+                      continue;
+                    }
+                    if (resolved.kind === "resolved") {
                       if (step.capability && !(resolved.entry.dispatch ?? []).some((b) => b.capability === step.capability)) {
                         ctx.addIssue(
                           "error",
@@ -3769,7 +3807,18 @@ var init_contracts = __esm({
               if (!targetComp) {
                 if (isCrossTreeForm || isCollapsedForm) {
                   const resolved = resolveSurfaceRef(ctx, step.targetComponent, fromSubsystem);
-                  if (resolved) {
+                  if (resolved.kind === "ambiguous") {
+                    reportAmbiguousSurfaceRef(
+                      ctx,
+                      `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} "${step.targetMethod}" (step ${step.stepNumber}) on`,
+                      step.targetComponent,
+                      resolved.providers,
+                      impl.id,
+                      isDraftCtx
+                    );
+                    continue;
+                  }
+                  if (resolved.kind === "resolved") {
                     const surfaceMethod = resolved.entry.methods.find((m) => m.name === step.targetMethod);
                     if (!surfaceMethod) {
                       ctx.addIssue(
@@ -5284,6 +5333,7 @@ var init_stereotype_deps = __esm({
       codes: [
         { code: "INVALID_DEPENDENCY_REFERENCE", defaultSeverity: "error", summary: "dependsOn names a non-existent component" },
         { code: "CROSS_TREE_REF_UNRESOLVED", defaultSeverity: "warning", summary: "Cross-tree dependsOn (super::/:: form) with no surface snapshot covering it" },
+        { code: "SURFACE_REF_AMBIGUOUS", defaultSeverity: "error", summary: "Cross-tree dependsOn matched by surface snapshots of several providers with different contracts" },
         { code: "CROSS_SUBSYSTEM_NON_ADAPTER", defaultSeverity: "error", summary: "Non-Adapter component crossing a subsystem boundary" },
         { code: "CROSS_SUBSYSTEM_PRIVATE_ACCESS", defaultSeverity: "error", summary: "Cross-subsystem dependency on an unpublished component" },
         { code: "CROSS_SUBSYSTEM_TARGET_NON_PORTAL", defaultSeverity: "error", summary: "Cross-subsystem hop entering through a non-Portal" },
@@ -5307,7 +5357,11 @@ var init_stereotype_deps = __esm({
               const external = isExternalNamespaceRef(ctx, depId);
               if (external || isCollapsedCrossTreeRef(ctx, depId, comp.subsystem)) {
                 const resolved = resolveSurfaceRef(ctx, depId, comp.subsystem);
-                if (resolved) {
+                if (resolved.kind === "ambiguous") {
+                  reportAmbiguousSurfaceRef(ctx, `Component "${comp.id}" depends on`, depId, resolved.providers, comp.id, isDraftCtx);
+                  continue;
+                }
+                if (resolved.kind === "resolved") {
                   if (comp.componentType !== "Adapter") {
                     ctx.addIssue(
                       "error",
@@ -5399,12 +5453,12 @@ var init_stereotype_deps = __esm({
               }
             }
             if (comp.componentType === "Specialist") {
-              const forbiddenTypes = ["Portal", "Observer", "Orchestrator", "Store", "Supervisor"];
+              const forbiddenTypes = ["Portal", "Observer", "Orchestrator", "Store", "Registry", "Supervisor", "Actor"];
               if (forbiddenTypes.includes(depComp.componentType)) {
                 ctx.addIssue(
                   "error",
                   "ARCHITECTURE_VIOLATION_SPECIALIST_DEP",
-                  `Architectural violation: Specialist component "${comp.id}" cannot depend on "${depComp.componentType}" component "${depComp.id}". Specialists are narrow capabilities \u2014 they may use Repositories, Indexes, and Adapters, but not Orchestrators, Supervisors, Stores, Portals, or Observers.` + (depComp.componentType === "Store" ? storeResolutionHint(comp.componentType, depComp.id) : ""),
+                  `Architectural violation: Specialist component "${comp.id}" cannot depend on "${depComp.componentType}" component "${depComp.id}". Specialists are pure capabilities \u2014 they may use Repository facades, Indexes, and Adapters, but never workflow/runtime blocks (Orchestrators, Supervisors, Actors) and never persistence directly (Stores, Registries \u2014 all storage, even in-memory, is reached through a Repository facade), nor Portals or Observers.` + (depComp.componentType === "Store" ? storeResolutionHint(comp.componentType, depComp.id) : ""),
                   comp.id,
                   isDraftCtx || ctx.isComponentDraft(depComp.id)
                 );
@@ -8676,7 +8730,7 @@ function buildRuleContext(opts) {
   for (const i of interfaces) collectAllows(i.id, i.lint);
   for (const im of implementations) collectAllows(im.id, im.lint);
   for (const t of types) collectAllows(t.id, t.lint);
-  const knownIssueCodes = /* @__PURE__ */ new Set([
+  const knownIssueCodes2 = /* @__PURE__ */ new Set([
     ...[...SDD_RULES, ...extensions.rules].flatMap((r) => r.codes.map((c) => c.code)),
     // Declarative assertions bring their own namespaced codes — lint.allow
     // and severity overrides treat them exactly like builtins.
@@ -8739,7 +8793,7 @@ function buildRuleContext(opts) {
     mountSurfaceSnapshots: opts.mountSurfaceSnapshots ?? [],
     codeModel: opts.codeModel ?? emptyCodeModel(),
     lintAllows,
-    knownIssueCodes,
+    knownIssueCodes: knownIssueCodes2,
     addIssue
   };
 }
@@ -9009,8 +9063,8 @@ function doctrineIdentity(doctrine, gate) {
     )
   };
 }
-function hashGateState(doctrine, gate = {}) {
-  const payload = { tree: loadTree(), doctrine: doctrineIdentity(doctrine, gate) };
+function hashGateState(doctrine, inputs, gate = {}) {
+  const payload = { tree: loadTree(), doctrine: doctrineIdentity(doctrine, gate), inputs: [...inputs].sort() };
   const digest2 = crypto2.createHash("sha256").update(canonicalize(payload)).digest("hex");
   return { algorithm: GATE_ALGORITHM, digest: digest2 };
 }
@@ -9041,7 +9095,7 @@ var init_statehash = __esm({
     init_specs2();
     init_rules();
     CONTENT_ALGORITHM = "sha256";
-    GATE_ALGORITHM = "sha256+doctrine";
+    GATE_ALGORITHM = "sha256+doctrine+inputs";
   }
 });
 
@@ -14015,6 +14069,9 @@ var MODEL = __MODEL_JSON__;
 function addRule(rule) {
   ruleSet.push(rule);
 }
+function listRules() {
+  return ruleSet;
+}
 function registerBuiltinRules() {
   ruleSet = [];
   for (const rule of SDD_RULES) addRule(rule);
@@ -14029,6 +14086,9 @@ function ruleSequence() {
 function specScopedRules() {
   return ruleSequence().filter((r) => r.scope === "spec");
 }
+function knownIssueCodes() {
+  return listRules().flatMap((r) => r.codes);
+}
 var ruleSet;
 var init_repository = __esm({
   "src/core/rules/repository.ts"() {
@@ -14680,15 +14740,18 @@ function importSurface(sourcePath, origin) {
   saveSnapshot(snapshot);
   return snapshot;
 }
-function pinFamilySurfaces() {
-  const parent = resolveChainingParent();
-  if (!parent) return null;
-  const childRoot = getProjectRoot();
-  const projected = runWithProjectRoot(parent.parentRoot, () => {
+function projectFamilySurfaces(parent) {
+  return runWithProjectRoot(parent.parentRoot, () => {
     invalidateSpecCache();
     const siblings = loadSubsystemSpecs().filter((s) => !s.id.includes("::") && s.id !== parent.subsystemId);
     return [projectChildSurface(), ...siblings.map((s) => projectSubsystemSurface(s.id))];
   });
+}
+function pinFamilySurfaces() {
+  const parent = resolveChainingParent();
+  if (!parent) return null;
+  const childRoot = getProjectRoot();
+  const projected = projectFamilySurfaces(parent);
   const before = new Map(listSnapshots(childRoot).map((s) => [s.projectName, surfaceContentKey(s)]));
   const changed = [];
   for (const snapshot of projected) {
@@ -14699,17 +14762,21 @@ function pinFamilySurfaces() {
   }
   return changed;
 }
-function computeParentStateId(parentRoot) {
-  return computeStateIdAt(parentRoot);
+function projectedFamilyContent(parent) {
+  try {
+    return new Map(projectFamilySurfaces(parent).map((s) => [s.projectName, surfaceContentKey(s)]));
+  } catch {
+    return null;
+  }
 }
 function listExternalInterfaces() {
   const snapshots = listSnapshots();
   const chainingParent = resolveChainingParent();
-  const parentStateId = chainingParent ? computeParentStateId(chainingParent.parentRoot) : null;
+  const projected = chainingParent ? projectedFamilyContent(chainingParent) : null;
   return snapshots.map((snapshot) => {
     const generated = snapshot.origin === "generated";
     const sourceKind = !generated ? "foreign" : snapshot.projectName.includes("::") ? "sibling" : "parent";
-    const freshness = generated && parentStateId ? snapshot.stateId === parentStateId ? "fresh" : "stale" : "unverifiable";
+    const freshness = generated && projected ? projected.get(snapshot.projectName) === surfaceContentKey(snapshot) ? "fresh" : "stale" : "unverifiable";
     return {
       projectName: snapshot.projectName,
       origin: snapshot.origin,
@@ -14848,7 +14915,7 @@ var init_approval = __esm({
 // src/core/validation.ts
 var validation_exports = {};
 __export(validation_exports, {
-  listRules: () => listRules,
+  listRules: () => listRules2,
   validateAsComplete: () => validateAsComplete,
   validateProjectConfig: () => validateProjectConfig,
   validateRegistry: () => validateRegistry,
@@ -14861,6 +14928,32 @@ function projectPackSelections() {
     return [];
   }
 }
+function issueKey(issue2) {
+  return `${issue2.code}|${issue2.specId ?? ""}`;
+}
+function worstByKey(issues) {
+  const worst = /* @__PURE__ */ new Map();
+  for (const issue2 of issues) {
+    const key = issueKey(issue2);
+    const seen = worst.get(key);
+    if (!seen || SEVERITY_RANK[issue2.severity] > SEVERITY_RANK[seen]) worst.set(key, issue2.severity);
+  }
+  return worst;
+}
+function stricterSeverities(parent, child) {
+  const fromParent = parent?.sddRuleSeverity ?? {};
+  const fromChild = child?.sddRuleSeverity ?? {};
+  const codes = /* @__PURE__ */ new Set([...Object.keys(fromParent), ...Object.keys(fromChild)]);
+  if (codes.size === 0) return parent ?? child;
+  const defaults = new Map(knownIssueCodes().map((rc) => [rc.code, rc.defaultSeverity]));
+  const merged = {};
+  for (const code of codes) {
+    const p = fromParent[code] ?? defaults.get(code);
+    const c = fromChild[code] ?? defaults.get(code);
+    merged[code] = p === void 0 || c === void 0 ? p ?? c : SEVERITY_RANK[p] >= SEVERITY_RANK[c] ? p : c;
+  }
+  return { ...parent ?? child, sddRuleSeverity: merged };
+}
 function issue(severity, code, message, agentId, specId) {
   return { severity, code, message, agentId, specId };
 }
@@ -14942,7 +15035,7 @@ function validateProjectConfig(config) {
     issues
   };
 }
-function listRules() {
+function listRules2() {
   const extensions = loadProjectExtensions();
   registerBuiltinRules();
   registerPackRules(extensions.rules);
@@ -15042,21 +15135,22 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
     for (const rule of ruleSequence()) {
       rule.check(ctx);
     }
-    const uncovered = (i) => SUBPROJECT_REFERENCE_CODES.has(i.code) && !i.surfaceResolved;
-    const chainingParent = crossTree !== "off" && issues.some(uncovered) ? findChainingParent(getProjectRoot()) : null;
-    const resolution = chainingParent ? resolveThroughParent(getProjectRoot(), treatAllAsComplete) : null;
+    const unresolved = (i) => RESOLUTION_FAILURE_CODES.has(i.code) && !i.surfaceResolved;
+    const chainingParent = crossTree !== "off" && issues.some(unresolved) ? resolveChainingParent() : null;
+    const resolution = chainingParent ? resolveThroughParent(getProjectRoot(), treatAllAsComplete, rules) : null;
     if (resolution) {
-      const parentSeverity = /* @__PURE__ */ new Map();
-      for (const i of resolution.issues) {
-        const key = `${i.code}|${i.specId ?? ""}`;
-        if (i.severity === "error" || !parentSeverity.has(key)) parentSeverity.set(key, i.severity);
-      }
-      const rejudged = (i) => {
-        const judged = parentSeverity.get(`${i.code}|${i.specId ?? ""}`);
-        return judged === "error" || judged === "warning" && i.severity === "warning";
-      };
-      const kept = issues.filter((i) => !uncovered(i) && !(i.surfaceResolved && rejudged(i)));
-      const merged = dedupeIssues([...kept, ...resolution.issues]);
+      const judgedByParent = worstByKey(resolution.issues);
+      const kept = issues.filter((i) => {
+        const judged = judgedByParent.get(issueKey(i));
+        if (judged !== void 0) return SEVERITY_RANK[judged] < SEVERITY_RANK[i.severity];
+        return !unresolved(i);
+      });
+      const keptByChild = worstByKey(kept);
+      const added = resolution.issues.filter((i) => {
+        const own = keptByChild.get(issueKey(i));
+        return own === void 0 || SEVERITY_RANK[own] <= SEVERITY_RANK[i.severity];
+      });
+      const merged = dedupeIssues([...kept, ...added]);
       return {
         valid: merged.every((i) => i.severity !== "error"),
         issues: merged,
@@ -15073,14 +15167,14 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
     });
   }
 }
-function resolveThroughParent(boundRoot, treatAllAsComplete) {
+function resolveThroughParent(boundRoot, treatAllAsComplete, childRules) {
   const reach = getRequestParentReach();
   if (reach && !reach.parentReach) return null;
   const ceiling = reach?.topRoot ? path18.resolve(reach.topRoot) : void 0;
   const chain = [];
   let top = path18.resolve(boundRoot);
   while (top !== ceiling) {
-    const hop = findChainingParent(top);
+    const hop = findChainingParent(top, ceiling);
     if (!hop) break;
     const next = path18.resolve(hop.parentRoot);
     if (ceiling && !isWithinOrEqual(ceiling, next)) break;
@@ -15091,10 +15185,10 @@ function resolveThroughParent(boundRoot, treatAllAsComplete) {
   const scope = chain.join("::");
   const inner = runWithProjectRoot(top, () => {
     invalidateSpecCache();
-    let governing = {};
+    let governing = { rules: stricterSeverities(void 0, childRules) };
     try {
       const config = loadProjectConfig();
-      governing = { rules: config.rules, projectType: config.projectType };
+      governing = { rules: stricterSeverities(config.rules, childRules), projectType: config.projectType };
     } catch {
     }
     return validateSddTree({
@@ -15168,7 +15262,7 @@ function settledStatusBearing(loaded) {
 function validateAsComplete(options) {
   return validateSddTree({ ...options ?? {}, treatAllAsComplete: true });
 }
-var path18, SUBPROJECT_REFERENCE_CODES;
+var path18, RESOLUTION_FAILURE_CODES, SEVERITY_RANK;
 var init_validation = __esm({
   "src/core/validation.ts"() {
     "use strict";
@@ -15184,16 +15278,15 @@ var init_validation = __esm({
     init_fs();
     path18 = __toESM(require("path"));
     init_approval();
-    SUBPROJECT_REFERENCE_CODES = /* @__PURE__ */ new Set([
+    RESOLUTION_FAILURE_CODES = /* @__PURE__ */ new Set([
       "UNDEFINED_TYPE_REFERENCE",
       "INVALID_DEPENDENCY_REFERENCE",
       "INVALID_TARGET_COMPONENT_REFERENCE",
       "INVALID_SUBSYSTEM_REFERENCE",
-      "UNDECLARED_DEPENDENCY_CALL",
       "INVALID_TRUSTED_LINK",
-      "CROSS_SUBSYSTEM_NON_ADAPTER",
       "CROSS_TREE_REF_UNRESOLVED"
     ]);
+    SEVERITY_RANK = { off: 0, warning: 1, error: 2 };
   }
 });
 
@@ -15756,6 +15849,7 @@ __export(specs_exports, {
   getSubprojectPrefix: () => getSubprojectPrefix,
   getSubsystemPath: () => getSubsystemPath,
   getTypePath: () => getTypePath,
+  inspectChainedRoots: () => inspectChainedRoots,
   invalidateSpecCache: () => invalidateSpecCache,
   listChainedRoots: () => listChainedRoots,
   loadComponentSpec: () => loadComponentSpec,
@@ -15773,6 +15867,7 @@ __export(specs_exports, {
   loadTypeSpecs: () => loadTypeSpecs,
   normalizeComponentLayout: () => normalizeComponentLayout,
   readLockState: () => readLockState,
+  rebaseReference: () => rebaseReference,
   resolveChainingParent: () => resolveChainingParent,
   resolveSubprojectForNamespace: () => resolveSubprojectForNamespace,
   restoreSpecFiles: () => restoreSpecFiles,
@@ -15828,6 +15923,20 @@ function qualifyId(id, prefix, rootSubsystems) {
   }
   return prefix ? `${prefix}::${id}` : id;
 }
+function qualifyDeclaredId(id, prefix, mountRealization = false) {
+  if (!id || !prefix) return id;
+  if (id.startsWith("::") || id.startsWith("super::")) {
+    return qualifyId(id, prefix, NO_ROOT_SUBSYSTEMS);
+  }
+  if (mountRealization && id === prefix.split("::").pop()) {
+    return prefix;
+  }
+  return `${prefix}::${id}`;
+}
+function qualifySubsystemRef(id, prefix, rootSubsystems) {
+  if (prefix && !id.includes("::") && id === prefix.split("::").pop()) return prefix;
+  return qualifyId(id, prefix, rootSubsystems);
+}
 function splitNamespace(qualifiedId2) {
   if (!qualifiedId2.includes("::")) {
     return { prefix: "", localId: qualifiedId2 };
@@ -15858,33 +15967,75 @@ function relativizeId(id, prefix) {
   if (common === idParts.length) common--;
   return `${"super::".repeat(prefixParts.length - common)}${idParts.slice(common).join("::")}`;
 }
+function rebaseReference(ref, mount, direction, isMoved = () => false) {
+  if (!ref || ref.startsWith("::")) return ref;
+  const segments = ref.split("::");
+  let hops = 0;
+  while (segments[hops] === "super") hops++;
+  if (hops === segments.length) return ref;
+  const outer = Array.from({ length: hops + 1 }, (_, i) => `<n${i}>`).join("::");
+  const inner = `${outer}::${mount}`;
+  const [from, to] = direction === "into" ? [outer, inner] : [inner, outer];
+  const target = qualifyId(ref, from, NO_ROOT_SUBSYSTEMS);
+  const left = relativizeId(target, from);
+  const travels = !left.startsWith("super::") && (direction === "outOf" || isMoved(left));
+  return relativizeId(travels ? qualifyId(left, to, NO_ROOT_SUBSYSTEMS) : target, to);
+}
 function isWithin(dir, file) {
   const d = path19.resolve(dir);
   const f = path19.resolve(file);
   return f === d || f.startsWith(d + path19.sep);
 }
+function canonicalPath(target) {
+  let existing = path19.resolve(target);
+  const rest = [];
+  for (; ; ) {
+    try {
+      fs13.lstatSync(existing);
+      break;
+    } catch {
+      const up = path19.dirname(existing);
+      if (up === existing) return path19.resolve(target);
+      rest.unshift(path19.basename(existing));
+      existing = up;
+    }
+  }
+  try {
+    return path19.join(fs13.realpathSync.native(existing), ...rest);
+  } catch {
+    return null;
+  }
+}
+function chainDirKey(dir) {
+  return canonicalPath(dir) ?? path19.resolve(dir);
+}
 function projectPathEscapesRoot(projectRoot2, projectPath, resolvedChildDir) {
-  return path19.isAbsolute(projectPath) || !isWithin(projectRoot2, resolvedChildDir);
+  if (path19.isAbsolute(projectPath) || !isWithin(projectRoot2, resolvedChildDir)) return true;
+  const root = canonicalPath(projectRoot2);
+  const child = canonicalPath(resolvedChildDir);
+  return root === null || child === null || !isWithin(root, child);
 }
 function assertContainedProjectPath(projectRoot2, projectPath) {
   const root = path19.resolve(projectRoot2);
   const resolved = path19.resolve(root, projectPath);
   if (projectPathEscapesRoot(root, projectPath, resolved)) {
     throw new Error(
-      `projectPath "${projectPath}" must resolve within the project root "${root}", but resolves to "${resolved}"; absolute paths and ../-escaping paths are rejected so a chained subproject is always contained by its parent.`
+      `projectPath "${projectPath}" must resolve within the project root "${root}", but resolves to "${resolved}"; absolute, ../-escaping and link-escaping paths are rejected so a chained subproject is always contained by its parent.`
     );
   }
   return resolved;
 }
-function findChainingParent(childRoot) {
+function findChainingParent(childRoot, ceiling) {
   let childResolved;
   try {
     childResolved = path19.resolve(childRoot);
   } catch {
     return null;
   }
+  const bound = ceiling ? path19.resolve(ceiling) : void 0;
   let dir = path19.dirname(childResolved);
   for (let hops = 0; hops < 32; hops++) {
+    if (bound && !isWithin(bound, dir)) break;
     const specsDir = aiPathsAt(dir).specsDir();
     if (pathExists(specsDir)) {
       for (const file of listFilesRecursive(specsDir, ".yaml")) {
@@ -15898,7 +16049,8 @@ function findChainingParent(childRoot) {
           const projectPath = raw.projectPath;
           if (typeof projectPath === "string" && projectPath.trim() !== "") {
             try {
-              if (path19.resolve(dir, projectPath) === childResolved) {
+              const mountDir = path19.resolve(dir, projectPath);
+              if (mountDir === childResolved && !projectPathEscapesRoot(dir, projectPath, mountDir)) {
                 const id = raw.id;
                 return { parentRoot: dir, subsystemId: typeof id === "string" ? id : "?" };
               }
@@ -15914,12 +16066,11 @@ function findChainingParent(childRoot) {
   }
   return null;
 }
-function listChainedRoots(rootDir = getProjectRoot()) {
+function inspectChainedRoots(rootDir = getProjectRoot()) {
   const root = path19.resolve(rootDir);
-  const found = [];
-  const visited = /* @__PURE__ */ new Set([root]);
-  const walk = (projectDir, depth) => {
-    if (depth > 32) return;
+  const inspection = { roots: [], skipped: [] };
+  const listed = /* @__PURE__ */ new Set();
+  const walk = (projectDir, prefix, ancestors, depth) => {
     const specsDir = aiPathsAt(projectDir).specsDir();
     if (!pathExists(specsDir)) return;
     for (const file of listFilesRecursive(specsDir, ".yaml")) {
@@ -15930,24 +16081,37 @@ function listChainedRoots(rootDir = getProjectRoot()) {
         continue;
       }
       if (!raw || typeof raw !== "object" || !("parentSystem" in raw)) continue;
-      const projectPath = raw.projectPath;
+      const { id, projectPath } = raw;
       if (typeof projectPath !== "string" || projectPath.trim() === "") continue;
+      const localId = typeof id === "string" ? id : "?";
       let childDir;
       try {
         childDir = path19.resolve(projectDir, projectPath);
       } catch {
         continue;
       }
-      if (projectPathEscapesRoot(root, projectPath, childDir)) continue;
-      if (visited.has(childDir)) continue;
-      if (!fs13.existsSync(childDir)) continue;
-      visited.add(childDir);
-      found.push(path19.relative(root, childDir).split(path19.sep).join("/"));
-      walk(childDir, depth + 1);
+      let reason;
+      if (projectPathEscapesRoot(projectDir, projectPath, childDir)) reason = "escapes";
+      else if (ancestors.has(chainDirKey(childDir))) reason = "cyclic";
+      else if (!fs13.existsSync(childDir)) reason = "missing";
+      else if (depth >= 32) reason = "too-deep";
+      if (reason) {
+        const mount = prefix ? qualifyDeclaredId(localId, prefix, true) : localId;
+        inspection.skipped.push({ mount, projectPath, reason });
+        continue;
+      }
+      const key = chainDirKey(childDir);
+      if (listed.has(key)) continue;
+      listed.add(key);
+      inspection.roots.push(path19.relative(root, childDir).split(path19.sep).join("/"));
+      walk(childDir, prefix ? `${prefix}::${localId}` : localId, /* @__PURE__ */ new Set([...ancestors, key]), depth + 1);
     }
   };
-  walk(root, 0);
-  return found;
+  walk(root, "", /* @__PURE__ */ new Set([chainDirKey(root)]), 0);
+  return inspection;
+}
+function listChainedRoots(rootDir = getProjectRoot()) {
+  return inspectChainedRoots(rootDir).roots;
 }
 function mergeMountRealizations(subs) {
   const result = [];
@@ -16228,7 +16392,26 @@ function buildProjectGraph(level) {
   return buildGraphModel(level);
 }
 function resolveChainingParent() {
-  return findChainingParent(getProjectRoot());
+  const reach = getRequestParentReach();
+  if (reach && !reach.parentReach) return null;
+  return findChainingParent(getProjectRoot(), reach?.topRoot);
+}
+function snapshotInputKey(snapshot) {
+  const { stateId, generatedAt, origin, ...content } = snapshot;
+  return canonicalize(content);
+}
+function consumedSurfaceInputsAt(rootDir) {
+  const dir = path19.join(rootDir, ".wai", "surfaces");
+  if (!pathExists(dir)) return [];
+  const keys = [];
+  for (const file of fs13.readdirSync(dir)) {
+    if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
+    try {
+      keys.push(snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path19.join(dir, file)))));
+    } catch {
+    }
+  }
+  return keys;
 }
 function computeGateStateId() {
   let gate = {};
@@ -16237,7 +16420,10 @@ function computeGateStateId() {
     gate = { projectType: config.projectType, rules: config.rules };
   } catch {
   }
-  return hashGateState(loadProjectExtensions(), gate);
+  const root = getProjectRoot();
+  const roots = [root, ...listChainedRoots(root).map((rel2) => path19.join(root, rel2))];
+  const inputs = roots.flatMap(consumedSurfaceInputsAt);
+  return hashGateState(loadProjectExtensions(), inputs, gate);
 }
 function readLockState() {
   const record2 = readLockRecord();
@@ -16293,7 +16479,7 @@ function findLegacySpecFiles() {
 function updateSpec(kind, id, delta, hooks) {
   return current().updateSpec(kind, id, delta, hooks);
 }
-var fs13, path19, SIGNATURE_TTL_MS, SpecWorkspace, workspaces;
+var fs13, path19, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, SpecWorkspace, workspaces;
 var init_specs2 = __esm({
   "src/core/specs.ts"() {
     "use strict";
@@ -16308,6 +16494,7 @@ var init_specs2 = __esm({
     init_models();
     init_narrative_labels();
     init_diagram();
+    NO_ROOT_SUBSYSTEMS = /* @__PURE__ */ new Set();
     SIGNATURE_TTL_MS = 2e3;
     SpecWorkspace = class {
       constructor(rootDir) {
@@ -16346,7 +16533,7 @@ var init_specs2 = __esm({
         this.rootSubsystems.clear();
         this.cachedRecursive = recursive;
         this.scanVisitedSpecDirs = [];
-        const visited = /* @__PURE__ */ new Set([path19.resolve(this.rootDir)]);
+        const visited = /* @__PURE__ */ new Set([chainDirKey(this.rootDir)]);
         const maxDepth = typeof recursive === "number" ? recursive : recursive ? Infinity : 0;
         this.cachedIndex = this.scanSpecsForProject(this.rootDir, "", visited, maxDepth, 0);
         this.cachedSpecDirs = this.scanVisitedSpecDirs;
@@ -16457,7 +16644,7 @@ var init_specs2 = __esm({
           }
         }
         index.subsystems = index.subsystems.map((sub) => {
-          const qualifiedSubId = namespacePrefix ? qualifyId(sub.id, namespacePrefix, this.rootSubsystems) : sub.id;
+          const qualifiedSubId = namespacePrefix ? qualifyDeclaredId(sub.id, namespacePrefix, true) : sub.id;
           const componentPrefix = sub.projectPath ? qualifiedSubId : namespacePrefix;
           return {
             ...sub,
@@ -16476,14 +16663,14 @@ var init_specs2 = __esm({
         const originalSubsystemPaths = index.paths.subsystem;
         index.paths.subsystem = {};
         for (const [k, v] of Object.entries(originalSubsystemPaths)) {
-          const qualifiedK = namespacePrefix ? qualifyId(k, namespacePrefix, this.rootSubsystems) : k;
+          const qualifiedK = namespacePrefix ? qualifyDeclaredId(k, namespacePrefix, true) : k;
           index.paths.subsystem[qualifiedK] = v;
         }
         if (namespacePrefix) {
           index.components = index.components.map((comp) => ({
             ...comp,
-            id: qualifyId(comp.id, namespacePrefix, this.rootSubsystems),
-            subsystem: qualifyId(comp.subsystem, namespacePrefix, this.rootSubsystems),
+            id: qualifyDeclaredId(comp.id, namespacePrefix),
+            subsystem: qualifySubsystemRef(comp.subsystem, namespacePrefix, this.rootSubsystems),
             owns: comp.owns.map((o) => qualifyId(o, namespacePrefix, this.rootSubsystems)),
             dependsOn: comp.dependsOn.map((d) => qualifyId(d, namespacePrefix, this.rootSubsystems)),
             dispatch: comp.dispatch?.map((b) => ({
@@ -16493,12 +16680,12 @@ var init_specs2 = __esm({
           }));
           index.interfaces = index.interfaces.map((intf) => ({
             ...intf,
-            id: qualifyId(intf.id, namespacePrefix, this.rootSubsystems),
+            id: qualifyDeclaredId(intf.id, namespacePrefix),
             component: qualifyId(intf.component, namespacePrefix, this.rootSubsystems)
           }));
           index.implementations = index.implementations.map((impl) => ({
             ...impl,
-            id: qualifyId(impl.id, namespacePrefix, this.rootSubsystems),
+            id: qualifyDeclaredId(impl.id, namespacePrefix),
             contract: qualifyId(impl.contract, namespacePrefix, this.rootSubsystems),
             methods: impl.methods.map((m) => ({
               ...m,
@@ -16510,13 +16697,13 @@ var init_specs2 = __esm({
           }));
           index.types = index.types.map((t) => ({
             ...t,
-            id: qualifyId(t.id, namespacePrefix, this.rootSubsystems),
-            subsystem: t.subsystem ? qualifyId(t.subsystem, namespacePrefix, this.rootSubsystems) : void 0,
+            id: qualifyDeclaredId(t.id, namespacePrefix),
+            subsystem: t.subsystem ? qualifySubsystemRef(t.subsystem, namespacePrefix, this.rootSubsystems) : void 0,
             group: t.group ? qualifyId(t.group, namespacePrefix, this.rootSubsystems) : void 0
           }));
           index.groups = index.groups.map((g) => ({
             ...g,
-            id: qualifyId(g.id, namespacePrefix, this.rootSubsystems)
+            id: qualifyDeclaredId(g.id, namespacePrefix)
           }));
           const originalPaths = index.paths;
           index.paths = {
@@ -16528,39 +16715,40 @@ var init_specs2 = __esm({
             group: {}
           };
           for (const [k, v] of Object.entries(originalPaths.component)) {
-            index.paths.component[qualifyId(k, namespacePrefix, this.rootSubsystems)] = v;
+            index.paths.component[qualifyDeclaredId(k, namespacePrefix)] = v;
           }
           for (const [k, v] of Object.entries(originalPaths.interface)) {
-            index.paths.interface[qualifyId(k, namespacePrefix, this.rootSubsystems)] = v;
+            index.paths.interface[qualifyDeclaredId(k, namespacePrefix)] = v;
           }
           for (const [k, v] of Object.entries(originalPaths.implementation)) {
-            index.paths.implementation[qualifyId(k, namespacePrefix, this.rootSubsystems)] = v;
+            index.paths.implementation[qualifyDeclaredId(k, namespacePrefix)] = v;
           }
           for (const [k, v] of Object.entries(originalPaths.type)) {
-            index.paths.type[qualifyId(k, namespacePrefix, this.rootSubsystems)] = v;
+            index.paths.type[qualifyDeclaredId(k, namespacePrefix)] = v;
           }
           for (const [k, v] of Object.entries(originalPaths.group)) {
-            index.paths.group[qualifyId(k, namespacePrefix, this.rootSubsystems)] = v;
+            index.paths.group[qualifyDeclaredId(k, namespacePrefix)] = v;
           }
         }
         if (currentDepth < maxDepth) {
           for (const subproj of localSubprojects) {
             const childDir = path19.resolve(projectDir, subproj.projectPath);
-            if (projectPathEscapesRoot(this.rootDir, subproj.projectPath, childDir)) {
+            const mountId = namespacePrefix ? qualifyDeclaredId(subproj.subsystemId, namespacePrefix, true) : subproj.subsystemId;
+            if (projectPathEscapesRoot(projectDir, subproj.projectPath, childDir)) {
               this.loaderIssues.push({
                 severity: "error",
                 code: "PROJECTPATH_ESCAPE",
-                message: `Subproject path "${subproj.projectPath}" declared by subsystem "${subproj.subsystemId}" escapes the project root "${this.rootDir}" (resolves to "${childDir}"); absolute and ../-escaping projectPaths are rejected. Skipping this subproject.`,
-                specId: subproj.subsystemId
+                message: `Subproject path "${subproj.projectPath}" declared by subsystem "${mountId}" escapes the root of the project declaring it, "${projectDir}" (resolves to "${childDir}"); absolute, ../-escaping and link-escaping projectPaths are rejected. Skipping this subproject.`,
+                specId: mountId
               });
               continue;
             }
-            if (visitedDirs.has(childDir)) {
+            if (visitedDirs.has(chainDirKey(childDir))) {
               this.loaderIssues.push({
                 severity: "error",
                 code: "CIRCULAR_SUBPROJECT_REFERENCE",
-                message: `Circular reference detected: Subsystem "${subproj.subsystemId}" refers to subproject "${childDir}" which is already loaded.`,
-                specId: subproj.subsystemId
+                message: `Circular reference detected: Subsystem "${mountId}" refers to subproject "${childDir}" which is already loaded.`,
+                specId: mountId
               });
               continue;
             }
@@ -16568,14 +16756,14 @@ var init_specs2 = __esm({
               this.loaderIssues.push({
                 severity: "error",
                 code: "SUBPROJECT_NOT_FOUND",
-                message: `Subproject directory "${childDir}" declared by subsystem "${subproj.subsystemId}" does not exist.`,
-                specId: subproj.subsystemId
+                message: `Subproject directory "${childDir}" declared by subsystem "${mountId}" does not exist.`,
+                specId: mountId
               });
               continue;
             }
             const childNamespace = namespacePrefix ? `${namespacePrefix}::${subproj.subsystemId}` : subproj.subsystemId;
             const newVisited = new Set(visitedDirs);
-            newVisited.add(childDir);
+            newVisited.add(chainDirKey(childDir));
             const childIndex = this.scanSpecsForProject(childDir, childNamespace, newVisited, maxDepth, currentDepth + 1);
             index.subsystems.push(...childIndex.subsystems);
             index.components.push(...childIndex.components);
@@ -16608,11 +16796,11 @@ var init_specs2 = __esm({
           const sub = index.subsystems.find((s) => s.id === currentPrefix);
           if (sub && sub.projectPath) {
             const nextDir = path19.resolve(currentDir, sub.projectPath);
-            if (projectPathEscapesRoot(this.rootDir, sub.projectPath, nextDir)) {
+            if (projectPathEscapesRoot(currentDir, sub.projectPath, nextDir)) {
               this.loaderIssues.push({
                 severity: "error",
                 code: "PROJECTPATH_ESCAPE",
-                message: `Subproject path "${sub.projectPath}" declared by subsystem "${currentPrefix}" escapes the project root "${this.rootDir}" (resolves to "${nextDir}"); absolute and ../-escaping projectPaths are rejected. Skipping this subproject.`,
+                message: `Subproject path "${sub.projectPath}" declared by subsystem "${currentPrefix}" escapes the root of the project declaring it, "${currentDir}" (resolves to "${nextDir}"); absolute, ../-escaping and link-escaping projectPaths are rejected. Skipping this subproject.`,
                 specId: currentPrefix
               });
               continue;
@@ -18256,6 +18444,7 @@ function externalizeSubsystem(subsystemId, projectPath) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   rewriteRefsInDir(parentSpecsDir, renameMap, fooDir);
+  rebaseMovedRefs(childFooDir, subsystemId, "into");
   invalidateSpecCache();
 }
 function internalizeSubsystem(subsystemId) {
@@ -18295,6 +18484,7 @@ function internalizeSubsystem(subsystemId) {
   });
   fs14.rmSync(childWai, { recursive: true, force: true });
   rewriteRefsInDir(parentSpecsDir, renameMap, fooDir);
+  rebaseMovedRefs(fooDir, subsystemId, "outOf");
   invalidateSpecCache();
 }
 function buildRenameMap(subsystemId, externalize) {
@@ -18321,7 +18511,27 @@ function buildRenameMap(subsystemId, externalize) {
 }
 function rewriteRefsInDir(specsDir, renameMap, excludeDir) {
   if (renameMap.size === 0) return;
-  const remap = (id) => id !== void 0 && renameMap.has(id) ? renameMap.get(id) : id;
+  rewriteRefFields(specsDir, (ref) => renameMap.get(ref) ?? ref, excludeDir);
+}
+function rebaseMovedRefs(movedDir, mount, direction) {
+  const declared = componentIdsUnder(movedDir);
+  rewriteRefFields(movedDir, (ref, position) => position === "component" ? rebaseReference(ref, mount, direction, (id) => declared.has(id)) : ref);
+}
+function componentIdsUnder(dir) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const file of listFilesRecursive(dir, ".yaml")) {
+    let raw;
+    try {
+      raw = readYamlFile(file);
+    } catch {
+      continue;
+    }
+    if (raw && typeof raw === "object" && "componentType" in raw && typeof raw.id === "string") ids.add(raw.id);
+  }
+  return ids;
+}
+function rewriteRefFields(specsDir, remap, excludeDir) {
+  const at = (ref, position) => typeof ref === "string" ? remap(ref, position) : ref;
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
     if (excludeDir && isWithinDir(excludeDir, file)) continue;
     let raw;
@@ -18333,14 +18543,14 @@ function rewriteRefsInDir(specsDir, renameMap, excludeDir) {
     if (!raw || typeof raw !== "object") continue;
     let changed = false;
     if ("componentType" in raw && Array.isArray(raw.dependsOn)) {
-      const next = raw.dependsOn.map((d) => remap(d));
+      const next = raw.dependsOn.map((d) => at(d, "component"));
       if (next.some((v, i) => v !== raw.dependsOn[i])) {
         raw.dependsOn = next;
         changed = true;
       }
       if (Array.isArray(raw.dispatch)) {
         for (const b of raw.dispatch) {
-          const nc = remap(b.component);
+          const nc = at(b.component, "component");
           if (nc !== b.component) {
             b.component = nc;
             changed = true;
@@ -18349,7 +18559,7 @@ function rewriteRefsInDir(specsDir, renameMap, excludeDir) {
       }
     } else if ("parentSystem" in raw && Array.isArray(raw.lifecycle)) {
       for (const le of raw.lifecycle) {
-        const nc = remap(le.component);
+        const nc = at(le.component, "component");
         if (nc !== le.component) {
           le.component = nc;
           changed = true;
@@ -18359,7 +18569,7 @@ function rewriteRefsInDir(specsDir, renameMap, excludeDir) {
       for (const m of raw.methods) {
         if (!Array.isArray(m.params)) continue;
         for (const p of m.params) {
-          const nt = remap(p.type);
+          const nt = at(p.type, "type");
           if (nt !== p.type) {
             p.type = nt;
             changed = true;
@@ -18370,7 +18580,7 @@ function rewriteRefsInDir(specsDir, renameMap, excludeDir) {
       for (const m of raw.methods) {
         if (!Array.isArray(m.narrative)) continue;
         for (const step of m.narrative) {
-          const nt = remap(step.targetComponent);
+          const nt = at(step.targetComponent, "component");
           if (nt !== step.targetComponent) {
             step.targetComponent = nt;
             changed = true;
@@ -18379,7 +18589,7 @@ function rewriteRefsInDir(specsDir, renameMap, excludeDir) {
       }
     } else if ("kind" in raw && Array.isArray(raw.fields)) {
       for (const f of raw.fields) {
-        const nt = remap(f.type);
+        const nt = at(f.type, "type");
         if (nt !== f.type) {
           f.type = nt;
           changed = true;
@@ -22768,8 +22978,34 @@ __export(server_exports, {
   captureBuildStamp: () => captureBuildStamp,
   createMcpServer: () => createMcpServer,
   isBuildStale: () => isBuildStale,
-  startMcpServer: () => startMcpServer
+  startMcpServer: () => startMcpServer,
+  statusFamilyContext: () => statusFamilyContext
 });
+function statusFamilyContext() {
+  const lines = [];
+  try {
+    const parent = resolveChainingParent();
+    if (parent) {
+      let parentName;
+      try {
+        const system = readYamlFile(aiPathsAt(parent.parentRoot).specsSystem());
+        if (typeof system?.name === "string") parentName = system.name;
+      } catch {
+      }
+      lines.push(
+        `Family: this project is a chained subproject, mounted as subsystem "${parent.subsystemId}" of ${parentName ? `the parent project "${parentName}"` : "its parent project"} \u2014 the surfaces it can consume are listed by sdd_list_external_interfaces.`
+      );
+    }
+    const mounts = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::"));
+    if (mounts.length > 0) {
+      lines.push(`Family: chained subprojects mounted here \u2014 ${mounts.map((s) => `${s.id} (${s.projectPath})`).join(", ")}.`);
+    }
+  } catch {
+  }
+  return lines.length > 0 ? `${lines.join("\n")}
+
+` : "";
+}
 function requireLoader() {
   return loader_exports;
 }
@@ -23981,10 +24217,11 @@ NOTICE:
     },
     ({ subsystem, recursive }) => {
       try {
-        return text(getStatusReport({
+        const report2 = getStatusReport({
           subsystem,
           recursive: recursive ?? true
-        }));
+        });
+        return text(`${statusFamilyContext()}${report2}`);
       } catch (e) {
         return errText(String(e));
       }
@@ -24112,8 +24349,10 @@ NOTICE:
       }
     }, hostedStub);
     reg(server, "sdd_host_export_tree", {
-      description: "Hosted spec-tree transfer: pack the BOUND project's WHOLE spec tree \u2014 its own .wai plus every chained subproject \u2014 into a .waitree archive, returned as base64 with its roots, file count and state id. The migration counterpart of an import: use it to take a hosted project local, or to move it to another instance. Requires project:read over the project. Bounded by the data-plane body cap; a very large tree exports through the web download route instead.",
-      inputSchema: {}
+      description: "Hosted spec-tree transfer: pack the BOUND project's WHOLE spec tree \u2014 its own .wai plus every chained subproject \u2014 into a .waitree archive, returned as base64 with its roots, file count and state id. The migration counterpart of an import: use it to take a hosted project local, or to move it to another instance. Requires project:read over the project. Bounded by the data-plane body cap; a very large tree exports through the web download route instead. Refuses when a chained mount cannot be packed (escaping, missing, cyclic, too deep, or holding no .wai), naming every one and why, unless allowPartial is set \u2014 then the archive is built anyway and the result lists what was skipped.",
+      inputSchema: {
+        allowPartial: import_zod10.z.boolean().optional().describe("Build the archive even when some chained mounts cannot be packed, listing them as skipped; default false (refuse and name them)")
+      }
     }, hostedStub);
     reg(server, "sdd_host_import_tree", {
       description: "Hosted spec-tree transfer: REPLACE the BOUND project's spec tree from a base64 .waitree archive. Requires project:admin over the project (strictly above project:write \u2014 this replaces the whole design, not one spec). Refuses an occupied destination unless replaceExisting is set, always refuses executable entries (rule/code packs install only through the trusted filesystem), and moves the previous tree aside to a backup whose path is returned.",
@@ -24176,6 +24415,7 @@ var init_server = __esm({
     path30 = __toESM(require("path"));
     import_url = require("url");
     init_fs();
+    init_yaml();
     init_status();
     init_defaults();
     init_narrative_labels();
@@ -25305,18 +25545,29 @@ function discardStagingDir(stagingDir) {
   } catch {
   }
 }
-function exportSpecTree(includeDerived) {
+function exportSpecTree(includeDerived, allowPartial) {
   const system = loadSystemSpec();
   if (!system) {
     throw new Error("no spec tree to export at this project root");
   }
-  const chained = listChainedRoots();
+  const inspection = inspectChainedRoots();
   const root = getProjectRoot();
-  const candidates = [
-    { relativePath: ".", waiDir: aiPathsAt(root).root() },
-    ...chained.map((rel2) => ({ relativePath: rel2, waiDir: aiPathsAt(path28.resolve(root, rel2)).root() }))
-  ];
-  const roots = candidates.filter((source) => pathExists(source.waiDir));
+  const skipped = [...inspection.skipped];
+  const roots = [{ relativePath: ".", waiDir: aiPathsAt(root).root() }];
+  for (const rel2 of inspection.roots) {
+    const waiDir = aiPathsAt(path28.resolve(root, rel2)).root();
+    if (pathExists(waiDir)) {
+      roots.push({ relativePath: rel2, waiDir });
+    } else {
+      skipped.push({ mount: rel2, projectPath: rel2, reason: "no-spec-tree" });
+    }
+  }
+  if (skipped.length > 0 && !allowPartial) {
+    const detail = skipped.map((s) => `${s.mount} (${s.reason})`).join(", ");
+    throw new Error(
+      `cannot export the whole spec tree \u2014 skipped: ${detail}. Pass allowPartial to export the rest anyway.`
+    );
+  }
   const stateId = computeStateId();
   const built = buildTreeArchive2(roots, system.name, stateId.digest, includeDerived);
   const result = {
@@ -25325,7 +25576,8 @@ function exportSpecTree(includeDerived) {
     projectName: built.manifest.projectName,
     roots: built.manifest.roots,
     fileCount: built.fileCount,
-    stateId: stateId.digest
+    stateId: stateId.digest,
+    skipped
   };
   return result;
 }
@@ -26254,6 +26506,7 @@ init_loader();
 init_validation();
 function isCiDraftWaivable(issue2) {
   if (issue2.severity !== "warning") return false;
+  if (issue2.code === "DRAFT_SUBSYSTEM_WARNING") return true;
   if (issue2.code === "DRAFT_COMPONENT_WARNING") return true;
   if (issue2.code === "UNUSED_COMPONENT") return issue2.draftContext === true;
   return false;
@@ -27727,7 +27980,7 @@ init_logger();
 init_validation();
 init_extensions();
 init_loader();
-async function listRules2() {
+async function listRules3() {
   let overrides = {};
   if (isProjectInitialized()) {
     try {
@@ -27742,7 +27995,7 @@ async function listRules2() {
   };
   const ext = loadProjectExtensions();
   const packRuleNames = new Set(ext.rules.map((r) => r.name));
-  const active = listRules();
+  const active = listRules2();
   const builtin = active.filter((r) => !packRuleNames.has(r.name));
   const packRules = active.filter((r) => packRuleNames.has(r.name));
   const groups = [
@@ -30104,7 +30357,19 @@ function excludeLocalFiles() {
   const excludePath = path48.join(getProjectRoot(), ".git", "info", "exclude");
   try {
     fs36.mkdirSync(path48.dirname(excludePath), { recursive: true });
-    fs36.appendFileSync(excludePath, "\n.wai/lock.json\n.wai/git.json\n");
+    const existing = fs36.existsSync(excludePath) ? fs36.readFileSync(excludePath, "utf8") : "";
+    const lines = existing.split(/\r?\n/).filter((line2) => line2.length > 0);
+    const hadLegacyLockExclusion = lines.some((line2) => line2.trim() === ".wai/lock.json");
+    const kept = lines.filter((line2) => line2.trim() !== ".wai/lock.json");
+    if (!kept.some((line2) => line2.trim() === ".wai/git.json")) {
+      kept.push(".wai/git.json");
+    }
+    fs36.writeFileSync(excludePath, kept.join("\n") + "\n");
+    if (hadLegacyLockExclusion) {
+      console.warn(
+        "[wairon git] removed a .wai/lock.json exclusion left by an earlier version \u2014 the approval it records is committed with the rest of .wai/ now, so it reaches the remote."
+      );
+    }
   } catch {
   }
 }
@@ -31076,13 +31341,13 @@ function listSecrets(_cfg, credential) {
   requireAdmin(credential);
   return listSecretKeys();
 }
-function exportProjectTree(cfg, credential, project2, subproject, includeDerived) {
+function exportProjectTree(cfg, credential, project2, subproject, includeDerived, allowPartial) {
   const principal = requirePrincipal(cfg, credential);
   if (authorize(cfg.dataDir, principal, "project:read", "project", project2).value !== "yes") {
     throw new AdminAuthError("Forbidden \u2014 exporting a project's spec tree requires project:read over it");
   }
   const root = boundLifecycleRoot(cfg, project2, subproject);
-  return runWithProjectRoot(root, () => hostCore.exportSpecTree(includeDerived));
+  return runWithProjectRoot(root, () => hostCore.exportSpecTree(includeDerived, allowPartial));
 }
 function importProjectTree(cfg, credential, project2, archive, subproject, replaceExisting) {
   const principal = requirePrincipal(cfg, credential);
@@ -35787,8 +36052,8 @@ function runPeriodicBackingSync(cfg) {
 }
 
 // src/server/projectops.ts
-function exportProjectTree2(cfg, credential, project2, subproject, includeDerived) {
-  return exportProjectTree(cfg, credential, project2, subproject, includeDerived);
+function exportProjectTree2(cfg, credential, project2, subproject, includeDerived, allowPartial) {
+  return exportProjectTree(cfg, credential, project2, subproject, includeDerived, allowPartial);
 }
 function importProjectTree2(cfg, credential, project2, archive, subproject, replaceExisting) {
   return importProjectTree(cfg, credential, project2, archive, subproject, replaceExisting);
@@ -39178,7 +39443,8 @@ function opsExportProjectTree(cfg, sessionId, url, res) {
     sessionId,
     q(url, "projectId") ?? "",
     void 0,
-    q(url, "includeDerived") === "1"
+    q(url, "includeDerived") === "1",
+    q(url, "allowPartial") === "1"
   );
   res.writeHead(200, {
     "content-type": "application/zip",
@@ -39902,7 +40168,8 @@ var PROJECT_RECORD_TOOLS = /* @__PURE__ */ new Set([
   "sdd_host_initialize_project",
   "sdd_host_get_approval_status",
   "sdd_host_await_approval",
-  ...PROJECT_OPS_TOOLS
+  ...PROJECT_OPS_TOOLS,
+  ...LANDSCAPE_DISCOVERY_TOOLS
 ]);
 function jsonRpcRequests(body) {
   const arr = Array.isArray(body) ? body : [body];
@@ -39930,11 +40197,31 @@ var WRITE_TOOL_PREFIXES = [
   "sdd_move_"
 ];
 var READ_TOOL_PREFIXES = ["sdd_get_", "sdd_validate_"];
+var READ_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "sdd_list_external_interfaces",
+  "listAgents",
+  "getAgent",
+  "listDomains",
+  "validateTopology",
+  "getProjectConfig"
+]);
 function requiredDataPlaneCapability(toolName) {
-  if (READ_TOOL_PREFIXES.some((p) => toolName.startsWith(p))) return "project:read";
+  if (READ_TOOL_NAMES.has(toolName) || READ_TOOL_PREFIXES.some((p) => toolName.startsWith(p))) return "project:read";
   if (WRITE_TOOL_PREFIXES.some((p) => toolName.startsWith(p))) return "project:write";
   return "project:write";
 }
+var TREE_SCOPED_HOST_TOOLS = /* @__PURE__ */ new Set([
+  "sdd_host_lock_project",
+  ...TREE_TRANSFER_TOOLS
+]);
+function toolScope(toolName) {
+  if (PROJECT_RECORD_TOOLS.has(toolName)) return "record";
+  if (TREE_SCOPED_HOST_TOOLS.has(toolName)) return "tree";
+  if (READ_TOOL_NAMES.has(toolName) || READ_TOOL_PREFIXES.some((p) => toolName.startsWith(p)) || WRITE_TOOL_PREFIXES.some((p) => toolName.startsWith(p))) {
+    return "tree";
+  }
+  return void 0;
+}
 var MUTATING_HOST_TOOLS = /* @__PURE__ */ new Set([
   "sdd_host_initialize_project",
   "sdd_host_lock_project",
@@ -39975,7 +40262,11 @@ function subprojectConfinementError(projectId, subproject, body) {
   const msg = jsonRpcRequest(body);
   if (!msg || msg.method !== "tools/call") return void 0;
   const name = msg.params?.name;
-  if (typeof name !== "string" || !PROJECT_RECORD_TOOLS.has(name)) return void 0;
+  if (typeof name !== "string") return void 0;
+  const scope = toolScope(name);
+  if (scope === "tree") return void 0;
+  const bound = `${projectId}${SUBPROJECT_SEPARATOR}${subproject}`;
+  const why = scope === "record" ? `${name} acts on the whole project "${projectId}", but this credential is bound to subproject "${bound}". ` : `${name} declares no scope, and this credential is bound to subproject "${bound}", which serves only tools that act on the bound tree. `;
   return {
     jsonrpc: "2.0",
     id: msg.id ?? null,
@@ -39983,7 +40274,7 @@ function subprojectConfinementError(projectId, subproject, body) {
       content: [
         {
           type: "text",
-          text: `Refused \u2014 ${name} acts on the whole project "${projectId}", but this credential is bound to subproject "${projectId}${SUBPROJECT_SEPARATOR}${subproject}". An unqualified credential for "${projectId}" is required to call ${name}.`
+          text: `Refused \u2014 ${why}An unqualified credential for "${projectId}" is required to call ${name}.`
         }
       ],
       isError: true
@@ -40068,14 +40359,22 @@ async function dispatchProjectLifecycleTool(cfg, credential, projectId, body, su
         );
         break;
       case "sdd_host_export_tree": {
-        const exported = exportProjectTree2(cfg, credential, projectId, subproject);
+        const exported = exportProjectTree2(
+          cfg,
+          credential,
+          projectId,
+          subproject,
+          void 0,
+          args.allowPartial === true
+        );
         value = {
           projectName: exported.projectName,
           roots: exported.roots,
           fileCount: exported.fileCount,
           stateId: exported.stateId,
           suggestedFileName: exported.suggestedFileName,
-          archiveBase64: Buffer.from(exported.archive).toString("base64")
+          archiveBase64: Buffer.from(exported.archive).toString("base64"),
+          skipped: exported.skipped
         };
         break;
       }
@@ -40663,7 +40962,8 @@ async function routeAdmin(cfg, req, res) {
         return sendJson(res, 200, { ok: true });
       }
       if (req.method === "GET" && parts.length === 4 && parts[3] === "tree") {
-        const exported = exportProjectTree(cfg, cred, parts[2]);
+        const allowPartial = url.searchParams.get("allowPartial") === "1";
+        const exported = exportProjectTree(cfg, cred, parts[2], void 0, void 0, allowPartial);
         res.writeHead(200, {
           "content-type": "application/zip",
           "content-disposition": `attachment; filename="${exported.suggestedFileName}"`
@@ -42115,8 +42415,8 @@ init_provision();
 function composeAgentBrief3(agentId) {
   return composeAgentBrief(agentId);
 }
-function exportSpecTree2(includeDerived) {
-  return exportSpecTree(includeDerived);
+function exportSpecTree2(includeDerived, allowPartial) {
+  return exportSpecTree(includeDerived, allowPartial);
 }
 function importSpecTree2(archive, options) {
   return importSpecTree(archive, options);
@@ -42328,8 +42628,8 @@ async function callTool(target, name, args) {
     return raw;
   }
 }
-async function exportRemoteTree(target) {
-  const payload = await callTool(target, "sdd_host_export_tree", {});
+async function exportRemoteTree(target, allowPartial) {
+  const payload = await callTool(target, "sdd_host_export_tree", { allowPartial: allowPartial === true });
   if (!payload || typeof payload.archiveBase64 !== "string" || !payload.archiveBase64) {
     throw new WaironError(`The hosted export returned no archive for project "${target.projectId}".`);
   }
@@ -42338,7 +42638,8 @@ async function exportRemoteTree(target) {
     suggestedFileName: payload.suggestedFileName ?? `${target.projectId}.waitree`,
     projectName: payload.projectName ?? target.projectId,
     roots: payload.roots ?? ["."],
-    fileCount: payload.fileCount ?? 0
+    fileCount: payload.fileCount ?? 0,
+    skipped: payload.skipped ?? []
   };
   if (payload.stateId) result.stateId = payload.stateId;
   return result;
@@ -42398,7 +42699,7 @@ async function initializeRemoteProject(target, ownerUnitId) {
   return record2.summary ?? `created project "${record2.id ?? topProjectId(target.projectId)}"`;
 }
 async function pushTree(target, options = {}) {
-  const exported = exportSpecTree2(options.includeDerived);
+  const exported = exportSpecTree2(options.includeDerived, options.allowPartial);
   const archivePath = writeArchiveIfAsked(exported.archive, options.archivePath, exported.suggestedFileName);
   let createdProject = false;
   if (options.createUnitId) {
@@ -42418,10 +42719,11 @@ async function pushTree(target, options = {}) {
   };
   if (imported.backupPath) result.backupPath = imported.backupPath;
   if (archivePath) result.archivePath = archivePath;
+  if (exported.skipped.length > 0) result.skipped = exported.skipped;
   return result;
 }
 async function pullTree(target, options = {}) {
-  const exported = await exportRemoteTree(target);
+  const exported = await exportRemoteTree(target, options.allowPartial);
   const archivePath = writeArchiveIfAsked(exported.archive, options.archivePath, exported.suggestedFileName);
   const imported = importSpecTree2(exported.archive, {
     replaceExisting: options.replaceExisting === true,
@@ -42438,6 +42740,7 @@ async function pullTree(target, options = {}) {
   };
   if (imported.backupPath) result.backupPath = imported.backupPath;
   if (archivePath) result.archivePath = archivePath;
+  if (exported.skipped.length > 0) result.skipped = exported.skipped;
   return result;
 }
 function resolveTarget(root, overrides = {}) {
@@ -42537,7 +42840,8 @@ async function runRemote(action, options = {}) {
       assertProjectInitialized();
       const transfer = {
         replaceExisting: options.force === true,
-        includeDerived: options.includeDerived === true
+        includeDerived: options.includeDerived === true,
+        allowPartial: options.allowPartial === true
       };
       if (options.unit) transfer.createUnitId = options.unit;
       if (options.archive) transfer.archivePath = options.archive;
@@ -42545,7 +42849,10 @@ async function runRemote(action, options = {}) {
       return;
     }
     case "pull": {
-      const transfer = { replaceExisting: options.force === true };
+      const transfer = {
+        replaceExisting: options.force === true,
+        allowPartial: options.allowPartial === true
+      };
       if (options.archive) transfer.archivePath = options.archive;
       if (options.dir) transfer.destDir = path68.resolve(options.dir);
       report(await pullTree(target, transfer));
@@ -42654,6 +42961,11 @@ function report(outcome) {
   if (outcome.backupPath) {
     logger.info(`The replaced tree was backed up to ${import_chalk20.default.cyan(outcome.backupPath)} \u2014 restore it by moving it back.`);
   }
+  if (outcome.skipped && outcome.skipped.length > 0) {
+    logger.warn(
+      `Skipped ${outcome.skipped.length} mount(s) \u2014 allowPartial let this through: ` + outcome.skipped.map((s) => `${s.mount} (${s.reason})`).join(", ")
+    );
+  }
 }
 
 // src/cli/index.ts
@@ -42885,7 +43197,7 @@ program.command("doctor").description("Health check: flags stale generated guide
   await runDoctor({ fix: opts.fix });
 });
 async function runRules() {
-  await listRules2();
+  await listRules3();
 }
 async function runPatterns() {
   await listPatterns();
@@ -43108,7 +43420,10 @@ program.command("login <url>").description("store a bearer credential for a host
 program.command("logout [url]").description("forget a stored credential for a hosted instance (local only \u2014 does NOT revoke it), or list what is stored").action(async (url) => {
   await runLogout(url, {});
 });
-program.command("remote <action>").description("hosted instance: push | pull (migrate a spec tree) \xB7 attach | detach | status (bind this checkout)").option("--url <url>", "hosted instance base URL (else WAIRON_REMOTE_URL)").option("--project <id>", "hosted project id, optionally qualified as project::subsystem (else WAIRON_REMOTE_PROJECT)").option("--token <token>", "bearer credential (else WAIRON_REMOTE_TOKEN) \u2014 mint one in the hosted UI under Tokens").option("--unit <id>", "push: create the destination project first, owned by this organization unit").option("--force", "replace an authored spec tree at the destination (it is backed up first)").option("--include-derived", "push: pack regenerable artifacts (diagrams, generated topology) too").option("--archive <path>", "also write the transferred archive to this path (file or directory)").option("--dir <path>", "pull: the local project root to import into (default: this project)").action(async (action, opts) => {
+program.command("remote <action>").description("hosted instance: push | pull (migrate a spec tree) \xB7 attach | detach | status (bind this checkout)").option("--url <url>", "hosted instance base URL (else WAIRON_REMOTE_URL)").option("--project <id>", "hosted project id, optionally qualified as project::subsystem (else WAIRON_REMOTE_PROJECT)").option("--token <token>", "bearer credential (else WAIRON_REMOTE_TOKEN) \u2014 mint one in the hosted UI under Tokens").option("--unit <id>", "push: create the destination project first, owned by this organization unit").option("--force", "replace an authored spec tree at the destination (it is backed up first)").option("--include-derived", "push: pack regenerable artifacts (diagrams, generated topology) too").option(
+  "--allow-partial",
+  "build the archive even when some chained mounts cannot be packed, listing them as skipped (default: refuse)"
+).option("--archive <path>", "also write the transferred archive to this path (file or directory)").option("--dir <path>", "pull: the local project root to import into (default: this project)").action(async (action, opts) => {
   await runRemote(action, {
     url: opts.url,
     project: opts.project,
@@ -43116,6 +43431,7 @@ program.command("remote <action>").description("hosted instance: push | pull (mi
     unit: opts.unit,
     force: opts.force,
     includeDerived: opts.includeDerived,
+    allowPartial: opts.allowPartial,
     archive: opts.archive,
     dir: opts.dir
   });