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

package/dist/index.js

@@ -1312,7 +1312,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";
@@ -2884,17 +2884,43 @@ function isExternalNamespaceRef(ctx, ref) {
   if (sep6 === -1) return false;
   return !ctx.subsystemIds.has(ref.slice(0, sep6));
 }
+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 = [];
@@ -2985,6 +3011,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" }
@@ -3039,7 +3066,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",
@@ -3099,7 +3137,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(
@@ -4614,6 +4663,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" },
@@ -4637,7 +4687,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",
@@ -4729,12 +4783,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)
                 );
@@ -8010,7 +8064,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.
@@ -8073,7 +8127,7 @@ function buildRuleContext(opts) {
     mountSurfaceSnapshots: opts.mountSurfaceSnapshots ?? [],
     codeModel: opts.codeModel ?? emptyCodeModel(),
     lintAllows,
-    knownIssueCodes,
+    knownIssueCodes: knownIssueCodes2,
     addIssue
   };
 }
@@ -8343,8 +8397,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 };
 }
@@ -8375,7 +8429,7 @@ var init_statehash = __esm({
     init_specs2();
     init_rules();
     CONTENT_ALGORITHM = "sha256";
-    GATE_ALGORITHM = "sha256+doctrine";
+    GATE_ALGORITHM = "sha256+doctrine+inputs";
   }
 });
 
@@ -13349,6 +13403,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);
@@ -13360,6 +13417,9 @@ function ruleSequence() {
   const base = ruleSet.filter((r) => r !== lintAllowsRule);
   return ruleSet.includes(lintAllowsRule) ? [...base, lintAllowsRule] : base;
 }
+function knownIssueCodes() {
+  return listRules().flatMap((r) => r.codes);
+}
 var ruleSet;
 var init_repository = __esm({
   "src/core/rules/repository.ts"() {
@@ -14132,15 +14192,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) {
@@ -14151,17 +14214,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,
@@ -14291,6 +14358,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 };
 }
@@ -14372,7 +14465,7 @@ function validateProjectConfig(config) {
     issues
   };
 }
-function listRules() {
+function listRules2() {
   const extensions = loadProjectExtensions();
   registerBuiltinRules();
   registerPackRules(extensions.rules);
@@ -14472,21 +14565,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,
@@ -14503,14 +14597,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 ? path14.resolve(reach.topRoot) : void 0;
   const chain = [];
   let top = path14.resolve(boundRoot);
   while (top !== ceiling) {
-    const hop = findChainingParent(top);
+    const hop = findChainingParent(top, ceiling);
     if (!hop) break;
     const next = path14.resolve(hop.parentRoot);
     if (ceiling && !isWithinOrEqual(ceiling, next)) break;
@@ -14521,10 +14615,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({
@@ -14598,7 +14692,7 @@ function settledStatusBearing(loaded) {
 function validateAsComplete(options) {
   return validateSddTree({ ...options ?? {}, treatAllAsComplete: true });
 }
-var path14, SUBPROJECT_REFERENCE_CODES;
+var path14, RESOLUTION_FAILURE_CODES, SEVERITY_RANK;
 var init_validation = __esm({
   "src/core/validation.ts"() {
     "use strict";
@@ -14614,16 +14708,15 @@ var init_validation = __esm({
     init_fs();
     path14 = __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 };
   }
 });
 
@@ -15197,6 +15290,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(qualifiedId) {
   if (!qualifiedId.includes("::")) {
     return { prefix: "", localId: qualifiedId };
@@ -15227,33 +15334,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 = path15.resolve(dir);
   const f = path15.resolve(file);
   return f === d || f.startsWith(d + path15.sep);
 }
+function canonicalPath(target) {
+  let existing = path15.resolve(target);
+  const rest = [];
+  for (; ; ) {
+    try {
+      fs9.lstatSync(existing);
+      break;
+    } catch {
+      const up = path15.dirname(existing);
+      if (up === existing) return path15.resolve(target);
+      rest.unshift(path15.basename(existing));
+      existing = up;
+    }
+  }
+  try {
+    return path15.join(fs9.realpathSync.native(existing), ...rest);
+  } catch {
+    return null;
+  }
+}
+function chainDirKey(dir) {
+  return canonicalPath(dir) ?? path15.resolve(dir);
+}
 function projectPathEscapesRoot(projectRoot, projectPath, resolvedChildDir) {
-  return path15.isAbsolute(projectPath) || !isWithin(projectRoot, resolvedChildDir);
+  if (path15.isAbsolute(projectPath) || !isWithin(projectRoot, resolvedChildDir)) return true;
+  const root = canonicalPath(projectRoot);
+  const child = canonicalPath(resolvedChildDir);
+  return root === null || child === null || !isWithin(root, child);
 }
 function assertContainedProjectPath(projectRoot, projectPath) {
   const root = path15.resolve(projectRoot);
   const resolved = path15.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 = path15.resolve(childRoot);
   } catch {
     return null;
   }
+  const bound = ceiling ? path15.resolve(ceiling) : void 0;
   let dir = path15.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")) {
@@ -15267,7 +15416,8 @@ function findChainingParent(childRoot) {
           const projectPath = raw.projectPath;
           if (typeof projectPath === "string" && projectPath.trim() !== "") {
             try {
-              if (path15.resolve(dir, projectPath) === childResolved) {
+              const mountDir = path15.resolve(dir, projectPath);
+              if (mountDir === childResolved && !projectPathEscapesRoot(dir, projectPath, mountDir)) {
                 const id = raw.id;
                 return { parentRoot: dir, subsystemId: typeof id === "string" ? id : "?" };
               }
@@ -15283,12 +15433,11 @@ function findChainingParent(childRoot) {
   }
   return null;
 }
-function listChainedRoots(rootDir = getProjectRoot()) {
+function inspectChainedRoots(rootDir = getProjectRoot()) {
   const root = path15.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")) {
@@ -15299,24 +15448,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 = path15.resolve(projectDir, projectPath);
       } catch {
         continue;
       }
-      if (projectPathEscapesRoot(root, projectPath, childDir)) continue;
-      if (visited.has(childDir)) continue;
-      if (!fs9.existsSync(childDir)) continue;
-      visited.add(childDir);
-      found.push(path15.relative(root, childDir).split(path15.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 (!fs9.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(path15.relative(root, childDir).split(path15.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 = [];
@@ -15597,7 +15759,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 = path15.join(rootDir, ".wai", "surfaces");
+  if (!pathExists(dir)) return [];
+  const keys = [];
+  for (const file of fs9.readdirSync(dir)) {
+    if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
+    try {
+      keys.push(snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path15.join(dir, file)))));
+    } catch {
+    }
+  }
+  return keys;
 }
 function computeGateStateId() {
   let gate = {};
@@ -15606,7 +15787,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) => path15.join(root, rel2))];
+  const inputs = roots.flatMap(consumedSurfaceInputsAt);
+  return hashGateState(loadProjectExtensions(), inputs, gate);
 }
 function readLockState() {
   const record = readLockRecord();
@@ -15662,7 +15846,7 @@ function findLegacySpecFiles() {
 function updateSpec(kind, id, delta, hooks) {
   return current().updateSpec(kind, id, delta, hooks);
 }
-var fs9, path15, SIGNATURE_TTL_MS, SpecWorkspace, workspaces;
+var fs9, path15, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, SpecWorkspace, workspaces;
 var init_specs2 = __esm({
   "src/core/specs.ts"() {
     "use strict";
@@ -15677,6 +15861,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) {
@@ -15715,7 +15900,7 @@ var init_specs2 = __esm({
         this.rootSubsystems.clear();
         this.cachedRecursive = recursive;
         this.scanVisitedSpecDirs = [];
-        const visited = /* @__PURE__ */ new Set([path15.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;
@@ -15826,7 +16011,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,
@@ -15845,14 +16030,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) => ({
@@ -15862,12 +16047,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,
@@ -15879,13 +16064,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 = {
@@ -15897,39 +16082,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 = path15.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;
             }
@@ -15937,14 +16123,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);
@@ -15977,11 +16163,11 @@ var init_specs2 = __esm({
           const sub = index.subsystems.find((s) => s.id === currentPrefix);
           if (sub && sub.projectPath) {
             const nextDir = path15.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;
@@ -21454,6 +21640,7 @@ __export(src_exports, {
   buildRuleContext: () => buildRuleContext,
   buildServerInstructions: () => buildServerInstructions2,
   buildTreeArchive: () => buildTreeArchive2,
+  canonicalize: () => canonicalize,
   captureApprovedSpecs: () => captureApprovedSpecs,
   checkSkillFreshness: () => checkSkillFreshness,
   clearLoaderIssues: () => clearLoaderIssues,
@@ -21464,7 +21651,6 @@ __export(src_exports, {
   composeVariantGuidance: () => composeVariantGuidance,
   computeGateStateId: () => computeGateStateId,
   computePackDigest: () => computePackDigest,
-  computeParentStateId: () => computeParentStateId,
   computeStateId: () => computeStateId,
   computeStateIdAt: () => computeStateIdAt,
   contextDir: () => contextDir,
@@ -21541,6 +21727,7 @@ __export(src_exports, {
   hashGateState: () => hashGateState,
   importSpecTree: () => importSpecTree,
   importSurface: () => importSurface,
+  inspectChainedRoots: () => inspectChainedRoots,
   inspectTreeArchive: () => inspectTreeArchive2,
   installPackFromDirectory: () => installPackFromDirectory,
   internalizeSubsystem: () => internalizeSubsystem,
@@ -21556,7 +21743,7 @@ __export(src_exports, {
   listInstalledPacks: () => listInstalledPacks,
   listMountSnapshots: () => listMountSnapshots,
   listResources: () => listResources,
-  listRules: () => listRules,
+  listRules: () => listRules2,
   listSkillNames: () => listSkillNames,
   listSkillResources: () => listSkillResources,
   listSnapshots: () => listSnapshots,
@@ -21619,6 +21806,7 @@ __export(src_exports, {
   readResource: () => readResource,
   readSkillResource: () => readSkillResource,
   readYamlFile: () => readYamlFile,
+  rebaseReference: () => rebaseReference,
   registerExporter: () => registerExporter,
   removeFreeStandingDomain: () => removeFreeStandingDomain,
   removeSnapshot: () => removeSnapshot,
@@ -22112,6 +22300,7 @@ function externalizeSubsystem(subsystemId, projectPath) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   rewriteRefsInDir(parentSpecsDir, renameMap, fooDir);
+  rebaseMovedRefs(childFooDir, subsystemId, "into");
   invalidateSpecCache();
 }
 function internalizeSubsystem(subsystemId) {
@@ -22151,6 +22340,7 @@ function internalizeSubsystem(subsystemId) {
   });
   fs13.rmSync(childWai, { recursive: true, force: true });
   rewriteRefsInDir(parentSpecsDir, renameMap, fooDir);
+  rebaseMovedRefs(fooDir, subsystemId, "outOf");
   invalidateSpecCache();
 }
 function buildRenameMap(subsystemId, externalize) {
@@ -22177,7 +22367,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;
@@ -22189,14 +22399,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;
@@ -22205,7 +22415,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;
@@ -22215,7 +22425,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;
@@ -22226,7 +22436,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;
@@ -22235,7 +22445,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;
@@ -22831,18 +23041,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(path22.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(path22.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 = {
@@ -22851,7 +23072,8 @@ function exportSpecTree(includeDerived) {
     projectName: built.manifest.projectName,
     roots: built.manifest.roots,
     fileCount: built.fileCount,
-    stateId: stateId.digest
+    stateId: stateId.digest,
+    skipped
   };
   return result;
 }
@@ -23372,6 +23594,7 @@ init_yaml();
   buildRuleContext,
   buildServerInstructions,
   buildTreeArchive,
+  canonicalize,
   captureApprovedSpecs,
   checkSkillFreshness,
   clearLoaderIssues,
@@ -23382,7 +23605,6 @@ init_yaml();
   composeVariantGuidance,
   computeGateStateId,
   computePackDigest,
-  computeParentStateId,
   computeStateId,
   computeStateIdAt,
   contextDir,
@@ -23459,6 +23681,7 @@ init_yaml();
   hashGateState,
   importSpecTree,
   importSurface,
+  inspectChainedRoots,
   inspectTreeArchive,
   installPackFromDirectory,
   internalizeSubsystem,
@@ -23537,6 +23760,7 @@ init_yaml();
   readResource,
   readSkillResource,
   readYamlFile,
+  rebaseReference,
   registerExporter,
   removeFreeStandingDomain,
   removeSnapshot,