@wairon/cli 5.0.2-dev.12 → 5.0.2-dev.14

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.0.2-dev.12";
+    WAIRON_VERSION = "5.0.2-dev.14";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -1914,6 +1914,47 @@ var init_loader = __esm({
   }
 });
 
+// src/core/statehash.ts
+function computeStateId() {
+  const tree = {
+    system: loadSystemSpec(),
+    subsystems: loadSubsystemSpecs(),
+    components: loadComponentSpecs(),
+    interfaces: loadInterfaceSpecs(),
+    implementations: loadImplementationSpecs(),
+    types: loadTypeSpecs()
+  };
+  const digest = crypto.createHash("sha256").update(canonicalize(tree)).digest("hex");
+  return { algorithm: "sha256", digest };
+}
+function stateIdEquals(a, b) {
+  return !!a && !!b && a.algorithm === b.algorithm && a.digest === b.digest;
+}
+function canonicalize(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(v) {
+  if (Array.isArray(v)) return v.map(sortKeys);
+  if (v && typeof v === "object") {
+    const src = v;
+    const out = {};
+    for (const k of Object.keys(src).sort()) {
+      if (k === "createdAt" || k === "updatedAt") continue;
+      out[k] = sortKeys(src[k]);
+    }
+    return out;
+  }
+  return v;
+}
+var crypto;
+var init_statehash = __esm({
+  "src/core/statehash.ts"() {
+    "use strict";
+    crypto = __toESM(require("crypto"));
+    init_specs2();
+  }
+});
+
 // src/core/narrative-labels.ts
 function resolveNarrativeLabels(methodName, steps) {
   const errors = [];
@@ -2999,6 +3040,16 @@ header input[type="search"]::placeholder { color:var(--dim); }
 #moreMenu .dropdown { display:block; width:100%; }
 #moreMenu .dropdown > .tbtn, #moreMenu > .tbtn { display:block; width:100%; text-align:left; border:none; background:transparent; margin:2px 0; }
 #moreMenu .dropdown > .tbtn:hover, #moreMenu > .tbtn:hover { background:var(--hover-bg); }
+/* Staged header compaction (responsive only, never persisted): compact
+   stand-ins for the search input, the mode tabs, and the ancestor crumbs.
+   All hidden at full width, so a roomy header renders exactly as before. */
+#searchBtn { position:relative; }
+#searchBtn.hasq::after { content:''; position:absolute; top:3px; right:3px; width:7px; height:7px; border-radius:50%; background:var(--accent); }
+.search-menu { min-width:210px; padding:8px; }
+.search-menu input[type="search"] { width:100%; }
+#modeMenu button.active { background:var(--accent); color:#fff; font-weight:700; }
+#crumbs .dropdown { display:inline-flex; }
+#crumbs .crumbmore { font-weight:700; }
 
 /* Settings panel \u2014 toggle switches */
 .settings-menu { min-width:266px; }
@@ -3122,9 +3173,17 @@ body.presentation #exitPresent, body.presentation #presentDetails { display:bloc
     <button data-vm="types">Types</button>
     <button data-vm="databases">Databases</button>
   </div>
+  <div class="dropdown" id="modeDd" style="display:none">
+    <button class="tbtn" id="modeBtn" title="Switch between the component architecture, the type ERD, or the database schemas">Components \u25BE</button>
+    <div class="menu" id="modeMenu"></div>
+  </div>
   <nav id="crumbs"></nav>
   <span class="divider"></span>
   <input id="search" type="search" placeholder="Search this view\u2026">
+  <div class="dropdown" id="searchDd" style="display:none">
+    <button class="tbtn" id="searchBtn" title="Search this view">\u{1F50D}</button>
+    <div class="menu search-menu" id="searchMenu"></div>
+  </div>
   <div class="seg" id="typesDetailSeg" style="display:none" title="ERD detail level">
     <button data-td="full">Full</button>
     <button data-td="fields">Fields</button>
@@ -3641,13 +3700,300 @@ var MODEL = __MODEL_JSON__;
   var BOX_W = 200, BOX_H = 56, SUBBOX_W = 230, SUBBOX_H = 84, GAP_X = 110, GAP_Y = 34;
   var INNER_W = 130, INNER_H = 36, INNER_GAPX = 26, INNER_GAPY = 12, HEAD_H = 34, PADI = 14;
 
+  // ---- deep expansion (opt-in via subsystem.deepInternals) -------------------
+  // When Internals is on and a subsystem record carries deepInternals:true, its
+  // box renders its WHOLE subtree instead of one layer: deep-flagged child
+  // subsystems become NESTED boundary boxes (recursing, defensively capped),
+  // every other child renders as a fixed leaf tile that is never expanded
+  // further. Sizes are computed bottom-up (a nested container tile takes its
+  // recursive {w,h}); positions are emitted top-down by accumulating parent
+  // top-left offsets. Relations between concrete visible endpoints are drawn
+  // as ONE direct line each by buildDeepContext \u2014 crossing nested boundaries
+  // on purpose (the full org overview of project relations); only relations
+  // that cannot resolve to two concrete endpoints keep today's port machinery,
+  // and ONLY at the outermost box. Without the flag this whole path is inert
+  // and the classic one-layer innerLayout runs unchanged.
+  var DEEP_MAX_DEPTH = 6;
+  function isDeepId(subId) {
+    var s = subById[subId];
+    return !!(s && s.deepInternals);
+  }
+  // The DEEPEST visible tile representing compId inside the deep-expanded box
+  // rooted at rootSubId: descend deep-flagged containers (the same expansion
+  // rule as deepContainerLayout) until the containing child is a leaf tile.
+  // Returns the child entry { kind, id } (its node id is IN(kind, id)).
+  function deepLeafFor(compId, rootSubId) {
+    var subId = rootSubId, depth = 1;
+    for (;;) {
+      var child = childOfScopeContaining(compId, { kind: 'subsystem', id: subId });
+      if (!child) return null;
+      if (child.kind === 'subsystem' && isDeepId(child.id) && depth < DEEP_MAX_DEPTH) {
+        subId = child.id; depth += 1;
+        continue;
+      }
+      return child;
+    }
+  }
+  // One deep container's DIRECT children, placed with PER-TILE sizes (nested
+  // containers take their recursive size; leaves stay INNER_W x INNER_H). The
+  // placement mirrors innerLayout's strategy switch, generalised to variable
+  // tile sizes. Tiles are centres relative to THIS container's top-left corner
+  // (content sits right of PADI, below the HEAD_H label band); nested tiles
+  // are relative to their own container, so emission accumulates offsets.
+  function deepContainerLayout(subId, depth) {
+    var kids = childrenOf({ kind: 'subsystem', id: subId });
+    if (!kids.length) {
+      // An EMPTY deep subsystem still shows as a (min-size) boundary box.
+      return { tiles: [], w: INNER_W + 2 * PADI, h: HEAD_H + PADI };
+    }
+    var scope = { kind: 'subsystem', id: subId };
+    var kidKey = function (k) { return k.kind + ':' + k.id; };
+    var size = {};
+    kids.forEach(function (k) {
+      if (k.kind === 'subsystem' && isDeepId(k.id) && depth < DEEP_MAX_DEPTH) {
+        var nested = deepContainerLayout(k.id, depth + 1);
+        size[kidKey(k)] = { w: nested.w, h: nested.h, sub: nested };
+      } else {
+        size[kidKey(k)] = { w: INNER_W, h: INNER_H, sub: null };
+      }
+    });
+    // Intra-container edges lifted to DIRECT children \u2014 for LAYOUT ONLY (the
+    // drawn lines come from buildDeepContext's direct pass, never per level).
+    var intra = {};
+    MODEL.edges.forEach(function (edge) {
+      var a = childOfScopeContaining(edge.from, scope);
+      var b = childOfScopeContaining(edge.to, scope);
+      if (!a || !b) return;
+      var ak = a.kind + ':' + a.id, bk = b.kind + ':' + b.id;
+      if (!size[ak] || !size[bk] || ak === bk) return;
+      intra[ak + '=>' + bk] = 1;
+    });
+    var layer = {};
+    function calc(k, stack) {
+      var key = kidKey(k);
+      if (layer[key] !== undefined) return layer[key];
+      if (stack[key]) return 0;
+      stack[key] = 1;
+      var l = 0;
+      if (k.kind === 'component') {
+        var c = compById[k.id];
+        if (c && (c.componentType === 'Portal' || c.componentType === 'Observer')) { layer[key] = 0; delete stack[key]; return 0; }
+      }
+      Object.keys(intra).forEach(function (ek) {
+        var cut = ek.indexOf('=>');
+        if (ek.slice(cut + 2) !== key) return;
+        var srcKid = kids.filter(function (x) { return kidKey(x) === ek.slice(0, cut); })[0];
+        if (srcKid) l = Math.max(l, calc(srcKid, stack) + 1);
+      });
+      delete stack[key];
+      layer[key] = l;
+      return l;
+    }
+    kids.forEach(function (k) { calc(k, {}); });
+    var tiles = [], contentW = 0, contentH = 0;
+    if (state.layout === 'grid') {
+      // Row packing by ACTUAL tile size (the fixed per-column grid assumed
+      // uniform tiles); the target row width follows the tile count, widened
+      // to at least the widest single tile.
+      var gsorted = kids.slice().sort(function (a, b) { return a.id < b.id ? -1 : 1; });
+      var target = Math.max(1, Math.ceil(Math.sqrt(kids.length))) * (INNER_W + INNER_GAPX);
+      kids.forEach(function (k) { var s0 = size[kidKey(k)]; if (s0.w > target) target = s0.w; });
+      var gx = 0, gy = 0, rowH = 0;
+      gsorted.forEach(function (k) {
+        var s = size[kidKey(k)];
+        if (gx > 0 && gx + s.w > target) { gx = 0; gy += rowH + INNER_GAPY; rowH = 0; }
+        tiles.push({ kid: k, x: gx + s.w / 2, y: gy + s.h / 2, w: s.w, h: s.h, sub: s.sub });
+        gx += s.w + INNER_GAPX;
+        if (s.h > rowH) rowH = s.h;
+        if (gx - INNER_GAPX > contentW) contentW = gx - INNER_GAPX;
+        if (gy + rowH > contentH) contentH = gy + rowH;
+      });
+    } else if (state.layout === 'concentric' || state.layout === 'force') {
+      var ideg = {};
+      kids.forEach(function (k) { ideg[kidKey(k)] = 0; });
+      Object.keys(intra).forEach(function (ek) {
+        var cut2 = ek.indexOf('=>');
+        var sk = ek.slice(0, cut2), tk = ek.slice(cut2 + 2);
+        if (ideg[sk] !== undefined) ideg[sk]++;
+        if (ideg[tk] !== undefined) ideg[tk]++;
+      });
+      var rel = concentricPositions(
+        kids.map(kidKey),
+        function (key) { return ideg[key] || 0; },
+        function (key) { return { w: size[key].w, h: size[key].h }; }
+      );
+      // Normalise by the tiles' BOUNDING BOX (not just the centres) so a wide
+      // nested container on the rim still clears the container's left/top pad.
+      var minL = Infinity, minT = Infinity;
+      kids.forEach(function (k) {
+        var s1 = size[kidKey(k)], p1 = rel[kidKey(k)] || { x: 0, y: 0 };
+        if (p1.x - s1.w / 2 < minL) minL = p1.x - s1.w / 2;
+        if (p1.y - s1.h / 2 < minT) minT = p1.y - s1.h / 2;
+      });
+      if (minL === Infinity) { minL = 0; minT = 0; }
+      kids.forEach(function (k) {
+        var s2 = size[kidKey(k)], p2 = rel[kidKey(k)] || { x: 0, y: 0 };
+        var cx = p2.x - minL, cyy = p2.y - minT;
+        tiles.push({ kid: k, x: cx, y: cyy, w: s2.w, h: s2.h, sub: s2.sub });
+        if (cx + s2.w / 2 > contentW) contentW = cx + s2.w / 2;
+        if (cyy + s2.h / 2 > contentH) contentH = cyy + s2.h / 2;
+      });
+    } else {
+      // Layered dependency columns: the column is as wide as its widest tile,
+      // and each tile advances by ITS OWN height.
+      var cols = {};
+      kids.forEach(function (k) { var l = layer[kidKey(k)] || 0; (cols[l] = cols[l] || []).push(k); });
+      var colKeys = Object.keys(cols).map(Number).sort(function (a, b) { return a - b; });
+      var x = 0;
+      colKeys.forEach(function (ck) {
+        var col = cols[ck].sort(function (a, b) { return a.id < b.id ? -1 : 1; });
+        var colW = 0, y = 0;
+        col.forEach(function (k) { var s3 = size[kidKey(k)]; if (s3.w > colW) colW = s3.w; });
+        col.forEach(function (k) {
+          var s = size[kidKey(k)];
+          tiles.push({ kid: k, x: x + colW / 2, y: y + s.h / 2, w: s.w, h: s.h, sub: s.sub });
+          y += s.h + INNER_GAPY;
+        });
+        if (y - INNER_GAPY > contentH) contentH = y - INNER_GAPY;
+        x += colW + INNER_GAPX;
+      });
+      contentW = x - INNER_GAPX;
+    }
+    tiles.forEach(function (t) { t.x += PADI; t.y += HEAD_H; });
+    return { tiles: tiles, w: contentW + 2 * PADI, h: HEAD_H + contentH + PADI };
+  }
+  // Top-level deep box: the recursive interior plus today's port machinery at
+  // the OUTERMOST box only (buildDeepContext supplies which relations still
+  // need ports; stubs run port <-> the DEEPEST visible leaf tile). Returns the
+  // same shape as innerLayout, plus deep:true so emission recurses.
+  function deepLayout(entry, portRec) {
+    var box = deepContainerLayout(entry.id, 1);
+    var parentId = anchorNodeId(entry);
+    var pBaseIn = 'p~in~' + parentId + '~', pBaseOut = 'p~out~' + parentId + '~';
+    var extIn = portRec ? portRec.extIn : {}, extOut = portRec ? portRec.extOut : {};
+    var inIds = Object.keys(extIn).sort(), outIds = Object.keys(extOut).sort();
+    var hasIn = inIds.length > 0, hasOut = outIds.length > 0;
+    var PROXY_W = 22, PROXY_H = 22, PROXY_GAP = 8;
+    var shift = hasIn ? PROXY_W + INNER_GAPX : 0;
+    var tiles = box.tiles;
+    if (shift) tiles.forEach(function (t) { t.x += shift; });
+    var w = box.w + shift + (hasOut ? PROXY_W + INNER_GAPX : 0);
+    if (w < SUBBOX_W) w = SUBBOX_W;
+    var stackMax = Math.max(inIds.length, outIds.length);
+    var h = Math.max(box.h, HEAD_H + stackMax * PROXY_H + Math.max(0, stackMax - 1) * PROXY_GAP + PADI);
+    var midY = HEAD_H + Math.max(0, (h - HEAD_H - PADI) / 2);
+    function stackPorts(ids, recs, base, cx, dir) {
+      var total = ids.length * PROXY_H + Math.max(0, ids.length - 1) * PROXY_GAP;
+      var y0 = Math.max(HEAD_H + PROXY_H / 2, midY - total / 2 + PROXY_H / 2);
+      return ids.map(function (eid, i) {
+        var km = recs[eid].kids, klist = [];
+        Object.keys(km).forEach(function (key) { klist.push(km[key]); });
+        return { id: base + eid, extId: eid, dir: dir, kids: klist, raws: Object.keys(recs[eid].raws), x: cx, y: y0 + i * (PROXY_H + PROXY_GAP), w: PROXY_W, h: PROXY_H };
+      });
+    }
+    return {
+      deep: true,
+      tiles: tiles,
+      edges: portRec ? Object.keys(portRec.stubs).map(function (k) { return portRec.stubs[k]; }) : [],
+      proxies: stackPorts(inIds, extIn, pBaseIn, PADI + PROXY_W / 2, 'in')
+        .concat(stackPorts(outIds, extOut, pBaseOut, w - PADI - PROXY_W / 2, 'out')),
+      w: w,
+      h: h,
+    };
+  }
+  // View-level deep context (null unless Internals is on AND at least one
+  // in-view entry is deep-flagged \u2014 the classic path never sees it): which
+  // top-level entries are deep-expanded; every relation drawn as a DIRECT
+  // concrete line (deduped per src=>tgt pair); the per-top-pair count used to
+  // suppress aggregated edges whose constituents are ALL drawn directly; and
+  // the port records for relations that keep today's port semantics.
+  function buildDeepContext(scope, entries) {
+    if (!state.internals) return null;
+    var deepByAnchor = {}, any = false;
+    entries.forEach(function (e) {
+      if (e.kind === 'subsystem' && isDeepId(e.id)) { deepByAnchor[anchorNodeId(e)] = e; any = true; }
+    });
+    if (!any) return null;
+    var entryByAnchor = {};
+    entries.forEach(function (e) { entryByAnchor[e.kind + ':' + e.id] = e; });
+    // A relation endpoint's DIRECT-line node in this view: the deepest leaf
+    // tile inside a deep-expanded entry, or a top-level component box ITSELF.
+    // null = this endpoint keeps aggregated/port semantics (interiors of
+    // non-deep entries, out-of-scope counterparts).
+    function directEnd(compId) {
+      var child = childOfScopeContaining(compId, scope);
+      var entry = child && entryByAnchor[child.kind + ':' + child.id];
+      if (!entry) return null;
+      var aid = anchorNodeId(entry);
+      if (deepByAnchor[aid]) {
+        var leaf = deepLeafFor(compId, entry.id);
+        return leaf ? { node: IN(leaf.kind, leaf.id), top: aid, deep: true } : null;
+      }
+      if (entry.kind === 'component' && entry.id === compId) return { node: aid, top: aid, deep: false };
+      return null;
+    }
+    var direct = {}, directTopCount = {}, ports = {};
+    function portRec(aid) { return ports[aid] = ports[aid] || { extIn: {}, extOut: {}, stubs: {} }; }
+    MODEL.edges.forEach(function (edge) {
+      var a = directEnd(edge.from), b = directEnd(edge.to);
+      if (a && b && (a.deep || b.deep) && a.node !== b.node) {
+        // Drawn as ONE direct line \u2014 never ALSO as ports/stubs (dedupe rule).
+        var key = a.node + '=>' + b.node;
+        if (!direct[key]) direct[key] = { src: a.node, tgt: b.node, cross: false, aTop: a.top, bTop: b.top };
+        if (edge.cross) direct[key].cross = true;
+        if (a.top !== b.top) {
+          var tk = a.top + '=>' + b.top;
+          directTopCount[tk] = (directTopCount[tk] || 0) + 1;
+        }
+        return;
+      }
+      // Not a direct line: keep today's port semantics on any deep box with
+      // exactly one endpoint inside its subtree, stubbed to the deepest leaf.
+      var ac = childOfScopeContaining(edge.from, scope);
+      var bc = childOfScopeContaining(edge.to, scope);
+      var aEnt = ac && entryByAnchor[ac.kind + ':' + ac.id];
+      var bEnt = bc && entryByAnchor[bc.kind + ':' + bc.id];
+      var aAid = aEnt ? anchorNodeId(aEnt) : null;
+      var bAid = bEnt ? anchorNodeId(bEnt) : null;
+      if (aAid === bAid) return; // internal to one entry, or neither in scope
+      if (aAid && deepByAnchor[aAid]) {
+        var leafA = deepLeafFor(edge.from, aEnt.id);
+        if (leafA) {
+          var recA = portRec(aAid);
+          var ro = recA.extOut[edge.to] = recA.extOut[edge.to] || { kids: {}, raws: {} };
+          ro.kids[leafA.kind + ':' + leafA.id] = leafA;
+          ro.raws[edge.from] = 1;
+          var poId = 'p~out~' + aAid + '~' + edge.to;
+          recA.stubs[IN(leafA.kind, leafA.id) + '=>' + poId] = { src: IN(leafA.kind, leafA.id), tgt: poId, stub: true };
+        }
+      }
+      if (bAid && deepByAnchor[bAid]) {
+        var leafB = deepLeafFor(edge.to, bEnt.id);
+        if (leafB) {
+          var recB = portRec(bAid);
+          var ri = recB.extIn[edge.from] = recB.extIn[edge.from] || { kids: {}, raws: {} };
+          ri.kids[leafB.kind + ':' + leafB.id] = leafB;
+          ri.raws[edge.to] = 1;
+          var piId = 'p~in~' + bAid + '~' + edge.from;
+          recB.stubs[piId + '=>' + IN(leafB.kind, leafB.id)] = { src: piId, tgt: IN(leafB.kind, leafB.id), stub: true };
+        }
+      }
+    });
+    return { deepByAnchor: deepByAnchor, direct: direct, directTopCount: directTopCount, ports: ports };
+  }
+
   // Micro-layout for a container's direct children when Internals is on:
   // layered mini columns + intra-container edges. Each external relation gets
   // its own small PORT node INSIDE the container (one per external
   // counterpart; incoming left, outgoing right). Children connect to ports
   // with short edges that never leave the box \u2014 the real cross-boundary line
   // is only revealed on hover, or pinned while the port is selected.
-  function innerLayout(entry) {
+  function innerLayout(entry, deepCtx) {
+    // Deep-flagged subsystems take the recursive path (deepCtx exists only
+    // when Internals is on and the view has deep entries \u2014 see buildElements).
+    if (deepCtx && entry.kind === 'subsystem' && deepCtx.deepByAnchor[anchorNodeId(entry)]) {
+      return deepLayout(entry, deepCtx.ports[anchorNodeId(entry)]);
+    }
     var kids = state.internals && entry.hasKids ? childrenOf({ kind: entry.kind, id: entry.id }) : [];
     if (!kids.length) return null;
     var scope = { kind: entry.kind, id: entry.id };
@@ -4219,12 +4565,42 @@ var MODEL = __MODEL_JSON__;
     if (scope.kind === 'types' || scope.kind === 'databases') return buildTypeElements();
     var entries = childrenOf(scope);
     var eles = [];
+    var deepCtx = buildDeepContext(scope, entries);
     var ve = viewEdges(scope, entries);
     // Data-coupling overlay: same scoping pipeline, a different edge source.
     var vd = state.dataCoupling ? viewEdges(scope, entries, MODEL.dataEdges) : { agg: {}, ghosts: {} };
     Object.keys(vd.ghosts).forEach(function (g) { if (!ve.ghosts[g]) ve.ghosts[g] = vd.ghosts[g]; });
     var inners = {};
-    entries.forEach(function (e) { inners[anchorNodeId(e)] = innerLayout(e); });
+    entries.forEach(function (e) { inners[anchorNodeId(e)] = innerLayout(e, deepCtx); });
+
+    // Deep-mode recursive tile emission: a nested container becomes a cytoscape
+    // compound parent (no explicit position \u2014 a compound derives its bounds
+    // from its children); leaves and EMPTY containers are plain positioned
+    // nodes. ox/oy = the emitting container's absolute top-left; tile.x/y are
+    // centres relative to it, so offsets accumulate top-down. Search dimming
+    // propagates the TOP entry's dim to the whole subtree.
+    function emitDeepTiles(tiles, parentNodeId, ox, oy, dimCls) {
+      tiles.forEach(function (tile) {
+        var ax = ox + tile.x, ay = oy + tile.y;
+        if (tile.sub) {
+          var nid = SN(tile.kid.id);
+          var selCls = state.selectedKind === 'subsystem' && state.selected === tile.kid.id ? ' sel' : '';
+          var nested = {
+            data: { id: nid, parent: parentNodeId, label: nameOf(tile.kid), w: tile.w, h: tile.h, tw: tile.w - 16 },
+            classes: 'subsysBox' + (tile.sub.tiles.length ? ' drillable' : '') + dimCls + selCls,
+          };
+          if (!tile.sub.tiles.length) nested.position = { x: ax, y: ay };
+          eles.push(nested);
+          emitDeepTiles(tile.sub.tiles, nid, ax - tile.w / 2, ay - tile.h / 2, dimCls);
+        } else {
+          eles.push({
+            data: { id: IN(tile.kid.kind, tile.kid.id), parent: parentNodeId, label: nameOf(tile.kid), w: INNER_W, h: INNER_H, tw: INNER_W - 10 },
+            position: { x: ax, y: ay },
+            classes: 'inner' + dimCls,
+          });
+        }
+      });
+    }
 
     // Resolve a port's reveal target(s) in THIS view. Preference order: the
     // MATCHING PORT inside the counterpart's container (a port-to-port line
@@ -4356,17 +4732,25 @@ var MODEL = __MODEL_JSON__;
         + (state.showIssues && issuesBySpec[e.id] ? ' hasIssue' : '')
         + (state.selectedKind === e.kind && state.selected === e.id ? ' sel' : '');
       if (inner) {
-        eles.push({ data: { id: aid, label: e.kind === 'subsystem' ? nameOf(e) : nameOf(e), w: p.w, h: p.h, tw: p.w - 16 }, classes: classes });
-        inner.tiles.forEach(function (tile) {
-          eles.push({
-            data: {
-              id: IN(tile.kid.kind, tile.kid.id), parent: aid,
-              label: nameOf(tile.kid), w: INNER_W, h: INNER_H, tw: INNER_W - 10,
-            },
-            position: { x: p.x - p.w / 2 + tile.x, y: p.y - p.h / 2 + tile.y },
-            classes: 'inner' + (dim ? ' dimmed' : ''),
+        var boxNode = { data: { id: aid, label: e.kind === 'subsystem' ? nameOf(e) : nameOf(e), w: p.w, h: p.h, tw: p.w - 16 }, classes: classes };
+        // An EMPTY deep boundary box has no children, so it is NOT a compound
+        // parent \u2014 it needs (and honours) an explicit position and size.
+        if (inner.deep && !inner.tiles.length && !(inner.proxies && inner.proxies.length)) boxNode.position = { x: p.x, y: p.y };
+        eles.push(boxNode);
+        if (inner.deep) {
+          emitDeepTiles(inner.tiles, aid, p.x - p.w / 2, p.y - p.h / 2, dim ? ' dimmed' : '');
+        } else {
+          inner.tiles.forEach(function (tile) {
+            eles.push({
+              data: {
+                id: IN(tile.kid.kind, tile.kid.id), parent: aid,
+                label: nameOf(tile.kid), w: INNER_W, h: INNER_H, tw: INNER_W - 10,
+              },
+              position: { x: p.x - p.w / 2 + tile.x, y: p.y - p.h / 2 + tile.y },
+              classes: 'inner' + (dim ? ' dimmed' : ''),
+            });
           });
-        });
+        }
         (inner.proxies || []).forEach(function (px) {
           eles.push({
             data: {
@@ -4519,9 +4903,28 @@ var MODEL = __MODEL_JSON__;
 
     var dimmedAnchors = {};
     entries.forEach(function (e) { if (state.query && !matches(e)) dimmedAnchors[anchorNodeId(e)] = true; });
+
+    // Deep mode: ONE direct line per related pair of concrete visible nodes \u2014
+    // leaf tiles at any depth and/or top-level component boxes (deduped by
+    // buildDeepContext). These lines cross nested boundaries on purpose.
+    if (deepCtx) {
+      var ddi = 0;
+      Object.keys(deepCtx.direct).sort().forEach(function (key) {
+        var d = deepCtx.direct[key];
+        var ddim = state.query && (dimmedAnchors[d.aTop] || dimmedAnchors[d.bTop]);
+        eles.push({
+          data: { id: 'dd' + (ddi++), source: d.src, target: d.tgt, lbl: '' },
+          classes: 'inneredge' + (d.cross ? ' cross' : '') + (ddim ? ' dimmed' : ''),
+        });
+      });
+    }
+
     var i = 0;
     Object.keys(ve.agg).forEach(function (key) {
       var e = ve.agg[key];
+      // Prefer the leaf lines: drop an aggregated container edge whose
+      // constituent relations were ALL drawn as direct deep lines above.
+      if (deepCtx && deepCtx.directTopCount[key] >= e.n) return;
       var bundle = e.n > 1;
       var dim = state.query && (dimmedAnchors[e.src] || dimmedAnchors[e.tgt]);
       var route = routeData(e.src, e.tgt, key);
@@ -4780,22 +5183,58 @@ var MODEL = __MODEL_JSON__;
     }
     return path;
   }
+  // Crumb compaction (compaction stage 5) is a RENDER MODE, not marker-based
+  // reparenting: renderCrumbs rebuilds #crumbs' innerHTML on every navigation,
+  // so nodes physically moved elsewhere would be destroyed by the next render.
+  // The header-compaction stage toggles crumbsCompact and re-renders; compact
+  // keeps the CURRENT scope visible and folds the ancestors into an ordered
+  // "\\u2026" dropdown (document order, root first) whose entries navigate
+  // exactly like the crumbs they replace.
+  var crumbsCompact = false;
+  var lastCrumbsHtml; // no initializer: the boot render at cy-init time precedes this line
+  // Set by the header-compaction IIFE: crumb re-renders change the header's
+  // CONTENT width without resizing #hdr itself (it is edge-anchored), so the
+  // ResizeObserver never fires for them \u2014 renderCrumbs nudges a reflow here.
+  var headerReflowHook = null;
+  function crumbBtnHtml(p, cur) {
+    return '<button class="crumb' + (cur ? ' cur' : '') + '" data-ck="' + p.kind + '" data-ci="' + (p.id || '') + '">' + p.label + '</button>';
+  }
   function renderCrumbs() {
     var el = document.getElementById('crumbs');
     var path = crumbPath();
-    el.innerHTML = path.map(function (p, i) {
-      var cur = i === path.length - 1;
-      return '<button class="crumb' + (cur ? ' cur' : '') + '" data-ck="' + p.kind + '" data-ci="' + (p.id || '') + '">' + p.label + '</button>'
-        + (cur ? '' : '<span class="sep">\\u203A</span>');
-    }).join('');
+    var html;
+    if (crumbsCompact && path.length > 1) {
+      html = '<span class="dropdown" id="crumbDd">'
+        + '<button class="crumb crumbmore" id="crumbMoreBtn" title="Show the collapsed ancestor path">\\u2026</button>'
+        + '<span class="menu" id="crumbMenu">'
+        + path.slice(0, path.length - 1).map(function (p) {
+          return '<button data-ck="' + p.kind + '" data-ci="' + (p.id || '') + '">' + p.label + '</button>';
+        }).join('')
+        + '</span></span>'
+        + '<span class="sep">\\u203A</span>'
+        + crumbBtnHtml(path[path.length - 1], true);
+    } else {
+      html = path.map(function (p, i) {
+        var cur = i === path.length - 1;
+        return crumbBtnHtml(p, cur) + (cur ? '' : '<span class="sep">\\u203A</span>');
+      }).join('');
+    }
+    // No-op renders keep the already-wired nodes (and an open "\\u2026" menu)
+    // intact \u2014 and don't churn the reflow scheduler while a search query types.
+    if (html === lastCrumbsHtml) return;
+    lastCrumbsHtml = html;
+    el.innerHTML = html;
     var btns = el.querySelectorAll('button');
     for (var i = 0; i < btns.length; i++) {
       (function (b) {
+        if (!b.getAttribute('data-ck')) return; // the "\\u2026" trigger toggles, never navigates
         b.addEventListener('click', function () {
           navigateTo(b.getAttribute('data-ck'), b.getAttribute('data-ci') || null);
         });
       })(btns[i]);
     }
+    if (crumbsCompact && path.length > 1) wireDropdown('crumbDd', 'crumbMoreBtn');
+    if (headerReflowHook) headerReflowHook();
   }
   function renderViewHint() {
     if (state.view.kind === 'types' || state.view.kind === 'databases') {
@@ -5062,7 +5501,16 @@ var MODEL = __MODEL_JSON__;
     return c ? { kind: 'subsystem', id: c.subsystem } : { kind: 'system', id: null };
   }
 
-  document.getElementById('search').addEventListener('input', function (ev) { state.query = ev.target.value.trim(); rebuild(false); });
+  // While the search input is compacted behind the magnifier icon (compaction
+  // stage 3), a non-empty query must stay discoverable \u2014 mark the icon with an
+  // accent dot. The class is kept in sync on every query edit; the dot is only
+  // ever visible while the compact icon itself is.
+  function updateSearchBadge() {
+    var b = document.getElementById('searchBtn');
+    if (b && b.classList) b.classList[state.query ? 'add' : 'remove']('hasq');
+  }
+  document.getElementById('search').addEventListener('input', function (ev) { state.query = ev.target.value.trim(); updateSearchBadge(); rebuild(false); });
+  updateSearchBadge();
   // Sync each View toggle's checkbox from the (possibly persisted) state, then
   // persist on change so the choices survive a refresh (see persist()/saved).
   document.getElementById('internalsToggle').checked = state.internals;
@@ -5116,9 +5564,24 @@ var MODEL = __MODEL_JSON__;
       })(btns[i]);
     }
   })();
+  // Compaction stage 4 replaces the mode tabs with one dropdown trigger; its
+  // label must follow the CURRENT mode. updateHeaderSegs runs on every rebuild,
+  // so a mode change made while compact re-labels the trigger immediately.
+  function updateModeBtn() {
+    var b = document.getElementById('modeBtn');
+    if (!b) return;
+    var lbl = state.view.kind === 'types' ? 'Types' : state.view.kind === 'databases' ? 'Databases' : 'Components';
+    b.textContent = lbl + ' \\u25BE';
+  }
   function updateHeaderSegs() {
     var seg = document.getElementById('modeSeg');
     var btns = seg.querySelectorAll('button');
+    if (!btns.length) {
+      // Compaction stage 4 moved the real tab buttons into the mode dropdown \u2014
+      // keep driving THEIR active classes there (they move back node-identical).
+      var mm = document.getElementById('modeMenu');
+      if (mm && mm.querySelectorAll) btns = mm.querySelectorAll('button');
+    }
     for (var i = 0; i < btns.length; i++) {
       var vm = btns[i].getAttribute('data-vm');
       var active = vm === 'components'
@@ -5126,6 +5589,7 @@ var MODEL = __MODEL_JSON__;
         : vm === state.view.kind;
       if (btns[i].classList) btns[i].classList[active ? 'add' : 'remove']('active');
     }
+    updateModeBtn();
     var td = document.getElementById('typesDetailSeg');
     td.style.display = (state.view.kind === 'types' || state.view.kind === 'databases') ? '' : 'none';
     var tbs = td.querySelectorAll('button');
@@ -5189,7 +5653,13 @@ var MODEL = __MODEL_JSON__;
     var r = btn.getBoundingClientRect();
     menu.style.top = (r.bottom + 6) + 'px';
     menu.style.left = 'auto';
-    menu.style.right = Math.max(6, window.innerWidth - r.right) + 'px';
+    // Right-aligned to the trigger, but never pushed off the LEFT edge \u2014 the
+    // compact search / crumb triggers (header compaction) sit on the header's
+    // left side, where a 200px menu right-aligned to a narrow button would clip.
+    var right = Math.max(6, window.innerWidth - r.right);
+    var mw = menu.getBoundingClientRect ? menu.getBoundingClientRect().width : 0;
+    if (mw && window.innerWidth - right - mw < 6) right = Math.max(6, window.innerWidth - mw - 6);
+    menu.style.right = right + 'px';
   }
   function wireDropdown(ddId, btnId) {
     var dd = document.getElementById(ddId);
@@ -5208,11 +5678,29 @@ var MODEL = __MODEL_JSON__;
   var ldd = wireDropdown('layoutDd', 'layoutBtn');
   var sdd = wireDropdown('settingsDd', 'settingsBtn');
   var mdd = wireDropdown('moreDd', 'moreBtn');
+  // Compact stand-ins (header compaction stages 3-4): the search panel and the
+  // mode-tab dropdown are ordinary dropdowns; their triggers stay hidden until
+  // their compaction stage shows them, so wiring them here is inert at full width.
+  var qdd = wireDropdown('searchDd', 'searchBtn');
+  var vdd = wireDropdown('modeDd', 'modeBtn');
+  // Opening the compact search panel focuses the REAL input (stage 3 moves the
+  // node, never clones it, so its input listener keeps driving state.query).
+  // Registered after wireDropdown's toggle, so 'open' reflects the new state.
+  document.getElementById('searchBtn').addEventListener('click', function () {
+    if (String(qdd.className || '').indexOf('open') >= 0) {
+      var inp = document.getElementById('search');
+      if (inp && inp.focus) inp.focus();
+    }
+  });
   // Keep the settings panel open while flipping switches (clicks inside it don't
   // bubble to the document-level close handler).
   (function () {
     var m = document.getElementById('settingsMenu');
     if (m && m.addEventListener) m.addEventListener('click', function (ev) { if (ev && ev.stopPropagation) ev.stopPropagation(); });
+    // Same for the floating search panel: clicking into the input must not
+    // bubble to the document-level close handler and shut the panel mid-typing.
+    var sm = document.getElementById('searchMenu');
+    if (sm && sm.addEventListener) sm.addEventListener('click', function (ev) { if (ev && ev.stopPropagation) ev.stopPropagation(); });
   })();
 
   // Layout picker: choose the auto-layout algorithm. Components use cytoscape's
@@ -5236,6 +5724,12 @@ var MODEL = __MODEL_JSON__;
   });
   updateLayoutBtn();
 
+  // The compact crumb dropdown (compaction stage 5) is re-created by every
+  // compact crumb render, so it is looked up per close instead of captured.
+  function closeCrumbDd() {
+    var cdd = document.getElementById('crumbDd');
+    if (cdd && cdd.classList) cdd.classList.remove('open');
+  }
   if (document.addEventListener) {
     document.addEventListener('click', function () {
       if (dd.classList) dd.classList.remove('open');
@@ -5243,6 +5737,9 @@ var MODEL = __MODEL_JSON__;
       if (ldd.classList) ldd.classList.remove('open');
       if (sdd.classList) sdd.classList.remove('open');
       if (mdd && mdd.classList) mdd.classList.remove('open');
+      if (qdd && qdd.classList) qdd.classList.remove('open');
+      if (vdd && vdd.classList) vdd.classList.remove('open');
+      closeCrumbDd();
     });
     document.addEventListener('keydown', function (ev) {
       if (ev.key === 'Escape') {
@@ -5250,16 +5747,27 @@ var MODEL = __MODEL_JSON__;
         if (modal.classList && String(modal.className).indexOf('open') >= 0) { closeFlow(); return; }
         setPresentation(false);
         if (dd.classList) dd.classList.remove('open');
+        if (qdd && qdd.classList) qdd.classList.remove('open');
+        if (vdd && vdd.classList) vdd.classList.remove('open');
+        closeCrumbDd();
       }
     });
   }
 
-  // \u2500\u2500 Responsive header overflow \u2192 "\u22EF" dropdown \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-  // When the floating header no longer fits its controls, trailing items
-  // COLLAPSE into the More menu instead of relying on horizontal scroll \u2014
-  // every control stays one click away. Whole items move (listeners survive
-  // reparenting); a hidden placeholder pins each item's original position so
-  // restoring keeps the exact order. Collapse order = least-used first.
+  // \u2500\u2500 Responsive header compaction \u2192 ordered stages \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // When the floating header no longer fits its controls, standard reusable
+  // COMPACTION BEHAVIORS apply progressively \u2014 each stage only while the row
+  // still overflows \u2014 and restore in REVERSE order when space returns:
+  //   1. trailing buttons fold into the "\u22EF" menu (least-used first, one by one)
+  //   2. the View dropdown folds in after them
+  //   3. the search input compacts to a \u{1F50D} icon + floating panel
+  //   4. the mode tabs compact to one current-mode dropdown
+  //   5. ancestor crumbs compact into an ordered "\u2026" dropdown
+  // Stages 1-2 move whole items (listeners survive reparenting) with a hidden
+  // placeholder pinning each item's original spot for restore; stage 5 is a
+  // render mode (renderCrumbs rebuilds its innerHTML, so reparenting would not
+  // survive navigation). Nothing here is persisted \u2014 compaction is purely
+  // responsive to the available width.
   (function () {
     if (typeof window === 'undefined') return;
     var hdr = document.getElementById('hdr');
@@ -5287,7 +5795,122 @@ var MODEL = __MODEL_JSON__;
       }
       return markers[id];
     }
-    var collapsed = [];
+    // Fold stage (the classic behavior): move items into the "\u22EF" menu ONE per
+    // apply() call \u2014 the reflow loop keeps a stage active until it reports no
+    // further progress, preserving the original per-button granularity.
+    function foldStage(ids) {
+      var folded = [];
+      return {
+        apply: function () {
+          while (folded.length < ids.length) {
+            var id = ids[folded.length];
+            var el = movableFor(id);
+            if (!el || el === moreDd || el.parentNode === moreMenu) { folded.push({ el: null, marker: null }); continue; }
+            var m = markerFor(id, el);
+            // A dropdown moved while open would strand its fixed-positioned menu.
+            if (el.classList) el.classList.remove('open');
+            moreDd.style.display = '';
+            moreMenu.appendChild(el);
+            folded.push({ el: el, marker: m });
+            return true;
+          }
+          return false;
+        },
+        restore: function () {
+          for (var i = folded.length - 1; i >= 0; i--) {
+            var it = folded[i];
+            if (it.el && it.marker && it.marker.parentNode) it.marker.parentNode.insertBefore(it.el, it.marker);
+          }
+          folded = [];
+        },
+      };
+    }
+    // Stage 3: the search input compacts behind a \u{1F50D} icon; the REAL input node
+    // MOVES into the floating panel (fixed-positioned by the same helper as
+    // every dropdown menu), so its input listener keeps driving state.query.
+    function searchStage() {
+      var on = false;
+      return {
+        apply: function () {
+          if (on) return false;
+          var inp = document.getElementById('search');
+          var ddw = document.getElementById('searchDd');
+          var menu = document.getElementById('searchMenu');
+          if (!inp || !ddw || !menu) return false;
+          menu.appendChild(inp);
+          ddw.style.display = '';
+          on = true;
+          return true;
+        },
+        restore: function () {
+          if (!on) return;
+          on = false;
+          var inp = document.getElementById('search');
+          var ddw = document.getElementById('searchDd');
+          if (inp && ddw && ddw.parentNode) ddw.parentNode.insertBefore(inp, ddw);
+          if (ddw) { ddw.style.display = 'none'; if (ddw.classList) ddw.classList.remove('open'); }
+        },
+      };
+    }
+    // Stage 4: the mode tabs collapse into ONE dropdown labelled with the
+    // current mode. The REAL tab buttons move into its menu (listeners and
+    // active styling survive); updateHeaderSegs keeps the trigger label in
+    // sync when the mode changes while compact.
+    function modeStage() {
+      var moved = [];
+      return {
+        apply: function () {
+          if (moved.length) return false;
+          var seg = document.getElementById('modeSeg');
+          var ddw = document.getElementById('modeDd');
+          var menu = document.getElementById('modeMenu');
+          if (!seg || !ddw || !menu) return false;
+          var btns = seg.querySelectorAll('button');
+          if (!btns.length) return false;
+          for (var i = 0; i < btns.length; i++) moved.push(btns[i]);
+          for (var j = 0; j < moved.length; j++) menu.appendChild(moved[j]);
+          seg.style.display = 'none';
+          ddw.style.display = '';
+          updateModeBtn();
+          return true;
+        },
+        restore: function () {
+          if (!moved.length) return;
+          var seg = document.getElementById('modeSeg');
+          var ddw = document.getElementById('modeDd');
+          for (var i = 0; i < moved.length; i++) seg.appendChild(moved[i]);
+          moved = [];
+          seg.style.display = '';
+          if (ddw) { ddw.style.display = 'none'; if (ddw.classList) ddw.classList.remove('open'); }
+        },
+      };
+    }
+    // Stage 5: crumb compaction is a render-mode toggle consulted by
+    // renderCrumbs itself \u2014 see crumbsCompact there. Never reparenting.
+    function crumbStage() {
+      return {
+        apply: function () {
+          if (crumbsCompact) return false;
+          crumbsCompact = true;
+          renderCrumbs();
+          return true;
+        },
+        restore: function () {
+          if (!crumbsCompact) return;
+          crumbsCompact = false;
+          renderCrumbs();
+        },
+      };
+    }
+    // Ordered compaction stages: applied first-to-last only while the header
+    // overflows, restored last-to-first when space returns.
+    var STAGES = [
+      foldStage(COLLAPSE),        // 1: trailing buttons \u2192 "\u22EF" menu
+      foldStage(['settingsBtn']), // 2: the View dropdown folds in too
+      searchStage(),              // 3: search input \u2192 \u{1F50D} + floating panel
+      modeStage(),                // 4: mode tabs \u2192 current-mode dropdown
+      crumbStage(),               // 5: ancestor crumbs \u2192 "\u2026" dropdown
+    ];
     // Signed fit measure in px: positive = overflowing, negative = headroom.
     // The header is a flex row whose ONLY flex:1 child is the .spacer, so the
     // spacer's rendered width IS the free space -- it grows to absorb all slack
@@ -5303,33 +5926,54 @@ var MODEL = __MODEL_JSON__;
       var slack = spacer ? spacer.getBoundingClientRect().width : 0;
       return (hdr.scrollWidth - hdr.clientWidth) - slack;
     }
+    var inReflow = false;
     function reflow() {
       // Not laid out (hidden tab, non-browser DOM) \u2014 measuring would misfire.
       var box = hdr.getBoundingClientRect();
       if (!box || box.width <= 0) return;
-      // Restore everything, then collapse until the row fits (idempotent).
-      for (var i = collapsed.length - 1; i >= 0; i--) {
-        var it = collapsed[i];
-        if (it.el && it.marker && it.marker.parentNode) it.marker.parentNode.insertBefore(it.el, it.marker);
-      }
-      collapsed = [];
-      moreDd.style.display = 'none';
-      hdr.scrollLeft = 0;
-      var guard = 0;
-      // Demand a few px of headroom, not a bare fit \u2014 the marginal-fit widths
-      // are exactly where the phantom scrollbar appeared.
-      while (overflowPx() > -8 && guard < COLLAPSE.length) {
-        var id = COLLAPSE[guard++];
-        var el = movableFor(id);
-        if (!el || el === moreDd || el.parentNode === moreMenu) continue;
-        var m = markerFor(id, el);
-        // A dropdown moved while open would strand its fixed-positioned menu.
-        if (el.classList) el.classList.remove('open');
-        moreDd.style.display = '';
-        moreMenu.appendChild(el);
-        collapsed.push({ el: el, marker: m });
-      }
-      if (collapsed.length === 0) moreDd.style.display = 'none';
+      inReflow = true;
+      try {
+        // The floating search panel must survive a reflow cycle: restore-all
+        // would close it (and reparenting blurs the input), so capture its
+        // open/focus state up front and reinstate it after the stage walk.
+        var ddw = document.getElementById('searchDd');
+        var inp = document.getElementById('search');
+        var searchOpen = !!(ddw && String(ddw.className || '').indexOf('open') >= 0);
+        var searchFocus = false;
+        try {
+          var ae = (typeof ROOT !== 'undefined' && ROOT ? ROOT : document).activeElement;
+          searchFocus = !!(ae && inp && ae === inp);
+        } catch (e) { /* stubbed DOM */ }
+        // Restore every stage in REVERSE order, then re-apply progressively
+        // while the row still overflows (idempotent).
+        for (var i = STAGES.length - 1; i >= 0; i--) STAGES[i].restore();
+        moreDd.style.display = 'none';
+        hdr.scrollLeft = 0;
+        // Demand a few px of headroom, not a bare fit \u2014 the marginal-fit widths
+        // are exactly where the phantom scrollbar appeared. Every apply()
+        // changes the very widths being measured, but restore-all + a strictly
+        // forward stage walk make the outcome a pure function of the current
+        // width, and reflow never reschedules itself (renderCrumbs' nudge is
+        // suppressed via inReflow, and #hdr's own box never changes here), so
+        // boundary widths settle in ONE pass instead of oscillating.
+        var si = 0;
+        var guard = 0;
+        var bound = COLLAPSE.length + STAGES.length + 8;
+        while (overflowPx() > -8 && si < STAGES.length && guard < bound) {
+          guard++;
+          if (!STAGES[si].apply()) si++;
+        }
+        if (searchOpen || searchFocus) {
+          var compactNow = ddw && ddw.style && ddw.style.display !== 'none';
+          if (compactNow && searchOpen) {
+            if (ddw.classList) ddw.classList.add('open');
+            positionDropdownMenu(ddw, document.getElementById('searchBtn'));
+          }
+          if (searchFocus && inp && inp.focus) inp.focus();
+        }
+      } finally {
+        inReflow = false;
+      }
     }
     var raf = null;
     var defer = window.requestAnimationFrame
@@ -5339,6 +5983,9 @@ var MODEL = __MODEL_JSON__;
       if (raf !== null) return;
       raf = defer(function () { raf = null; reflow(); });
     }
+    // Crumb re-renders change the header's content width without resizing #hdr
+    // itself \u2014 renderCrumbs nudges a reflow through this hook (no-op mid-reflow).
+    headerReflowHook = function () { if (!inReflow) schedule(); };
     if (typeof ResizeObserver !== 'undefined') {
       new ResizeObserver(schedule).observe(hdr);
     } else if (window.addEventListener) {
@@ -6869,47 +7516,6 @@ var init_filenames = __esm({
   }
 });
 
-// src/core/statehash.ts
-function computeStateId() {
-  const tree = {
-    system: loadSystemSpec(),
-    subsystems: loadSubsystemSpecs(),
-    components: loadComponentSpecs(),
-    interfaces: loadInterfaceSpecs(),
-    implementations: loadImplementationSpecs(),
-    types: loadTypeSpecs()
-  };
-  const digest = crypto.createHash("sha256").update(canonicalize(tree)).digest("hex");
-  return { algorithm: "sha256", digest };
-}
-function stateIdEquals(a, b) {
-  return !!a && !!b && a.algorithm === b.algorithm && a.digest === b.digest;
-}
-function canonicalize(value) {
-  return JSON.stringify(sortKeys(value));
-}
-function sortKeys(v) {
-  if (Array.isArray(v)) return v.map(sortKeys);
-  if (v && typeof v === "object") {
-    const src = v;
-    const out = {};
-    for (const k of Object.keys(src).sort()) {
-      if (k === "createdAt" || k === "updatedAt") continue;
-      out[k] = sortKeys(src[k]);
-    }
-    return out;
-  }
-  return v;
-}
-var crypto;
-var init_statehash = __esm({
-  "src/core/statehash.ts"() {
-    "use strict";
-    crypto = __toESM(require("crypto"));
-    init_specs2();
-  }
-});
-
 // src/core/openapi.ts
 function schemaFor(typeRef, closureIds) {
   const trimmed = typeRef.trim().replace(/^promise\s*<(.+)>$/i, "$1").trim();
@@ -7363,6 +7969,57 @@ function projectOwnSurface(maxAudience) {
 function projectChildSurface() {
   return projectOwnSurface("project");
 }
+function localName(id) {
+  return id.split("::").pop();
+}
+function projectSubsystemSurface(subsystemId) {
+  const system = loadSystemSpec();
+  if (!system) {
+    throw new Error("Cannot project a subsystem surface: the L0 system spec is missing.");
+  }
+  const subsystems = loadSubsystemSpecs();
+  const target = subsystems.find((s) => s.id === subsystemId);
+  if (!target) {
+    throw new Error(`Cannot project a subsystem surface: subsystem "${subsystemId}" does not exist.`);
+  }
+  const components = loadComponentSpecs();
+  const interfaces = loadInterfaceSpecs();
+  const types = loadTypeSpecs();
+  const entries = [];
+  for (const pub of target.publicInterfaces ?? []) {
+    if (!pub.component) continue;
+    const comp = components.find((c) => c.id === pub.component || c.id === `${subsystemId}::${pub.component}`);
+    if (!comp) continue;
+    if (comp.componentType !== "Portal") continue;
+    const compInterfaces = interfaces.filter((i) => i.component === comp.id && (!pub.interface || i.id === pub.interface || i.id === `${subsystemId}::${pub.interface}`));
+    const methods = compInterfaces.flatMap((i) => i.methods);
+    entries.push({
+      id: localName(pub.interface ?? comp.id),
+      name: comp.name,
+      // Family ceiling: a sibling surface is consumable by the system family only.
+      audience: "project",
+      type: pub.type ?? "Custom",
+      // The snapshot carries the LOCAL portal name — consumers resolve cross-tree
+      // refs by their final segment.
+      component: localName(comp.id),
+      methods,
+      ...comp.dispatch && comp.dispatch.length ? { dispatch: comp.dispatch } : {},
+      // Project the backing Portal's auth + basePath so the codec can emit
+      // OpenAPI security + per-portal servers self-contained from the snapshot.
+      ...comp.auth && comp.auth.scheme !== "none" ? { auth: comp.auth } : {},
+      ...comp.basePath ? { basePath: comp.basePath } : {},
+      details: pub.details ?? ""
+    });
+  }
+  return SurfaceSnapshotSchema.parse({
+    projectName: `${system.name}::${subsystemId}`,
+    origin: "generated",
+    stateId: stateIdString(),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    interfaces: entries,
+    types: computeTypeClosure(entries, types)
+  });
+}
 function listSnapshots(rootDir = getProjectRoot()) {
   const dir = surfacesDir(rootDir);
   if (!fs9.existsSync(dir)) return [];
@@ -7379,10 +8036,13 @@ function listSnapshots(rootDir = getProjectRoot()) {
 function getSnapshot(projectName, rootDir = getProjectRoot()) {
   return listSnapshots(rootDir).find((s) => s.projectName === projectName) ?? null;
 }
+function snapshotFilename(projectName) {
+  return `${safeFilenamePart(projectName)}.yaml`;
+}
 function saveSnapshot(snapshot, rootDir = getProjectRoot()) {
   const dir = surfacesDir(rootDir);
   fs9.mkdirSync(dir, { recursive: true });
-  const p = path10.join(dir, `${snapshot.projectName}.yaml`);
+  const p = path10.join(dir, snapshotFilename(snapshot.projectName));
   writeYamlFile(p, SurfaceSnapshotSchema.parse(snapshot));
   return p;
 }
@@ -7455,17 +8115,54 @@ function importSurface(sourcePath, origin) {
   return snapshot;
 }
 function generateChildSnapshots(rootDir = getProjectRoot()) {
-  const children = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::"));
+  const topLevel = loadSubsystemSpecs().filter((s) => !s.id.includes("::"));
+  const children = topLevel.filter((s) => s.projectPath);
   if (!children.length) return [];
-  const snapshot = projectChildSurface();
+  const familySnapshot = projectChildSurface();
+  const siblingSnapshots = /* @__PURE__ */ new Map();
+  const siblingSurface = (subsystemId) => {
+    let snap = siblingSnapshots.get(subsystemId);
+    if (!snap) {
+      snap = projectSubsystemSurface(subsystemId);
+      siblingSnapshots.set(subsystemId, snap);
+    }
+    return snap;
+  };
   const written = [];
   for (const child of children) {
     const childDir = path10.resolve(rootDir, child.projectPath);
     if (!fs9.existsSync(childDir)) continue;
-    written.push(saveSnapshot(snapshot, childDir));
+    written.push(saveSnapshot(familySnapshot, childDir));
+    for (const sibling of topLevel) {
+      if (sibling.id === child.id) continue;
+      written.push(saveSnapshot(siblingSurface(sibling.id), childDir));
+    }
   }
   return written;
 }
+function computeParentStateId(parentRoot) {
+  return computeStateIdAt(parentRoot);
+}
+function listExternalInterfaces() {
+  const snapshots = listSnapshots();
+  const chainingParent = resolveChainingParent();
+  const parentStateId = chainingParent ? computeParentStateId(chainingParent.parentRoot) : 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";
+    return {
+      projectName: snapshot.projectName,
+      origin: snapshot.origin,
+      sourceKind,
+      generatedAt: snapshot.generatedAt,
+      ...snapshot.stateId ? { stateId: snapshot.stateId } : {},
+      ...snapshot.version ? { version: snapshot.version } : {},
+      freshness,
+      interfaceIds: snapshot.interfaces.map((e) => e.id)
+    };
+  });
+}
 function surfaceContentKey(snapshot) {
   const { stateId, generatedAt, origin, ...content } = snapshot;
   return JSON.stringify(content);
@@ -7674,7 +8371,8 @@ var init_contracts = __esm({
                           "SURFACE_REF_NOT_EXPOSED",
                           `Method "${implMethod.name}" in implementation "${impl.id}" dispatches capability "${step.capability}" through cross-tree portal "${step.targetComponent}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not serve that capability on "${resolved.entry.id}".`,
                           impl.id,
-                          isDraftCtx
+                          isDraftCtx,
+                          true
                         );
                       }
                       continue;
@@ -7731,7 +8429,8 @@ var init_contracts = __esm({
                         "SURFACE_REF_NOT_EXPOSED",
                         `Method "${implMethod.name}" in implementation "${impl.id}" calls "${step.targetMethod}" on cross-tree component "${step.targetComponent}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not expose that method on "${resolved.entry.id}".`,
                         impl.id,
-                        isDraftCtx
+                        isDraftCtx,
+                        true
                       );
                     } else if (step.assertsGuarantees) {
                       const declared = new Set(surfaceMethod.guarantees ?? []);
@@ -7742,7 +8441,8 @@ var init_contracts = __esm({
                             "NARRATIVE_SEMANTIC_UNBACKED",
                             `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" asserts guarantee "${g}", but the surface snapshot of "${resolved.snapshot.projectName}" does not declare it on "${resolved.entry.id}.${step.targetMethod}".`,
                             impl.id,
-                            isDraftCtx
+                            isDraftCtx,
+                            true
                           );
                         }
                       }
@@ -9230,7 +9930,8 @@ var init_stereotype_deps = __esm({
                       "CROSS_SUBSYSTEM_NON_ADAPTER",
                       `Boundary violation: ${comp.componentType} "${comp.id}" depends directly on "${depId}", a surface of project "${resolved.snapshot.projectName}". Only a local client Adapter may cross a project boundary \u2014 route this hop through an Adapter.`,
                       comp.id,
-                      isDraftCtx
+                      isDraftCtx,
+                      true
                     );
                   }
                   continue;
@@ -11093,11 +11794,11 @@ var init_narrative_antipatterns = __esm({
           const memberEdges = keys.flatMap((k) => (adjacency.get(k) ?? []).filter((e) => inScc.has(e.toKey)));
           if (memberEdges.length === 0) continue;
           const anchor = [...memberEdges].sort((a, b) => a.fromKey.localeCompare(b.fromKey))[0];
-          const path62 = [...keys].sort().join(" \u2192 ");
+          const path61 = [...keys].sort().join(" \u2192 ");
           ctx.addIssue(
             "warning",
             "UNCONDITIONAL_CALL_CYCLE",
-            `Call cycle with no guard: ${path62} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
+            `Call cycle with no guard: ${path61} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
             anchor.impl.id,
             memberEdges.some((e) => ctx.isImplementationDraft(e.impl))
           );
@@ -12484,9 +13185,15 @@ function buildRuleContext(opts) {
     ...[...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.
-    ...extensions.assertions.map((a) => a.fullCode)
+    ...extensions.assertions.map((a) => a.fullCode),
+    // Entry-point emitted codes: validateSddTree's chained-subproject pass
+    // raises these AFTER the rule run (it post-processes the aggregated issue
+    // list), so no registered rule declares them — but lint.allow validation
+    // must still recognize them as real codes.
+    "CHAINED_SUBPROJECT_CONTEXT",
+    "UNVERIFIED_EXTERNAL_REF"
   ]);
-  const addIssue = (defaultSeverity, code, message, specId, isDraftContext) => {
+  const addIssue = (defaultSeverity, code, message, specId, isDraftContext, surfaceResolved) => {
     if (scopeSubsystem && specId && !isSpecInScope(specId)) {
       return;
     }
@@ -12504,7 +13211,14 @@ function buildRuleContext(opts) {
         if (severity === "warning") return;
       }
     }
-    issues.push({ severity, code, message, specId, ...isDraftContext ? { draftContext: true } : {} });
+    issues.push({
+      severity,
+      code,
+      message,
+      specId,
+      ...isDraftContext ? { draftContext: true } : {},
+      ...surfaceResolved ? { surfaceResolved: true } : {}
+    });
   };
   return {
     system,
@@ -12929,24 +13643,54 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
     for (const rule of ruleSequence()) {
       rule.check(ctx);
     }
-    const hasCrossTreeSuspects = issues.some((i) => SUBPROJECT_LENIENT_CODES.has(i.code));
+    const hasCrossTreeSuspects = issues.some(
+      (i) => SUBPROJECT_REFERENCE_CODES.has(i.code) || SUBPROJECT_CONFORMANCE_CODES.has(i.code)
+    );
     const chainingParent = hasCrossTreeSuspects ? findChainingParent(getProjectRoot()) : null;
     if (chainingParent) {
+      let unverified = 0;
       let downgraded = 0;
-      for (const iss of issues) {
-        if (!SUBPROJECT_LENIENT_CODES.has(iss.code)) continue;
-        if (iss.severity === "error") {
-          iss.severity = "warning";
-          downgraded++;
+      for (let at = 0; at < issues.length; at++) {
+        const iss = issues[at];
+        if (SUBPROJECT_REFERENCE_CODES.has(iss.code) && !iss.surfaceResolved) {
+          issues[at] = {
+            severity: "warning",
+            code: "UNVERIFIED_EXTERNAL_REF",
+            crossTreeContext: true,
+            // --ci waives it (parent root is authoritative)
+            specId: iss.specId,
+            ...iss.agentId ? { agentId: iss.agentId } : {},
+            ...iss.draftContext ? { draftContext: true } : {},
+            message: `Unverified external reference (${iss.code}): ${iss.message} No vendored surface snapshot covers this reference, so it cannot be verified from this chained subproject standalone \u2014 re-lock the parent so fresh family/sibling snapshots ship, or inspect what this project can consume via \`wairon surface externals\` / sdd_list_external_interfaces.`
+          };
+          unverified++;
+          continue;
+        }
+        if (SUBPROJECT_CONFORMANCE_CODES.has(iss.code)) {
+          if (iss.severity === "error") {
+            iss.severity = "warning";
+            downgraded++;
+          }
+          iss.crossTreeContext = true;
         }
-        iss.crossTreeContext = true;
       }
-      if (downgraded > 0) {
+      if (unverified > 0 || downgraded > 0) {
+        const notes = [];
+        if (unverified > 0) {
+          notes.push(
+            `${unverified} cross-tree reference(s) have no vendored surface snapshot covering them and were reported as UNVERIFIED_EXTERNAL_REF warnings \u2014 re-lock the parent so fresh family/sibling snapshots ship, or inspect via \`wairon surface externals\` / sdd_list_external_interfaces.`
+          );
+        }
+        if (downgraded > 0) {
+          notes.push(
+            `${downgraded} code\u2194spec conformance finding(s) (parent-root-relative source paths) were downgraded to warnings.`
+          );
+        }
         issues.unshift({
           severity: "warning",
           code: "CHAINED_SUBPROJECT_CONTEXT",
           crossTreeContext: true,
-          message: `This project is a chained subproject ("${chainingParent.subsystemId}") of the parent project at "${chainingParent.parentRoot}". ${downgraded} reference(s) resolve only in the parent tree (shared types, sibling subsystems, or cross-tree components that live above this root) and were downgraded to warnings \u2014 validating a subproject standalone cannot verify them. Run validation from the parent root for full cross-tree verification.`
+          message: `This project is a chained subproject ("${chainingParent.subsystemId}") of the parent project at "${chainingParent.parentRoot}". ${notes.join(" ")} Full cross-tree verification runs from the parent root.`
         });
       }
     }
@@ -12963,7 +13707,7 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
 function validateAsComplete(options) {
   return validateSddTree({ ...options ?? {}, treatAllAsComplete: true });
 }
-var SUBPROJECT_LENIENT_CODES;
+var SUBPROJECT_REFERENCE_CODES, SUBPROJECT_CONFORMANCE_CODES;
 var init_validation = __esm({
   "src/core/validation.ts"() {
     "use strict";
@@ -12976,8 +13720,7 @@ var init_validation = __esm({
     init_source_analysis();
     init_specs2();
     init_fs();
-    SUBPROJECT_LENIENT_CODES = /* @__PURE__ */ new Set([
-      // reference resolution
+    SUBPROJECT_REFERENCE_CODES = /* @__PURE__ */ new Set([
       "UNDEFINED_TYPE_REFERENCE",
       "INVALID_DEPENDENCY_REFERENCE",
       "INVALID_TARGET_COMPONENT_REFERENCE",
@@ -12985,8 +13728,9 @@ var init_validation = __esm({
       "UNDECLARED_DEPENDENCY_CALL",
       "INVALID_TRUSTED_LINK",
       "CROSS_SUBSYSTEM_NON_ADAPTER",
-      "CROSS_TREE_REF_UNRESOLVED",
-      // code↔spec conformance (root-relative sourcePaths / import graph)
+      "CROSS_TREE_REF_UNRESOLVED"
+    ]);
+    SUBPROJECT_CONFORMANCE_CODES = /* @__PURE__ */ new Set([
       "MISSING_SOURCE_FILE",
       "SOURCE_PATH_ESCAPES_ROOT",
       "MISSING_SOURCE_PATH",
@@ -13528,6 +14272,7 @@ __export(specs_exports, {
   buildProjectGraph: () => buildProjectGraph,
   clearLoaderIssues: () => clearLoaderIssues,
   collectPromotableSpecs: () => collectPromotableSpecs,
+  computeStateIdAt: () => computeStateIdAt,
   deleteComponentSpec: () => deleteComponentSpec,
   deleteGroupSpec: () => deleteGroupSpec,
   deleteImplementationSpec: () => deleteImplementationSpec,
@@ -13560,6 +14305,7 @@ __export(specs_exports, {
   loadTypeSpec: () => loadTypeSpec,
   loadTypeSpecs: () => loadTypeSpecs,
   normalizeComponentLayout: () => normalizeComponentLayout,
+  resolveChainingParent: () => resolveChainingParent,
   resolveSubprojectForNamespace: () => resolveSubprojectForNamespace,
   restoreSpecFiles: () => restoreSpecFiles,
   saveComponentSpec: () => saveComponentSpec,
@@ -13964,6 +14710,19 @@ function dryRunSerializeSpecs(include) {
 function buildProjectGraph(level) {
   return buildGraphModel(level);
 }
+function resolveChainingParent() {
+  return findChainingParent(getProjectRoot());
+}
+function computeStateIdAt(root) {
+  const resolved = path14.resolve(root);
+  return runWithProjectRoot(resolved, () => {
+    workspaceFor(resolved).invalidate();
+    const system = loadSystemSpec();
+    if (!system) return null;
+    const s = computeStateId();
+    return `${s.algorithm}:${s.digest}`;
+  });
+}
 function deleteTypeSpec(id) {
   return current().deleteTypeSpec(id);
 }
@@ -14007,6 +14766,7 @@ var init_specs2 = __esm({
     path14 = __toESM(require("path"));
     init_loader();
     init_fs();
+    init_statehash();
     init_yaml();
     init_models();
     init_narrative_labels();
@@ -16600,6 +17360,9 @@ function requireSpecs() {
 function requireProvision() {
   return init_provision(), __toCommonJS(provision_exports);
 }
+function listExternalInterfaces2() {
+  return listExternalInterfaces();
+}
 function text(content) {
   return { content: [{ type: "text", text: content }] };
 }
@@ -17566,7 +18329,36 @@ NOTICE:
       }
     }
   );
+  reg(
+    server,
+    "sdd_list_external_interfaces",
+    {
+      description: "List the bound project's consumable external surfaces (parent family, siblings, foreign imports) as discovery entries with origin, provenance, and freshness \u2014 the tool an agent inside a subproject uses to SEE its outward world instead of discovering it by failed reference resolution. Full contracts stay in the vendored snapshots (.wai/surfaces/); each entry summarizes the interface ids it exposes."
+    },
+    () => {
+      try {
+        return json(listExternalInterfaces2());
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
   registerSkillResources(server);
+  try {
+    const chainingParent = resolveChainingParent();
+    if (chainingParent) {
+      let externalSurfaceCount = 0;
+      try {
+        externalSurfaceCount = listExternalInterfaces2().length;
+      } catch {
+      }
+      process.stderr.write(
+        `[wairon mcp] chained subproject: this root is mounted as subsystem "${chainingParent.subsystemId}" of the parent project at ${chainingParent.parentRoot} \u2014 ${externalSurfaceCount} vendored external surface(s) discoverable via sdd_list_external_interfaces
+`
+      );
+    }
+  } catch {
+  }
   if (options.hostedTools) {
     const hostedStub = () => errText("This hosted tool is dispatched by the hosting data plane before reaching the MCP server; it is unavailable outside a hosted request.");
     reg(server, "sdd_host_lock_project", {
@@ -17702,6 +18494,8 @@ var init_server = __esm({
     init_narrative_labels();
     init_specs();
     init_skills();
+    init_specs2();
+    init_surfaces();
     SERVER_BUILD_STAMP = captureBuildStamp(__filename);
     STALE_SERVER_WARNING = "\n\n\u26A0 STALE SERVER: the wairon build on disk changed after this MCP server started. Restart the MCP session (e.g. /mcp reconnect) before further spec edits \u2014 writes through a stale server can silently drop fields introduced by newer schemas.";
     SKILL_RESOURCE_MIME = "text/markdown";
@@ -20775,7 +21569,7 @@ var require_dist = __commonJS({
       return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
     }
     var fs51 = __toESM2(require("fs"));
-    var path62 = __toESM2(require("path"));
+    var path61 = __toESM2(require("path"));
     var import_fflate = require_node();
     var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".hg", ".svn"]);
     function listEntries(archive) {
@@ -20813,8 +21607,8 @@ var require_dist = __commonJS({
     }
     function writeTree(destDir, files) {
       for (const file of files) {
-        const absolute = path62.join(destDir, file.path);
-        fs51.mkdirSync(path62.dirname(absolute), { recursive: true });
+        const absolute = path61.join(destDir, file.path);
+        fs51.mkdirSync(path61.dirname(absolute), { recursive: true });
         fs51.writeFileSync(absolute, file.contents);
       }
     }
@@ -20827,10 +21621,10 @@ var require_dist = __commonJS({
       for (const entry of fs51.readdirSync(current2, { withFileTypes: true })) {
         if (entry.isDirectory()) {
           if (SKIP_DIRS.has(entry.name)) continue;
-          walkPackDir(root, path62.join(current2, entry.name), out);
+          walkPackDir(root, path61.join(current2, entry.name), out);
         } else if (entry.isFile()) {
-          const absolute = path62.join(current2, entry.name);
-          const relative22 = path62.relative(root, absolute).split(path62.sep).join("/");
+          const absolute = path61.join(current2, entry.name);
+          const relative22 = path61.relative(root, absolute).split(path61.sep).join("/");
           out.push({ path: relative22, contents: fs51.readFileSync(absolute) });
         }
       }
@@ -22241,86 +23035,216 @@ async function generateLayer(options = {}) {
 }
 
 // src/commands/lock.ts
+var os7 = __toESM(require("os"));
 var import_inquirer2 = __toESM(require("inquirer"));
 init_logger();
-init_loader();
-init_fs();
-init_validation();
-init_specs2();
-async function runLock(options = {}) {
-  assertProjectInitialized();
-  if (!pathExists(AI_PATHS.specsSystem())) {
-    logger.error("No SDD spec tree found (.wai/specs). Nothing to lock.");
-    process.exit(1);
+init_defaults();
+
+// src/core/detection.ts
+var fs18 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
+init_defaults();
+var PACKAGE_MARKERS = [
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "build.gradle",
+  "build.gradle.kts",
+  "pom.xml"
+];
+var MAX_SCAN_DEPTH = 5;
+function detectDomainCandidates(projectRoot2, alreadyTrackedPaths = /* @__PURE__ */ new Set(), alreadyTrackedIds = /* @__PURE__ */ new Set()) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const c of detectGitSubmodules(projectRoot2)) {
+    candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
   }
-  const projectConfig = loadProjectConfig();
-  logger.info("Analyzing and validating specifications in-memory...");
-  const index = scanAllSpecs({ recursive: options.recursive ?? true });
-  const promotable = collectPromotableSpecs(options.subsystem);
-  const originalStatuses = /* @__PURE__ */ new Map();
-  const isSpecInSubsystemScope = (specSubsystem) => {
-    if (!options.subsystem) return true;
-    if (!specSubsystem) return false;
-    return specSubsystem === options.subsystem || specSubsystem.startsWith(`${options.subsystem}::`);
-  };
-  for (const s of index.subsystems) {
-    if (!options.subsystem || s.id === options.subsystem || s.id.startsWith(`${options.subsystem}::`)) {
-      originalStatuses.set(s, s.status);
-      s.status = "complete";
+  for (const c of detectNestedGitRepos(projectRoot2)) {
+    if (!candidates.has(c.path)) {
+      candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
     }
   }
-  for (const c of index.components) {
-    if (isSpecInSubsystemScope(c.subsystem)) {
-      originalStatuses.set(c, c.status);
-      c.status = "complete";
-    }
+  const gitPaths = new Set(
+    Array.from(candidates.values()).filter((c) => c.type === "git-submodule" || c.type === "git-repo").map((c) => c.path)
+  );
+  for (const c of detectPackageRoots(projectRoot2)) {
+    if (candidates.has(c.path)) continue;
+    const insideGit = Array.from(gitPaths).some(
+      (gp) => c.path === gp || c.path.startsWith(gp + "/")
+    );
+    if (insideGit) continue;
+    candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
   }
-  for (const i of index.interfaces) {
-    const comp = index.components.find((c) => c.id === i.component);
-    if (comp && isSpecInSubsystemScope(comp.subsystem)) {
-      originalStatuses.set(i, i.status);
-      i.status = "complete";
-    }
+  const sorted = Array.from(candidates.values()).sort((a, b) => a.path.localeCompare(b.path));
+  return deduplicateIds(sorted, alreadyTrackedIds);
+}
+function deduplicateIds(candidates, existingIds = /* @__PURE__ */ new Set()) {
+  const idCount = /* @__PURE__ */ new Map();
+  for (const id of existingIds) {
+    idCount.set(id, (idCount.get(id) ?? 0) + 1);
   }
-  for (const m of index.implementations) {
-    const intf = index.interfaces.find((i) => i.id === m.contract);
-    const comp = intf ? index.components.find((c) => c.id === intf.component) : null;
-    if (comp && isSpecInSubsystemScope(comp.subsystem)) {
-      originalStatuses.set(m, m.status);
-      m.status = "complete";
-    }
+  for (const c of candidates) {
+    idCount.set(c.suggestedId, (idCount.get(c.suggestedId) ?? 0) + 1);
   }
-  const dry = validateSddTree({
-    rules: projectConfig.rules,
-    projectType: projectConfig.projectType,
-    scopeSubsystem: options.subsystem,
-    recursive: options.recursive ?? true
+  return candidates.map((c) => {
+    if ((idCount.get(c.suggestedId) ?? 0) <= 1) return c;
+    const parts = c.path.split("/");
+    const qualifiedId2 = parts.length >= 2 ? pathToId(`${parts[parts.length - 2]}-${parts[parts.length - 1]}`) : c.suggestedId;
+    return { ...c, suggestedId: qualifiedId2 };
   });
-  for (const [spec, status2] of originalStatuses.entries()) {
-    spec.status = status2;
+}
+function parseGitmodules(filePath) {
+  const content = fs18.readFileSync(filePath, "utf-8");
+  const entries = [];
+  let current2 = {};
+  for (const line2 of content.split("\n")) {
+    const trimmed = line2.trim();
+    const headerMatch = trimmed.match(/^\[submodule "(.+)"\]$/);
+    if (headerMatch) {
+      if (current2.path) entries.push(current2);
+      current2 = { name: headerMatch[1] };
+      continue;
+    }
+    const keyVal = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+    if (keyVal) {
+      const [, key, value] = keyVal;
+      if (key === "path") current2.path = value.trim();
+      if (key === "url") current2.url = value.trim();
+    }
   }
-  const errors = dry.issues.filter((i) => i.severity === "error");
-  if (errors.length > 0) {
-    logger.header("Cannot lock \u2014 the spec tree does not validate as complete");
-    let errorCount = 0;
-    const MAX_PRINT = 100;
-    let skippedErrors = 0;
-    for (const i of errors) {
-      if (errorCount < MAX_PRINT) {
-        logger.error(`${i.specId ? `[${i.specId}] ` : ""}[${i.code}] ${i.message}`);
-        errorCount++;
-      } else {
-        skippedErrors++;
-      }
+  if (current2.path) entries.push(current2);
+  return entries;
+}
+function detectGitSubmodules(projectRoot2) {
+  const gitmodulesPath = path27.join(projectRoot2, ".gitmodules");
+  if (!fs18.existsSync(gitmodulesPath)) return [];
+  return parseGitmodules(gitmodulesPath).map((entry) => ({
+    suggestedId: pathToId(entry.path),
+    suggestedName: pathToName(entry.path),
+    path: normalizePath3(entry.path),
+    type: "git-submodule",
+    alreadyTracked: false
+  }));
+}
+function detectNestedGitRepos(projectRoot2) {
+  const results = [];
+  walkForGit(projectRoot2, projectRoot2, 0, results);
+  return results;
+}
+function walkForGit(projectRoot2, currentDir, depth, results) {
+  if (depth > MAX_SCAN_DEPTH) return;
+  let entries;
+  try {
+    entries = fs18.readdirSync(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
+    const fullPath = path27.join(currentDir, entry.name);
+    const relPath = normalizePath3(path27.relative(projectRoot2, fullPath));
+    if (relPath === "" || relPath === ".") continue;
+    const gitPath = path27.join(fullPath, ".git");
+    if (fs18.existsSync(gitPath)) {
+      results.push({
+        suggestedId: pathToId(relPath),
+        suggestedName: pathToName(relPath),
+        path: relPath,
+        type: "git-repo",
+        alreadyTracked: false
+      });
+      continue;
     }
-    if (skippedErrors > 0) {
-      logger.error(`... and ${skippedErrors} more error(s) omitted.`);
+    walkForGit(projectRoot2, fullPath, depth + 1, results);
+  }
+}
+function detectPackageRoots(projectRoot2) {
+  const results = [];
+  walkForPackages(projectRoot2, projectRoot2, 0, results);
+  return results;
+}
+function walkForPackages(projectRoot2, currentDir, depth, results) {
+  if (depth > MAX_SCAN_DEPTH) return;
+  let entries;
+  try {
+    entries = fs18.readdirSync(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
+    const fullPath = path27.join(currentDir, entry.name);
+    const relPath = normalizePath3(path27.relative(projectRoot2, fullPath));
+    if (relPath === "" || relPath === ".") continue;
+    const hasMarker = PACKAGE_MARKERS.some((m) => fs18.existsSync(path27.join(fullPath, m)));
+    if (hasMarker) {
+      results.push({
+        suggestedId: pathToId(relPath),
+        suggestedName: pathToName(relPath),
+        path: relPath,
+        type: "package-root",
+        alreadyTracked: false
+      });
     }
-    logger.blank();
-    logger.info("Fix the errors above, then run `wairon lock` again. Nothing was changed.");
-    process.exit(1);
+    walkForPackages(projectRoot2, fullPath, depth + 1, results);
   }
-  logger.header("Lock SDD specs");
+}
+function pathToId(relPath) {
+  const basename11 = path27.basename(relPath);
+  return basename11.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function pathToName(relPath) {
+  const id = pathToId(relPath);
+  return id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function normalizePath3(p) {
+  return p.replace(/\\/g, "/");
+}
+
+// src/core/index.ts
+init_domains();
+init_validation();
+init_extensions();
+init_variants();
+init_rules();
+init_specs2();
+init_provision();
+init_diagram();
+
+// src/core/lockfile.ts
+var fs19 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
+init_fs();
+function lockPath() {
+  return aiDir("lock.json");
+}
+function readLockRecord() {
+  try {
+    return JSON.parse(fs19.readFileSync(lockPath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeLockRecord(record2) {
+  const p = lockPath();
+  fs19.mkdirSync(path28.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp`;
+  fs19.writeFileSync(tmp, JSON.stringify(record2, null, 2) + "\n");
+  fs19.renameSync(tmp, p);
+}
+
+// src/core/index.ts
+init_statehash();
+init_agent_resolver();
+init_skills();
+init_surfaces();
+init_openapi();
+
+// src/commands/lock.ts
+async function runLock(options = {}, gate) {
+  const promotable = collectPromotableSpecs(options.subsystem);
   if (promotable.length === 0) {
     logger.info("All specs are already complete \u2014 this will re-validate and regenerate the agent topology.");
   } else {
@@ -22344,23 +23268,36 @@ async function runLock(options = {}) {
         default: false
       }
     ]);
-    if (!confirmed) {
-      logger.info("Cancelled. Nothing was changed.");
-      return;
-    }
+    if (!confirmed) return null;
+  }
+  if (options.subsystem) {
+    for (const p of promotable) applySpecStatus(p.kind, p.id, "complete");
+    invalidateSpecCache();
+  } else {
+    promoteAllComplete();
   }
-  for (const p of promotable) applySpecStatus(p.kind, p.id, "complete");
-  invalidateSpecCache();
   if (promotable.length > 0) {
     logger.success(`Locked ${promotable.length} spec(s) as complete.`);
   }
-  logger.blank();
-  await runGenerate({ domain: options.subsystem });
-  logger.blank();
-  logger.success("Specs locked and agent topology generated.");
-  logger.warn(
-    "Restart any running AI agent sessions (Claude Code / Antigravity / Codex) so the newly generated implementer agents load \u2014 they are not picked up mid-session."
-  );
+  let lockedBy = "local";
+  try {
+    lockedBy = `local:${os7.userInfo().username}`;
+  } catch {
+  }
+  const record2 = {
+    stateId: computeStateId(),
+    lockedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lockedBy,
+    validatorVersion: WAIRON_VERSION,
+    validationResult: {
+      valid: true,
+      errors: 0,
+      warnings: gate ? gate.issues.filter((i) => i.severity === "warning").length : 0
+    },
+    status: "ready"
+  };
+  writeLockRecord(record2);
+  return record2;
 }
 
 // src/commands/validate.ts
@@ -22499,6 +23436,10 @@ async function runValidate(options = {}) {
   }
 }
 
+// src/cli/index.ts
+init_loader();
+init_fs();
+
 // src/commands/list.ts
 var import_chalk7 = __toESM(require("chalk"));
 init_logger();
@@ -22613,9 +23554,9 @@ init_mcp();
 // src/commands/update.ts
 var https = __toESM(require("https"));
 var http = __toESM(require("http"));
-var fs18 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
-var os7 = __toESM(require("os"));
+var fs20 = __toESM(require("fs"));
+var path29 = __toESM(require("path"));
+var os8 = __toESM(require("os"));
 var crypto2 = __toESM(require("crypto"));
 var import_child_process2 = require("child_process");
 init_logger();
@@ -22678,8 +23619,8 @@ async function runUpdate(options = {}) {
     logger.info(`Download manually from: ${release.html_url}`);
     process.exit(1);
   }
-  const tmpDir = os7.tmpdir();
-  const tmpFile = path27.join(tmpDir, assetName);
+  const tmpDir = os8.tmpdir();
+  const tmpFile = path29.join(tmpDir, assetName);
   logger.info(`Downloading ${assetName}...`);
   try {
     await downloadFile(asset.browser_download_url, tmpFile);
@@ -22696,16 +23637,16 @@ async function runUpdate(options = {}) {
   const checksumAssetName = assetName + ".sha256";
   const checksumAsset = release.assets.find((a) => a.name === checksumAssetName);
   if (checksumAsset) {
-    const tmpChecksum = path27.join(tmpDir, checksumAssetName);
+    const tmpChecksum = path29.join(tmpDir, checksumAssetName);
     logger.info(`Verifying checksum...`);
     try {
       await downloadFile(checksumAsset.browser_download_url, tmpChecksum);
       verifyChecksum(tmpFile, tmpChecksum, assetName);
-      fs18.unlinkSync(tmpChecksum);
+      fs20.unlinkSync(tmpChecksum);
     } catch (err) {
       logger.error(`Checksum verification failed: ${err.message}`);
       try {
-        fs18.unlinkSync(tmpFile);
+        fs20.unlinkSync(tmpFile);
       } catch {
       }
       process.exit(1);
@@ -22771,7 +23712,7 @@ function fetchReleases(repo) {
 }
 function downloadFile(url, dest) {
   return new Promise((resolve24, reject) => {
-    const file = fs18.createWriteStream(dest);
+    const file = fs20.createWriteStream(dest);
     const get3 = url.startsWith("https://") ? https.get : http.get;
     get3(url, { headers: { "User-Agent": `wairon/${WAIRON_VERSION}` }, agent: false }, (res) => {
       if (res.statusCode === 301 || res.statusCode === 302) {
@@ -22793,21 +23734,21 @@ function downloadFile(url, dest) {
       });
       file.on("error", (err) => {
         res.destroy();
-        fs18.unlink(dest, () => {
+        fs20.unlink(dest, () => {
         });
         reject(err);
       });
     }).on("error", (err) => {
-      fs18.unlink(dest, () => {
+      fs20.unlink(dest, () => {
       });
       reject(err);
     });
   });
 }
 function verifyChecksum(filePath, checksumFile, expectedFilename) {
-  const checksumContent = fs18.readFileSync(checksumFile, "utf-8").trim();
+  const checksumContent = fs20.readFileSync(checksumFile, "utf-8").trim();
   const expectedHash = checksumContent.split(/\s+/)[0].toLowerCase();
-  const fileBuffer = fs18.readFileSync(filePath);
+  const fileBuffer = fs20.readFileSync(filePath);
   const actualHash = crypto2.createHash("sha256").update(fileBuffer).digest("hex").toLowerCase();
   if (actualHash !== expectedHash) {
     throw new Error(
@@ -22838,9 +23779,9 @@ function isPkgBinary2() {
 function installBinary(tmpFile, destPath) {
   const platform = process.platform;
   const isZip = tmpFile.endsWith(".zip");
-  const extractDir = path27.join(os7.tmpdir(), "wairon-extract");
-  if (fs18.existsSync(extractDir)) fs18.rmSync(extractDir, { recursive: true });
-  fs18.mkdirSync(extractDir, { recursive: true });
+  const extractDir = path29.join(os8.tmpdir(), "wairon-extract");
+  if (fs20.existsSync(extractDir)) fs20.rmSync(extractDir, { recursive: true });
+  fs20.mkdirSync(extractDir, { recursive: true });
   if (isZip) {
     (0, import_child_process2.execSync)(
       `powershell -NoProfile -NonInteractive -Command "Expand-Archive -Path '${tmpFile}' -DestinationPath '${extractDir}' -Force"`,
@@ -22850,18 +23791,18 @@ function installBinary(tmpFile, destPath) {
     (0, import_child_process2.execSync)(`tar -xzf "${tmpFile}" -C "${extractDir}"`, { stdio: ["ignore", "pipe", "pipe"] });
   }
   const binaryName = platform === "win32" ? "wairon.exe" : "wairon";
-  const extractedBinary = path27.join(extractDir, binaryName);
-  if (!fs18.existsSync(extractedBinary)) {
+  const extractedBinary = path29.join(extractDir, binaryName);
+  if (!fs20.existsSync(extractedBinary)) {
     throw new Error(`Extracted binary not found at ${extractedBinary}`);
   }
   if (platform === "win32") {
     const oldPath = destPath + ".old";
     try {
       cleanStaleBinary(oldPath);
-      fs18.renameSync(destPath, oldPath);
-      fs18.copyFileSync(extractedBinary, destPath);
+      fs20.renameSync(destPath, oldPath);
+      fs20.copyFileSync(extractedBinary, destPath);
       try {
-        fs18.unlinkSync(oldPath);
+        fs20.unlinkSync(oldPath);
       } catch {
       }
     } catch (err) {
@@ -22875,25 +23816,25 @@ function installBinary(tmpFile, destPath) {
     }
   } else {
     const tmpDest = destPath + ".new";
-    fs18.copyFileSync(extractedBinary, tmpDest);
-    fs18.chmodSync(tmpDest, 493);
-    fs18.renameSync(tmpDest, destPath);
+    fs20.copyFileSync(extractedBinary, tmpDest);
+    fs20.chmodSync(tmpDest, 493);
+    fs20.renameSync(tmpDest, destPath);
   }
   try {
-    fs18.unlinkSync(tmpFile);
+    fs20.unlinkSync(tmpFile);
   } catch {
   }
   try {
-    fs18.rmSync(extractDir, { recursive: true });
+    fs20.rmSync(extractDir, { recursive: true });
   } catch {
   }
 }
 function cleanStaleBinary(oldPath) {
   const target = oldPath ?? (isPkgBinary2() ? process.execPath + ".old" : null);
   if (!target) return;
-  if (fs18.existsSync(target)) {
+  if (fs20.existsSync(target)) {
     try {
-      fs18.unlinkSync(target);
+      fs20.unlinkSync(target);
     } catch {
     }
   }
@@ -23139,171 +24080,6 @@ async function filteredCheckbox(config) {
 
 // src/commands/domains.ts
 init_loader();
-
-// src/core/detection.ts
-var fs19 = __toESM(require("fs"));
-var path28 = __toESM(require("path"));
-init_defaults();
-var PACKAGE_MARKERS = [
-  "package.json",
-  "pyproject.toml",
-  "Cargo.toml",
-  "go.mod",
-  "build.gradle",
-  "build.gradle.kts",
-  "pom.xml"
-];
-var MAX_SCAN_DEPTH = 5;
-function detectDomainCandidates(projectRoot2, alreadyTrackedPaths = /* @__PURE__ */ new Set(), alreadyTrackedIds = /* @__PURE__ */ new Set()) {
-  const candidates = /* @__PURE__ */ new Map();
-  for (const c of detectGitSubmodules(projectRoot2)) {
-    candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
-  }
-  for (const c of detectNestedGitRepos(projectRoot2)) {
-    if (!candidates.has(c.path)) {
-      candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
-    }
-  }
-  const gitPaths = new Set(
-    Array.from(candidates.values()).filter((c) => c.type === "git-submodule" || c.type === "git-repo").map((c) => c.path)
-  );
-  for (const c of detectPackageRoots(projectRoot2)) {
-    if (candidates.has(c.path)) continue;
-    const insideGit = Array.from(gitPaths).some(
-      (gp) => c.path === gp || c.path.startsWith(gp + "/")
-    );
-    if (insideGit) continue;
-    candidates.set(c.path, { ...c, alreadyTracked: alreadyTrackedPaths.has(c.path) });
-  }
-  const sorted = Array.from(candidates.values()).sort((a, b) => a.path.localeCompare(b.path));
-  return deduplicateIds(sorted, alreadyTrackedIds);
-}
-function deduplicateIds(candidates, existingIds = /* @__PURE__ */ new Set()) {
-  const idCount = /* @__PURE__ */ new Map();
-  for (const id of existingIds) {
-    idCount.set(id, (idCount.get(id) ?? 0) + 1);
-  }
-  for (const c of candidates) {
-    idCount.set(c.suggestedId, (idCount.get(c.suggestedId) ?? 0) + 1);
-  }
-  return candidates.map((c) => {
-    if ((idCount.get(c.suggestedId) ?? 0) <= 1) return c;
-    const parts = c.path.split("/");
-    const qualifiedId2 = parts.length >= 2 ? pathToId(`${parts[parts.length - 2]}-${parts[parts.length - 1]}`) : c.suggestedId;
-    return { ...c, suggestedId: qualifiedId2 };
-  });
-}
-function parseGitmodules(filePath) {
-  const content = fs19.readFileSync(filePath, "utf-8");
-  const entries = [];
-  let current2 = {};
-  for (const line2 of content.split("\n")) {
-    const trimmed = line2.trim();
-    const headerMatch = trimmed.match(/^\[submodule "(.+)"\]$/);
-    if (headerMatch) {
-      if (current2.path) entries.push(current2);
-      current2 = { name: headerMatch[1] };
-      continue;
-    }
-    const keyVal = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
-    if (keyVal) {
-      const [, key, value] = keyVal;
-      if (key === "path") current2.path = value.trim();
-      if (key === "url") current2.url = value.trim();
-    }
-  }
-  if (current2.path) entries.push(current2);
-  return entries;
-}
-function detectGitSubmodules(projectRoot2) {
-  const gitmodulesPath = path28.join(projectRoot2, ".gitmodules");
-  if (!fs19.existsSync(gitmodulesPath)) return [];
-  return parseGitmodules(gitmodulesPath).map((entry) => ({
-    suggestedId: pathToId(entry.path),
-    suggestedName: pathToName(entry.path),
-    path: normalizePath3(entry.path),
-    type: "git-submodule",
-    alreadyTracked: false
-  }));
-}
-function detectNestedGitRepos(projectRoot2) {
-  const results = [];
-  walkForGit(projectRoot2, projectRoot2, 0, results);
-  return results;
-}
-function walkForGit(projectRoot2, currentDir, depth, results) {
-  if (depth > MAX_SCAN_DEPTH) return;
-  let entries;
-  try {
-    entries = fs19.readdirSync(currentDir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
-    const fullPath = path28.join(currentDir, entry.name);
-    const relPath = normalizePath3(path28.relative(projectRoot2, fullPath));
-    if (relPath === "" || relPath === ".") continue;
-    const gitPath = path28.join(fullPath, ".git");
-    if (fs19.existsSync(gitPath)) {
-      results.push({
-        suggestedId: pathToId(relPath),
-        suggestedName: pathToName(relPath),
-        path: relPath,
-        type: "git-repo",
-        alreadyTracked: false
-      });
-      continue;
-    }
-    walkForGit(projectRoot2, fullPath, depth + 1, results);
-  }
-}
-function detectPackageRoots(projectRoot2) {
-  const results = [];
-  walkForPackages(projectRoot2, projectRoot2, 0, results);
-  return results;
-}
-function walkForPackages(projectRoot2, currentDir, depth, results) {
-  if (depth > MAX_SCAN_DEPTH) return;
-  let entries;
-  try {
-    entries = fs19.readdirSync(currentDir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
-    const fullPath = path28.join(currentDir, entry.name);
-    const relPath = normalizePath3(path28.relative(projectRoot2, fullPath));
-    if (relPath === "" || relPath === ".") continue;
-    const hasMarker = PACKAGE_MARKERS.some((m) => fs19.existsSync(path28.join(fullPath, m)));
-    if (hasMarker) {
-      results.push({
-        suggestedId: pathToId(relPath),
-        suggestedName: pathToName(relPath),
-        path: relPath,
-        type: "package-root",
-        alreadyTracked: false
-      });
-    }
-    walkForPackages(projectRoot2, fullPath, depth + 1, results);
-  }
-}
-function pathToId(relPath) {
-  const basename12 = path28.basename(relPath);
-  return basename12.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function pathToName(relPath) {
-  const id = pathToId(relPath);
-  return id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
-function normalizePath3(p) {
-  return p.replace(/\\/g, "/");
-}
-
-// src/commands/domains.ts
 init_domains();
 init_domain();
 async function runDomainsList() {
@@ -23493,9 +24269,9 @@ async function runSkillsInstall() {
 }
 
 // src/commands/doctor.ts
-var fs20 = __toESM(require("fs"));
-var os8 = __toESM(require("os"));
-var path29 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var os9 = __toESM(require("os"));
+var path30 = __toESM(require("path"));
 var import_chalk12 = __toESM(require("chalk"));
 init_logger();
 init_defaults();
@@ -23525,10 +24301,10 @@ function stampVerdict(content) {
   return { mark: "warn", note: `v${v} \u2014 stale, installed is v${WAIRON_VERSION}` };
 }
 function mcpEntryHealth(settingsPath) {
-  if (!fs20.existsSync(settingsPath)) return { mark: "warn", note: "not registered" };
+  if (!fs21.existsSync(settingsPath)) return { mark: "warn", note: "not registered" };
   let entry;
   try {
-    const s = JSON.parse(fs20.readFileSync(settingsPath, "utf8"));
+    const s = JSON.parse(fs21.readFileSync(settingsPath, "utf8"));
     entry = s.mcpServers?.["wairon"];
   } catch {
     return { mark: "error", note: "parse error" };
@@ -23536,7 +24312,7 @@ function mcpEntryHealth(settingsPath) {
   if (!entry) return { mark: "warn", note: "not registered" };
   if (entry.command === "node" && Array.isArray(entry.args) && typeof entry.args[0] === "string") {
     const scriptPath = entry.args[0];
-    if (!fs20.existsSync(scriptPath)) {
+    if (!fs21.existsSync(scriptPath)) {
       return { mark: "error", note: `registered but the server path is missing \u2014 ${scriptPath}` };
     }
   }
@@ -23588,7 +24364,7 @@ async function runDoctor(options = {}) {
     const { findChainingSubprojectsMissingConfig: findChainingSubprojectsMissingConfig2 } = (init_provision(), __toCommonJS(provision_exports));
     const missing = findChainingSubprojectsMissingConfig2(getProjectRoot());
     if (missing.length > 0) {
-      line(tally, "warn", `${missing.length} chained subproject(s) have specs but no project.yaml (un-runnable standalone): ${missing.map((d) => path29.relative(getProjectRoot(), d) || ".").join(", ")}. Run \`wairon doctor --fix\` to initialize them.`);
+      line(tally, "warn", `${missing.length} chained subproject(s) have specs but no project.yaml (un-runnable standalone): ${missing.map((d) => path30.relative(getProjectRoot(), d) || ".").join(", ")}. Run \`wairon doctor --fix\` to initialize them.`);
     }
   } catch {
   }
@@ -23626,7 +24402,7 @@ async function runDoctor(options = {}) {
     const gp = localGuideFilePath(process.cwd(), t);
     if (!gp || seenGuides.has(gp)) continue;
     seenGuides.add(gp);
-    const rel2 = path29.relative(process.cwd(), gp).replace(/\\/g, "/");
+    const rel2 = path30.relative(process.cwd(), gp).replace(/\\/g, "/");
     if (!pathExists(gp)) {
       line(tally, "warn", `${rel2} guide \u2014 not injected (run \`wairon generate\`)`);
       continue;
@@ -23660,17 +24436,17 @@ async function runDoctor(options = {}) {
     line(tally, h.mark, `Claude (project .mcp.json): ${h.note}${h.mark === "ok" ? "" : " \u2014 run `wairon mcp install --backend claude`"}`);
   }
   if (wantGemini) {
-    const globalCfg = path29.join(os8.homedir(), ".gemini", "antigravity-cli", "mcp_config.json");
+    const globalCfg = path30.join(os9.homedir(), ".gemini", "antigravity-cli", "mcp_config.json");
     const hg = mcpEntryHealth(globalCfg);
     line(tally, hg.mark, `Antigravity (global mcp_config.json): ${hg.note}${hg.mark === "ok" ? "" : " \u2014 run `wairon mcp install --backend gemini --global`"}`);
     const projPath = fromProjectRoot(".gemini", "settings.json");
-    if (fs20.existsSync(projPath)) {
+    if (fs21.existsSync(projPath)) {
       const hp = mcpEntryHealth(projPath);
       line(tally, hp.mark === "error" ? "error" : "ok", `Gemini CLI (project): ${hp.note} ${import_chalk12.default.gray("(Antigravity ignores this file)")}`);
     }
   }
-  const pluginDir = path29.join(os8.homedir(), ".gemini", "config", "plugins", "wairon");
-  if (fs20.existsSync(pluginDir)) {
+  const pluginDir = path30.join(os9.homedir(), ".gemini", "config", "plugins", "wairon");
+  if (fs21.existsSync(pluginDir)) {
     line(tally, "warn", `Legacy Antigravity plugin present (${pluginDir}) \u2014 it collides with the wairon MCP server. Remove it with \`wairon doctor --fix\`.`);
   }
   logger.blank();
@@ -23701,7 +24477,7 @@ async function applyFixes() {
     const legacySpecs = findLegacySpecFiles();
     if (legacySpecs.length > 0) {
       for (const { path: oldPath, expected: newPath } of legacySpecs) {
-        fs20.renameSync(oldPath, newPath);
+        fs21.renameSync(oldPath, newPath);
       }
       console.log(`  ${icon("ok")} Migrated ${legacySpecs.length} legacy spec file(s) to the new dot-prefixed unified schema.`);
     }
@@ -23755,8 +24531,8 @@ function printSummary(tally) {
 }
 
 // src/commands/diagram.ts
-var fs21 = __toESM(require("fs"));
-var path30 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path31 = __toESM(require("path"));
 init_logger();
 init_loader();
 init_fs();
@@ -23791,8 +24567,8 @@ function collectIssues() {
 }
 function writeCanvas(dest) {
   const model = buildCanvasModel(collectIssues());
-  ensureDir(path30.dirname(path30.resolve(dest)));
-  fs21.writeFileSync(dest, renderCanvasHtml(model), "utf-8");
+  ensureDir(path31.dirname(path31.resolve(dest)));
+  fs22.writeFileSync(dest, renderCanvasHtml(model), "utf-8");
 }
 function parseSequenceRef(ref) {
   const sep6 = ref.includes(":") ? ref.lastIndexOf(":") : ref.lastIndexOf(".");
@@ -23807,55 +24583,55 @@ async function runDiagram(rawOptions = {}) {
   assertProjectInitialized();
   const options = applyFormat(rawOptions);
   if (options.canvas && !options.all) {
-    const dest2 = options.out ?? path30.join(AI_PATHS.docsDir(), "diagrams", "canvas.html");
+    const dest2 = options.out ?? path31.join(AI_PATHS.docsDir(), "diagrams", "canvas.html");
     writeCanvas(dest2);
     logger.success(`Interactive canvas written to ${dest2}`);
     logger.info("Open it in a browser \u2014 fully self-contained (works offline).");
     return;
   }
   if (options.drawio && !options.all) {
-    const dest2 = options.out ?? path30.join(AI_PATHS.docsDir(), "diagrams", "architecture.drawio");
-    ensureDir(path30.dirname(path30.resolve(dest2)));
-    fs21.writeFileSync(dest2, generateDrawioXml(buildCanvasModel()), "utf-8");
+    const dest2 = options.out ?? path31.join(AI_PATHS.docsDir(), "diagrams", "architecture.drawio");
+    ensureDir(path31.dirname(path31.resolve(dest2)));
+    fs22.writeFileSync(dest2, generateDrawioXml(buildCanvasModel()), "utf-8");
     logger.success(`draw.io diagram written to ${dest2}`);
     logger.info("Open with draw.io / diagrams.net (or import into tools that accept the format).");
     return;
   }
   if (options.excalidraw && !options.all) {
-    const dest2 = options.out ?? path30.join(AI_PATHS.docsDir(), "diagrams", "architecture.excalidraw");
-    ensureDir(path30.dirname(path30.resolve(dest2)));
-    fs21.writeFileSync(dest2, generateExcalidrawScene(buildCanvasModel()), "utf-8");
+    const dest2 = options.out ?? path31.join(AI_PATHS.docsDir(), "diagrams", "architecture.excalidraw");
+    ensureDir(path31.dirname(path31.resolve(dest2)));
+    fs22.writeFileSync(dest2, generateExcalidrawScene(buildCanvasModel()), "utf-8");
     logger.success(`Excalidraw scene written to ${dest2}`);
     logger.info("Open with excalidraw.com or the VS Code extension.");
     return;
   }
   const wantsMermaid = options.format?.toLowerCase().startsWith("mermaid") || !!options.subsystem || !!options.sequence;
   if (!options.all && !options.sequence && !wantsMermaid) {
-    const dest2 = options.out ?? path30.join(AI_PATHS.docsDir(), "diagrams", "canvas.html");
+    const dest2 = options.out ?? path31.join(AI_PATHS.docsDir(), "diagrams", "canvas.html");
     writeCanvas(dest2);
     logger.success(`Interactive canvas written to ${dest2}`);
     logger.info("Open it in a browser \u2014 fully self-contained (works offline). Other formats: --format mermaid|drawio|excalidraw.");
     return;
   }
   if (options.all) {
-    const outDir = options.out ?? path30.join(AI_PATHS.docsDir(), "diagrams");
+    const outDir = options.out ?? path31.join(AI_PATHS.docsDir(), "diagrams");
     const files = generateDiagramSet();
     if (files.length === 0) {
       logger.warn("No diagrams to generate \u2014 the spec tree has no components yet.");
       return;
     }
     for (const file of files) {
-      const dest2 = path30.join(outDir, file.relPath);
-      ensureDir(path30.dirname(dest2));
-      fs21.writeFileSync(dest2, toMarkdown(file), "utf-8");
+      const dest2 = path31.join(outDir, file.relPath);
+      ensureDir(path31.dirname(dest2));
+      fs22.writeFileSync(dest2, toMarkdown(file), "utf-8");
     }
-    writeCanvas(path30.join(outDir, "canvas.html"));
+    writeCanvas(path31.join(outDir, "canvas.html"));
     const exportModel = buildCanvasModel();
-    fs21.writeFileSync(path30.join(outDir, "architecture.drawio"), generateDrawioXml(exportModel), "utf-8");
-    fs21.writeFileSync(path30.join(outDir, "architecture.excalidraw"), generateExcalidrawScene(exportModel), "utf-8");
+    fs22.writeFileSync(path31.join(outDir, "architecture.drawio"), generateDrawioXml(exportModel), "utf-8");
+    fs22.writeFileSync(path31.join(outDir, "architecture.excalidraw"), generateExcalidrawScene(exportModel), "utf-8");
     const graph = loadSpecGraph();
-    const indexPath = path30.join(outDir, "README.md");
-    fs21.writeFileSync(indexPath, diagramSetIndex(files, graph.systemName), "utf-8");
+    const indexPath = path31.join(outDir, "README.md");
+    fs22.writeFileSync(indexPath, diagramSetIndex(files, graph.systemName), "utf-8");
     logger.success(`Generated ${files.length} diagram(s) + interactive canvas.html + index into ${outDir}`);
     for (const file of files.slice(0, 12)) {
       logger.info(`  ${file.relPath}`);
@@ -23866,26 +24642,26 @@ async function runDiagram(rawOptions = {}) {
   let mermaid;
   let title;
   let defaultDest;
-  const diagramsDir = path30.join(AI_PATHS.docsDir(), "diagrams");
+  const diagramsDir = path31.join(AI_PATHS.docsDir(), "diagrams");
   if (options.sequence) {
     const { component, method: method2 } = parseSequenceRef(options.sequence);
     mermaid = generateSequenceDiagram(component, method2, { depth: options.depth });
     title = `${component}.${method2} \u2014 narrative sequence`;
-    defaultDest = path30.join(diagramsDir, "sequences", `${component.replace(/::/g, "--")}.${method2}.md`);
+    defaultDest = path31.join(diagramsDir, "sequences", `${component.replace(/::/g, "--")}.${method2}.md`);
   } else if (options.subsystem) {
     mermaid = generateComponentDiagram({ subsystem: options.subsystem });
     title = `${options.subsystem} \u2014 components`;
-    defaultDest = path30.join(diagramsDir, "subsystems", `${options.subsystem.replace(/::/g, "--")}.md`);
+    defaultDest = path31.join(diagramsDir, "subsystems", `${options.subsystem.replace(/::/g, "--")}.md`);
   } else {
     mermaid = generateComponentDiagram();
     title = "Component architecture";
-    defaultDest = path30.join(diagramsDir, "system.md");
+    defaultDest = path31.join(diagramsDir, "system.md");
   }
   const dest = options.out ?? defaultDest;
-  ensureDir(path30.dirname(path30.resolve(dest)));
+  ensureDir(path31.dirname(path31.resolve(dest)));
   const content = dest.endsWith(".mmd") ? `${mermaid}
 ` : toMarkdown({ relPath: dest, title, mermaid });
-  fs21.writeFileSync(dest, content, "utf-8");
+  fs22.writeFileSync(dest, content, "utf-8");
   logger.success(`Mermaid diagram written to ${dest}`);
   logger.info("Renders on GitHub/IDE previews; use a .mmd --out path for raw Mermaid.");
 }
@@ -23994,8 +24770,8 @@ Component variants (${variants.length})
 }
 
 // src/commands/packs.ts
-var fs22 = __toESM(require("fs"));
-var path31 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var path32 = __toESM(require("path"));
 var import_chalk16 = __toESM(require("chalk"));
 var import_sdk = __toESM(require_dist());
 init_logger();
@@ -24021,11 +24797,11 @@ function describe(probe2) {
   return parts.join(", ");
 }
 function resolveSourceUnit(source) {
-  const abs = path31.resolve(source);
-  if (!fs22.existsSync(abs)) {
+  const abs = path32.resolve(source);
+  if (!fs23.existsSync(abs)) {
     throw new Error(`Pack source "${source}" does not exist.`);
   }
-  const isDir = fs22.statSync(abs).isDirectory();
+  const isDir = fs23.statSync(abs).isDirectory();
   if (isDir && !packDirEntry(abs)) {
     throw new Error(`"${source}" is a directory without a pack entry file (pack.yaml | pack.cjs | index.cjs | ...).`);
   }
@@ -24041,7 +24817,7 @@ async function addPack(source, options = {}) {
   }
   const { abs } = resolveSourceUnit(source);
   const scope = options.global ? "global" : "project";
-  const probe2 = probePack(abs, path31.dirname(abs), scope);
+  const probe2 = probePack(abs, path32.dirname(abs), scope);
   if (probe2.error) {
     logger.error(probe2.error);
     process.exitCode = 1;
@@ -24049,10 +24825,10 @@ async function addPack(source, options = {}) {
   }
   if (options.global) {
     const destDir = globalPacksDir();
-    const dest2 = path31.join(destDir, path31.basename(abs));
-    if (path31.resolve(dest2) !== abs) {
-      fs22.mkdirSync(destDir, { recursive: true });
-      fs22.cpSync(abs, dest2, { recursive: true, force: true });
+    const dest2 = path32.join(destDir, path32.basename(abs));
+    if (path32.resolve(dest2) !== abs) {
+      fs23.mkdirSync(destDir, { recursive: true });
+      fs23.cpSync(abs, dest2, { recursive: true, force: true });
     }
     logger.success(`Installed pack "${probe2.name}" globally: ${dest2}`);
     logger.info(`${describe(probe2)} \u2014 auto-loaded for every project on this machine (WAIRON_PACKS_DIR / ~/.wairon/packs).`);
@@ -24065,11 +24841,11 @@ async function addPack(source, options = {}) {
     return;
   }
   const root = getProjectRoot();
-  const relRef = `.wai/packs/${path31.basename(abs)}`;
-  const dest = path31.join(root, ".wai", "packs", path31.basename(abs));
-  if (path31.resolve(dest) !== abs) {
-    fs22.mkdirSync(path31.dirname(dest), { recursive: true });
-    fs22.cpSync(abs, dest, { recursive: true, force: true });
+  const relRef = `.wai/packs/${path32.basename(abs)}`;
+  const dest = path32.join(root, ".wai", "packs", path32.basename(abs));
+  if (path32.resolve(dest) !== abs) {
+    fs23.mkdirSync(path32.dirname(dest), { recursive: true });
+    fs23.cpSync(abs, dest, { recursive: true, force: true });
   }
   const config = loadProjectConfig();
   const packs = config.extensions?.packs ?? [];
@@ -24078,14 +24854,14 @@ async function addPack(source, options = {}) {
     saveProjectConfig(config);
     logger.success(`Vendored pack "${probe2.name}" into ${relRef} and registered it in .wai/project.yaml.`);
   } else {
-    fs22.cpSync(abs, dest, { recursive: true, force: true });
+    fs23.cpSync(abs, dest, { recursive: true, force: true });
     logger.success(`Pack "${probe2.name}" already registered \u2014 refreshed ${relRef} from the source.`);
   }
   logger.info(`${describe(probe2)} \u2014 commit .wai/ so CI and every clone enforce it.`);
 }
 async function addPackFromArchive(source, options) {
-  const abs = path31.resolve(source);
-  if (!fs22.existsSync(abs) || !fs22.statSync(abs).isFile()) {
+  const abs = path32.resolve(source);
+  if (!fs23.existsSync(abs) || !fs23.statSync(abs).isFile()) {
     logger.error(`Pack archive "${source}" does not exist.`);
     process.exitCode = 1;
     return;
@@ -24100,27 +24876,27 @@ async function addPackFromArchive(source, options) {
       process.exitCode = 1;
       return;
     }
-    baseDir = path31.join(getProjectRoot(), ".wai", "packs");
+    baseDir = path32.join(getProjectRoot(), ".wai", "packs");
   }
-  const bytes = fs22.readFileSync(abs);
-  fs22.mkdirSync(baseDir, { recursive: true });
-  const staging = fs22.mkdtempSync(path31.join(baseDir, ".wpack-staging-"));
+  const bytes = fs23.readFileSync(abs);
+  fs23.mkdirSync(baseDir, { recursive: true });
+  const staging = fs23.mkdtempSync(path32.join(baseDir, ".wpack-staging-"));
   let result;
   try {
     result = (0, import_sdk.extractPack)(bytes, staging);
   } catch (err) {
-    fs22.rmSync(staging, { recursive: true, force: true });
-    logger.error(`Failed to extract pack archive "${path31.basename(abs)}": ${err instanceof Error ? err.message : String(err)}`);
+    fs23.rmSync(staging, { recursive: true, force: true });
+    logger.error(`Failed to extract pack archive "${path32.basename(abs)}": ${err instanceof Error ? err.message : String(err)}`);
     process.exitCode = 1;
     return;
   }
   const name = result.name;
-  const destDir = path31.join(baseDir, name);
-  if (fs22.existsSync(destDir)) fs22.rmSync(destDir, { recursive: true, force: true });
-  fs22.renameSync(staging, destDir);
-  const probe2 = probePack(destDir, path31.dirname(destDir), scope);
+  const destDir = path32.join(baseDir, name);
+  if (fs23.existsSync(destDir)) fs23.rmSync(destDir, { recursive: true, force: true });
+  fs23.renameSync(staging, destDir);
+  const probe2 = probePack(destDir, path32.dirname(destDir), scope);
   if (probe2.error) {
-    fs22.rmSync(destDir, { recursive: true, force: true });
+    fs23.rmSync(destDir, { recursive: true, force: true });
     logger.error(probe2.error);
     process.exitCode = 1;
     return;
@@ -24138,7 +24914,7 @@ async function addPackFromArchive(source, options) {
     saveProjectConfig(config);
     logger.success(`Installed pack "${probe2.name ?? name}" into ${relRef} and registered it in .wai/project.yaml.`);
   } else {
-    logger.success(`Pack "${probe2.name ?? name}" already registered \u2014 refreshed ${relRef} from ${path31.basename(abs)}.`);
+    logger.success(`Pack "${probe2.name ?? name}" already registered \u2014 refreshed ${relRef} from ${path32.basename(abs)}.`);
   }
   logger.info(`${describe(probe2)} \u2014 commit .wai/ so CI and every clone enforce it.`);
 }
@@ -24159,7 +24935,7 @@ async function buildPack(source, options = {}) {
   const sourceDir = source && source.length > 0 ? source : ".";
   const result = (0, import_sdk.buildPack)(sourceDir);
   const outPath = options.out ?? result.suggestedFileName;
-  fs22.writeFileSync(outPath, result.archive);
+  fs23.writeFileSync(outPath, result.archive);
   logger.success(`Built pack "${result.info.name}" v${result.info.version} \u2192 ${outPath} (${result.archive.byteLength} bytes)`);
   logger.info(`Install it with \`wairon pack add ${outPath}\`, or upload it to a hosted instance.`);
 }
@@ -24173,9 +24949,9 @@ async function listPacks() {
   console.log(import_chalk16.default.bold.cyan(`\u25A0 Global (${globalPacksDir()})${useGlobal ? "" : import_chalk16.default.yellow("  [disabled: extensions.useGlobalPacks: false]")}`));
   if (globalRefs.length === 0) console.log(import_chalk16.default.dim("  (none)"));
   for (const ref of globalRefs) {
-    const probe2 = probePack(ref, path31.dirname(ref), "global");
-    if (probe2.error) console.log(`  ${import_chalk16.default.red("\u2716")} ${path31.basename(ref)} \u2014 ${import_chalk16.default.red(probe2.error)}`);
-    else console.log(`  ${import_chalk16.default.green("\u25CF")} ${import_chalk16.default.bold(probe2.name ?? path31.basename(ref))}  ${import_chalk16.default.dim(describe(probe2))}`);
+    const probe2 = probePack(ref, path32.dirname(ref), "global");
+    if (probe2.error) console.log(`  ${import_chalk16.default.red("\u2716")} ${path32.basename(ref)} \u2014 ${import_chalk16.default.red(probe2.error)}`);
+    else console.log(`  ${import_chalk16.default.green("\u25CF")} ${import_chalk16.default.bold(probe2.name ?? path32.basename(ref))}  ${import_chalk16.default.dim(describe(probe2))}`);
   }
   console.log("");
   if (!inProject) {
@@ -24196,9 +24972,9 @@ async function listPacks() {
 async function removePack(name, options = {}) {
   if (options.global) {
     for (const ref of discoverPacks(globalPacksDir())) {
-      const probe2 = probePack(ref, path31.dirname(ref), "global");
-      if (probe2.name === name || path31.basename(ref) === name) {
-        fs22.rmSync(ref, { recursive: true, force: true });
+      const probe2 = probePack(ref, path32.dirname(ref), "global");
+      if (probe2.name === name || path32.basename(ref) === name) {
+        fs23.rmSync(ref, { recursive: true, force: true });
         logger.success(`Removed global pack "${probe2.name ?? name}" (${ref}).`);
         return;
       }
@@ -24217,16 +24993,16 @@ async function removePack(name, options = {}) {
   const packs = config.extensions?.packs ?? [];
   for (const ref of packs) {
     const probe2 = probePack(ref, root, "project");
-    if (probe2.name === name || ref === name || path31.basename(ref) === name) {
+    if (probe2.name === name || ref === name || path32.basename(ref) === name) {
       config.extensions = {
         packs: packs.filter((p) => p !== ref),
         useGlobalPacks: config.extensions?.useGlobalPacks ?? true
       };
       saveProjectConfig(config);
-      const resolved = path31.resolve(root, ref);
-      const vendorDir = path31.resolve(root, ".wai", "packs");
-      if (resolved.startsWith(vendorDir + path31.sep)) {
-        fs22.rmSync(resolved, { recursive: true, force: true });
+      const resolved = path32.resolve(root, ref);
+      const vendorDir = path32.resolve(root, ".wai", "packs");
+      if (resolved.startsWith(vendorDir + path32.sep)) {
+        fs23.rmSync(resolved, { recursive: true, force: true });
         logger.success(`Deregistered pack "${probe2.name ?? name}" and deleted ${ref}.`);
       } else {
         logger.success(`Deregistered pack "${probe2.name ?? name}" (files at ${ref} left in place).`);
@@ -24240,8 +25016,8 @@ async function removePack(name, options = {}) {
 
 // src/commands/host.ts
 var fs50 = __toESM(require("fs"));
-var path60 = __toESM(require("path"));
-var os9 = __toESM(require("os"));
+var path59 = __toESM(require("path"));
+var os10 = __toESM(require("os"));
 var crypto20 = __toESM(require("crypto"));
 var import_child_process5 = require("child_process");
 var import_chalk17 = __toESM(require("chalk"));
@@ -24268,29 +25044,29 @@ var UNAUTHENTICATED = {
 var WEB_SESSION_PREFIX = "ws_";
 
 // src/server/credentials.ts
-var fs23 = __toESM(require("fs"));
-var path32 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
+var path33 = __toESM(require("path"));
 var crypto3 = __toESM(require("crypto"));
 var HASH_NS = "wairon:token:v1";
 function hashToken(token) {
   return crypto3.createHash("sha256").update(`${HASH_NS}:${token}`).digest("hex");
 }
 function storePath(dataDir) {
-  return path32.join(dataDir, "auth", "credentials.json");
+  return path33.join(dataDir, "auth", "credentials.json");
 }
 function load3(dataDir) {
   try {
-    return JSON.parse(fs23.readFileSync(storePath(dataDir), "utf8"));
+    return JSON.parse(fs24.readFileSync(storePath(dataDir), "utf8"));
   } catch {
     return [];
   }
 }
 function save(dataDir, records) {
   const p = storePath(dataDir);
-  fs23.mkdirSync(path32.dirname(p), { recursive: true });
+  fs24.mkdirSync(path33.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs23.writeFileSync(tmp, JSON.stringify(records, null, 2) + "\n");
-  fs23.renameSync(tmp, p);
+  fs24.writeFileSync(tmp, JSON.stringify(records, null, 2) + "\n");
+  fs24.renameSync(tmp, p);
 }
 function digestEquals(a, b) {
   const ab = Buffer.from(a, "hex");
@@ -24335,17 +25111,17 @@ function listByOwner(dataDir, ownerUserId) {
 }
 
 // src/server/websessions.ts
-var fs24 = __toESM(require("fs"));
-var path33 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path34 = __toESM(require("path"));
 var crypto4 = __toESM(require("crypto"));
 function storePath2(dataDir) {
-  return path33.join(dataDir, "web-sessions.json");
+  return path34.join(dataDir, "web-sessions.json");
 }
 function readSessions(dataDir) {
   const p = storePath2(dataDir);
   let raw;
   try {
-    raw = fs24.readFileSync(p, "utf8");
+    raw = fs25.readFileSync(p, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") return [];
     throw new Error(`Failed to read web session store at ${p}: ${e.message}`);
@@ -24360,10 +25136,10 @@ function readSessions(dataDir) {
 }
 function persistSessions(dataDir, sessions) {
   const p = storePath2(dataDir);
-  fs24.mkdirSync(path33.dirname(p), { recursive: true });
+  fs25.mkdirSync(path34.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs24.writeFileSync(tmp, JSON.stringify(sessions, null, 2) + "\n");
-  fs24.renameSync(tmp, p);
+  fs25.writeFileSync(tmp, JSON.stringify(sessions, null, 2) + "\n");
+  fs25.renameSync(tmp, p);
 }
 function mintSessionId() {
   return `${WEB_SESSION_PREFIX}${crypto4.randomBytes(24).toString("hex")}`;
@@ -24524,17 +25300,17 @@ function listWebSessionsBySubject(dataDir, userId) {
 }
 
 // src/server/users.ts
-var fs25 = __toESM(require("fs"));
-var path34 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path35 = __toESM(require("path"));
 var VALID_STATUSES = ["active", "inactive", "suspended", "deactivated", "disabled"];
 function storePath3(dataDir) {
-  return path34.join(dataDir, "users.json");
+  return path35.join(dataDir, "users.json");
 }
 function loadStore(dataDir) {
   const p = storePath3(dataDir);
   let raw;
   try {
-    raw = fs25.readFileSync(p, "utf8");
+    raw = fs26.readFileSync(p, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw new Error(`Cannot read hosted-user store at ${p}: ${err.message}`);
@@ -24552,10 +25328,10 @@ function loadStore(dataDir) {
 }
 function replaceAll(dataDir, records) {
   const p = storePath3(dataDir);
-  fs25.mkdirSync(path34.dirname(p), { recursive: true });
+  fs26.mkdirSync(path35.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs25.writeFileSync(tmp, JSON.stringify(records, null, 2) + "\n");
-  fs25.renameSync(tmp, p);
+  fs26.writeFileSync(tmp, JSON.stringify(records, null, 2) + "\n");
+  fs26.renameSync(tmp, p);
 }
 function registryUpsert(dataDir, record2) {
   const records = loadStore(dataDir);
@@ -24657,11 +25433,11 @@ function remapUnitReferences(dataDir, remap, removedScopeIds) {
 }
 
 // src/server/instance.ts
-var fs26 = __toESM(require("fs"));
-var path35 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path36 = __toESM(require("path"));
 var import_crypto = require("crypto");
 function storePath4(dataDir) {
-  return path35.join(dataDir, "instance.json");
+  return path36.join(dataDir, "instance.json");
 }
 var InstanceIdentityStore = class {
   constructor(dataDir) {
@@ -24678,7 +25454,7 @@ var InstanceIdentityStore = class {
     const p = storePath4(this.dataDir);
     let raw;
     try {
-      raw = fs26.readFileSync(p, "utf8");
+      raw = fs27.readFileSync(p, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw new Error(`Cannot read instance identity at ${p}: ${err.message}`);
@@ -24701,10 +25477,10 @@ var InstanceIdentityStore = class {
    *  never truncates the file. Only called by the registry's create-once seed. */
   replace(identity) {
     const p = storePath4(this.dataDir);
-    fs26.mkdirSync(path35.dirname(p), { recursive: true });
+    fs27.mkdirSync(path36.dirname(p), { recursive: true });
     const tmp = `${p}.tmp`;
-    fs26.writeFileSync(tmp, JSON.stringify(identity, null, 2) + "\n");
-    fs26.renameSync(tmp, p);
+    fs27.writeFileSync(tmp, JSON.stringify(identity, null, 2) + "\n");
+    fs27.renameSync(tmp, p);
   }
 };
 var InstanceIdentityRegistry = class {
@@ -24760,8 +25536,8 @@ function getInstanceIdentity(dataDir) {
 }
 
 // src/utils/secrets.ts
-var fs27 = __toESM(require("fs"));
-var path36 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path37 = __toESM(require("path"));
 var ENV_FALLBACK = {
   "git-token": ["WAIRON_GIT_TOKEN"],
   "notion-token": ["WAIRON_NOTION_TOKEN"],
@@ -24770,13 +25546,13 @@ var ENV_FALLBACK = {
 };
 function storePath5() {
   const dataDir = process.env["WAIRON_DATA_DIR"];
-  return dataDir ? path36.join(dataDir, "auth", "secrets.json") : null;
+  return dataDir ? path37.join(dataDir, "auth", "secrets.json") : null;
 }
 function readStore() {
   const p = storePath5();
   if (!p) return {};
   try {
-    return JSON.parse(fs27.readFileSync(p, "utf8"));
+    return JSON.parse(fs28.readFileSync(p, "utf8"));
   } catch {
     return {};
   }
@@ -24801,10 +25577,10 @@ function setSecret(key, value) {
   if (!p) throw new Error("WAIRON_DATA_DIR is not set \u2014 a running server needs it to store secrets.");
   const store = readStore();
   store[key] = value;
-  fs27.mkdirSync(path36.dirname(p), { recursive: true });
+  fs28.mkdirSync(path37.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs27.writeFileSync(tmp, JSON.stringify(store, null, 2) + "\n");
-  fs27.renameSync(tmp, p);
+  fs28.writeFileSync(tmp, JSON.stringify(store, null, 2) + "\n");
+  fs28.renameSync(tmp, p);
 }
 function listSecretKeys() {
   return Object.keys(readStore());
@@ -25012,17 +25788,17 @@ function verifySsoState(state) {
 }
 
 // src/server/organization.ts
-var fs28 = __toESM(require("fs"));
-var path37 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
+var path38 = __toESM(require("path"));
 var crypto6 = __toESM(require("crypto"));
 function storePath6(dataDir) {
-  return path37.join(dataDir, "organization.json");
+  return path38.join(dataDir, "organization.json");
 }
 function readState(dataDir) {
   const p = storePath6(dataDir);
   let raw;
   try {
-    raw = fs28.readFileSync(p, "utf8");
+    raw = fs29.readFileSync(p, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") return { units: [], placements: [] };
     throw new Error(`Failed to read organization store at ${p}: ${e.message}`);
@@ -25039,10 +25815,10 @@ function readState(dataDir) {
 }
 function persistState(dataDir, state) {
   const p = storePath6(dataDir);
-  fs28.mkdirSync(path37.dirname(p), { recursive: true });
+  fs29.mkdirSync(path38.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs28.writeFileSync(tmp, JSON.stringify(state, null, 2) + "\n");
-  fs28.renameSync(tmp, p);
+  fs29.writeFileSync(tmp, JSON.stringify(state, null, 2) + "\n");
+  fs29.renameSync(tmp, p);
 }
 var SLUG_PATTERN = /^[a-z0-9-]+$/;
 var UNIT_KINDS = ["business_entity", "department", "team", "group"];
@@ -25411,11 +26187,11 @@ function getOrganizationUnit(dataDir, id) {
 }
 
 // src/server/permissions.ts
-var fs29 = __toESM(require("fs"));
-var path38 = __toESM(require("path"));
+var fs30 = __toESM(require("fs"));
+var path39 = __toESM(require("path"));
 var import_crypto2 = require("crypto");
 function storePath7(dataDir) {
-  return path38.join(dataDir, "permissions.json");
+  return path39.join(dataDir, "permissions.json");
 }
 function assignmentKey(a) {
   return [a.subjectKind, a.subjectId ?? "", a.scopeKind, a.scopeId ?? "", a.capability].join("|");
@@ -25424,7 +26200,7 @@ function load4(dataDir) {
   const p = storePath7(dataDir);
   let raw;
   try {
-    raw = fs29.readFileSync(p, "utf8");
+    raw = fs30.readFileSync(p, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw new Error(`Cannot read permission store at ${p}: ${err.message}`);
@@ -25442,10 +26218,10 @@ function load4(dataDir) {
 }
 function replaceAll2(dataDir, assignments) {
   const p = storePath7(dataDir);
-  fs29.mkdirSync(path38.dirname(p), { recursive: true });
+  fs30.mkdirSync(path39.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs29.writeFileSync(tmp, JSON.stringify(assignments, null, 2) + "\n");
-  fs29.renameSync(tmp, p);
+  fs30.writeFileSync(tmp, JSON.stringify(assignments, null, 2) + "\n");
+  fs30.renameSync(tmp, p);
 }
 function registrySet(dataDir, assignment) {
   const assignments = load4(dataDir);
@@ -25531,8 +26307,8 @@ function getAssignment(dataDir, assignmentId) {
 }
 
 // src/server/roles.ts
-var fs30 = __toESM(require("fs"));
-var path39 = __toESM(require("path"));
+var fs31 = __toESM(require("fs"));
+var path40 = __toESM(require("path"));
 var BUILTIN_ROLES = [
   {
     id: SSO_ADMIN_ROLE_ID,
@@ -25550,13 +26326,13 @@ function isBuiltinRoleId(roleId) {
   return BUILTIN_ROLE_IDS.has(roleId);
 }
 function storePath8(dataDir) {
-  return path39.join(dataDir, "roles.json");
+  return path40.join(dataDir, "roles.json");
 }
 function load5(dataDir) {
   const p = storePath8(dataDir);
   let raw;
   try {
-    raw = fs30.readFileSync(p, "utf8");
+    raw = fs31.readFileSync(p, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw new Error(`Cannot read role store at ${p}: ${err.message}`);
@@ -25574,10 +26350,10 @@ function load5(dataDir) {
 }
 function replaceAll3(dataDir, roles) {
   const p = storePath8(dataDir);
-  fs30.mkdirSync(path39.dirname(p), { recursive: true });
+  fs31.mkdirSync(path40.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs30.writeFileSync(tmp, JSON.stringify(roles, null, 2) + "\n");
-  fs30.renameSync(tmp, p);
+  fs31.writeFileSync(tmp, JSON.stringify(roles, null, 2) + "\n");
+  fs31.renameSync(tmp, p);
 }
 function registryCreate(dataDir, role) {
   if (isBuiltinRoleId(role.id)) {
@@ -25811,131 +26587,14 @@ function actionableUnitIds(scopes) {
 }
 
 // src/server/projects.ts
-var fs31 = __toESM(require("fs"));
-var path40 = __toESM(require("path"));
-var ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
-function isValidProjectId(id) {
-  return typeof id === "string" && ID_RE.test(id);
-}
-function registryPath(dataDir) {
-  return path40.join(dataDir, "projects.json");
-}
-function load6(dataDir) {
-  try {
-    return JSON.parse(fs31.readFileSync(registryPath(dataDir), "utf8"));
-  } catch {
-    return [];
-  }
-}
-function save2(dataDir, records) {
-  const p = registryPath(dataDir);
-  fs31.mkdirSync(path40.dirname(p), { recursive: true });
-  const tmp = `${p}.tmp`;
-  fs31.writeFileSync(tmp, JSON.stringify(records, null, 2) + "\n");
-  fs31.renameSync(tmp, p);
-}
-function projectRoot(dataDir, id) {
-  return path40.join(dataDir, "projects", id);
-}
-function existingProjectRoot(dataDir, id) {
-  if (!isValidProjectId(id)) return null;
-  const rec = load6(dataDir).find((r) => r.id === id);
-  return rec ? rec.rootPath : null;
-}
-function createProjectRecord(dataDir, id) {
-  if (!isValidProjectId(id)) {
-    throw new Error(`Invalid project id "${id}" (allowed: lowercase letters, digits, hyphen).`);
-  }
-  const records = load6(dataDir);
-  if (records.some((r) => r.id === id)) {
-    throw new Error(`Project "${id}" already exists.`);
-  }
-  const root = projectRoot(dataDir, id);
-  fs31.mkdirSync(root, { recursive: true });
-  const record2 = {
-    id,
-    rootPath: root,
-    status: "active",
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  records.push(record2);
-  save2(dataDir, records);
-  return record2;
-}
-function registerLocalDevProject(dataDir, id, rootPath) {
-  if (!isValidProjectId(id)) {
-    throw new Error(`Invalid project id "${id}" (allowed: lowercase letters, digits, hyphen).`);
-  }
-  const records = load6(dataDir);
-  const existing = records.find((r) => r.id === id);
-  const record2 = {
-    id,
-    rootPath,
-    status: "active",
-    createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const next = existing ? records.map((r) => r.id === id ? record2 : r) : [...records, record2];
-  save2(dataDir, next);
-  return record2;
-}
-function listProjectRecords(dataDir) {
-  return load6(dataDir);
-}
-function removeProjectRecord(dataDir, id) {
-  const records = load6(dataDir);
-  const rec = records.find((r) => r.id === id);
-  if (rec) {
-    try {
-      fs31.rmSync(rec.rootPath, { recursive: true, force: true });
-    } catch {
-    }
-  }
-  save2(dataDir, records.filter((r) => r.id !== id));
-}
-function resolveProjectRoot(dataDir, principal, selector) {
-  const authorized = principal.projects;
-  const wildcard = authorized.includes("*");
-  let target;
-  if (selector) {
-    if (!wildcard && !authorized.includes(selector)) return null;
-    target = selector;
-  } else if (!wildcard && authorized.length === 1) {
-    target = authorized[0];
-  } else {
-    return null;
-  }
-  if (!isValidProjectId(target)) return null;
-  const rec = load6(dataDir).find((r) => r.id === target);
-  if (!rec || rec.status !== "active") return null;
-  return rec.rootPath;
-}
-
-// src/server/adapters.ts
-init_statehash();
-
-// src/core/lockfile.ts
-var fs32 = __toESM(require("fs"));
-var path41 = __toESM(require("path"));
+var fs35 = __toESM(require("fs"));
+var path44 = __toESM(require("path"));
+init_loader();
+init_yaml();
 init_fs();
-function lockPath() {
-  return aiDir("lock.json");
-}
-function readLockRecord() {
-  try {
-    return JSON.parse(fs32.readFileSync(lockPath(), "utf8"));
-  } catch {
-    return null;
-  }
-}
-function writeLockRecord(record2) {
-  const p = lockPath();
-  fs32.mkdirSync(path41.dirname(p), { recursive: true });
-  const tmp = `${p}.tmp`;
-  fs32.writeFileSync(tmp, JSON.stringify(record2, null, 2) + "\n");
-  fs32.renameSync(tmp, p);
-}
 
 // src/server/adapters.ts
+init_statehash();
 init_specs2();
 init_provision();
 init_validation();
@@ -25946,37 +26605,37 @@ init_types();
 init_server();
 
 // src/git/config.ts
-var fs33 = __toESM(require("fs"));
-var path42 = __toESM(require("path"));
+var fs32 = __toESM(require("fs"));
+var path41 = __toESM(require("path"));
 init_fs();
 function configPath() {
   return aiDir("git.json");
 }
 function readGitConfig() {
   try {
-    return JSON.parse(fs33.readFileSync(configPath(), "utf8"));
+    return JSON.parse(fs32.readFileSync(configPath(), "utf8"));
   } catch {
     return null;
   }
 }
 function writeGitConfig(config) {
   const p = configPath();
-  fs33.mkdirSync(path42.dirname(p), { recursive: true });
+  fs32.mkdirSync(path41.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs33.writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n");
-  fs33.renameSync(tmp, p);
+  fs32.writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n");
+  fs32.renameSync(tmp, p);
 }
 function clearGitConfig() {
   try {
-    fs33.rmSync(configPath(), { force: true });
+    fs32.rmSync(configPath(), { force: true });
   } catch {
   }
 }
 
 // src/git/adapter.ts
 var import_child_process3 = require("child_process");
-var fs34 = __toESM(require("fs"));
-var path43 = __toESM(require("path"));
+var fs33 = __toESM(require("fs"));
+var path42 = __toESM(require("path"));
 init_fs();
 function git(args, cwd) {
   return (0, import_child_process3.execFileSync)("git", args, {
@@ -26028,10 +26687,10 @@ function compareUrl(remote, defaultBranch, workingBranch) {
   return `${web}/compare/${encodeURIComponent(defaultBranch)}...${encodeURIComponent(workingBranch)}`;
 }
 function excludeLocalFiles() {
-  const excludePath = path43.join(getProjectRoot(), ".git", "info", "exclude");
+  const excludePath = path42.join(getProjectRoot(), ".git", "info", "exclude");
   try {
-    fs34.mkdirSync(path43.dirname(excludePath), { recursive: true });
-    fs34.appendFileSync(excludePath, "\n.wai/lock.json\n.wai/git.json\n");
+    fs33.mkdirSync(path42.dirname(excludePath), { recursive: true });
+    fs33.appendFileSync(excludePath, "\n.wai/lock.json\n.wai/git.json\n");
   } catch {
   }
 }
@@ -26096,39 +26755,39 @@ function configureSync(periodicSyncMinutes, skipIfClean) {
 }
 
 // src/producers/config.ts
-var fs35 = __toESM(require("fs"));
-var path44 = __toESM(require("path"));
+var fs34 = __toESM(require("fs"));
+var path43 = __toESM(require("path"));
 init_fs();
 function configPath2() {
   return aiDir("producers.json");
 }
-function load7() {
+function load6() {
   try {
-    return JSON.parse(fs35.readFileSync(configPath2(), "utf8"));
+    return JSON.parse(fs34.readFileSync(configPath2(), "utf8"));
   } catch {
     return [];
   }
 }
-function save3(configs) {
+function save2(configs) {
   const p = configPath2();
-  fs35.mkdirSync(path44.dirname(p), { recursive: true });
+  fs34.mkdirSync(path43.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs35.writeFileSync(tmp, JSON.stringify(configs, null, 2) + "\n");
-  fs35.renameSync(tmp, p);
+  fs34.writeFileSync(tmp, JSON.stringify(configs, null, 2) + "\n");
+  fs34.renameSync(tmp, p);
 }
 function readProducerConfig(target) {
-  return load7().find((c) => c.target === target) ?? null;
+  return load6().find((c) => c.target === target) ?? null;
 }
 function writeProducerConfig(config) {
-  const configs = load7().filter((c) => c.target !== config.target);
+  const configs = load6().filter((c) => c.target !== config.target);
   configs.push(config);
-  save3(configs);
+  save2(configs);
 }
 function clearProducerConfig(target) {
-  save3(load7().filter((c) => c.target !== target));
+  save2(load6().filter((c) => c.target !== target));
 }
 function listProducerConfigs() {
-  return load7();
+  return load6();
 }
 
 // src/producers/core-adapter.ts
@@ -26469,6 +27128,9 @@ var hostCore = {
    *  read of a bundled constant. */
   builtinProfileIds: () => [...BUILTIN_PROFILES]
 };
+function resolveContainedProjectPath(projectRoot2, projectPath) {
+  return assertContainedProjectPath(projectRoot2, projectPath);
+}
 function validateProjectAsComplete() {
   const config = loadProjectConfig();
   return validateAsComplete({ rules: config.rules, projectType: config.projectType });
@@ -26500,6 +27162,180 @@ var hostSdk = {
   extractArchive: (archive, destDir, limits) => sdkPortal.extractPack(archive, destDir, limits)
 };
 
+// src/server/projects.ts
+var ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+function isValidProjectId(id) {
+  return typeof id === "string" && ID_RE.test(id);
+}
+function registryPath(dataDir) {
+  return path44.join(dataDir, "projects.json");
+}
+function load7(dataDir) {
+  try {
+    return JSON.parse(fs35.readFileSync(registryPath(dataDir), "utf8"));
+  } catch {
+    return [];
+  }
+}
+function save3(dataDir, records) {
+  const p = registryPath(dataDir);
+  fs35.mkdirSync(path44.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp`;
+  fs35.writeFileSync(tmp, JSON.stringify(records, null, 2) + "\n");
+  fs35.renameSync(tmp, p);
+}
+function projectRoot(dataDir, id) {
+  return path44.join(dataDir, "projects", id);
+}
+function existingProjectRoot(dataDir, id) {
+  if (!isValidProjectId(id)) return null;
+  const rec = load7(dataDir).find((r) => r.id === id);
+  return rec ? rec.rootPath : null;
+}
+function createProjectRecord(dataDir, id) {
+  if (!isValidProjectId(id)) {
+    throw new Error(`Invalid project id "${id}" (allowed: lowercase letters, digits, hyphen).`);
+  }
+  const records = load7(dataDir);
+  if (records.some((r) => r.id === id)) {
+    throw new Error(`Project "${id}" already exists.`);
+  }
+  const root = projectRoot(dataDir, id);
+  fs35.mkdirSync(root, { recursive: true });
+  const record2 = {
+    id,
+    rootPath: root,
+    status: "active",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  records.push(record2);
+  save3(dataDir, records);
+  return record2;
+}
+function registerLocalDevProject(dataDir, id, rootPath) {
+  if (!isValidProjectId(id)) {
+    throw new Error(`Invalid project id "${id}" (allowed: lowercase letters, digits, hyphen).`);
+  }
+  const records = load7(dataDir);
+  const existing = records.find((r) => r.id === id);
+  const record2 = {
+    id,
+    rootPath,
+    status: "active",
+    createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const next = existing ? records.map((r) => r.id === id ? record2 : r) : [...records, record2];
+  save3(dataDir, next);
+  return record2;
+}
+function listProjectRecords(dataDir) {
+  return load7(dataDir);
+}
+function removeProjectRecord(dataDir, id) {
+  const records = load7(dataDir);
+  const rec = records.find((r) => r.id === id);
+  if (rec) {
+    try {
+      fs35.rmSync(rec.rootPath, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  save3(dataDir, records.filter((r) => r.id !== id));
+}
+var SUBPROJECT_SEPARATOR = "::";
+function parseQualifiedSelector(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  const [projectId, ...mounts] = value.split(SUBPROJECT_SEPARATOR);
+  if (!isValidProjectId(projectId)) return null;
+  if (mounts.some((m) => m.trim() === "")) return null;
+  return { projectId, mounts };
+}
+function findSubsystemSpec(root, subsystemId) {
+  const specsDir = aiPathsAt(root).specsDir();
+  if (!fs35.existsSync(specsDir)) return null;
+  for (const file of listFilesRecursive(specsDir, ".yaml")) {
+    let raw;
+    try {
+      raw = readYamlFile(file);
+    } catch {
+      continue;
+    }
+    if (!raw || typeof raw !== "object" || !("parentSystem" in raw)) continue;
+    if (raw.id !== subsystemId) continue;
+    const pp = raw.projectPath;
+    return typeof pp === "string" && pp.trim() !== "" ? { projectPath: pp } : {};
+  }
+  return null;
+}
+function resolveSubprojectMounts(projectId, projectRoot2, mounts) {
+  let root = projectRoot2;
+  let at = projectId;
+  for (const mount of mounts) {
+    const sub = findSubsystemSpec(root, mount);
+    if (!sub) {
+      throw new Error(
+        `unknown subproject mount "${mount}" on "${at}" \u2014 no subsystem with that id exists in its spec tree`
+      );
+    }
+    if (!sub.projectPath) {
+      throw new Error(
+        `subsystem "${mount}" on "${at}" is not a chained subproject (it carries no projectPath) \u2014 only a subsystem mounted via projectPath can be bound as a subproject`
+      );
+    }
+    root = resolveContainedProjectPath(root, sub.projectPath);
+    at = `${at}${SUBPROJECT_SEPARATOR}${mount}`;
+  }
+  return root;
+}
+function assertMintableNarrowingEntry(dataDir, entry) {
+  if (entry === "*") return;
+  const parsed = parseQualifiedSelector(entry);
+  if (!parsed) {
+    throw new Error(
+      `invalid project narrowing entry "${entry}" (expected a project id, optionally subproject-qualified as projectId::subsystemId)`
+    );
+  }
+  const rec = load7(dataDir).find((r) => r.id === parsed.projectId);
+  if (!rec) throw new Error(`unknown project "${parsed.projectId}"`);
+  if (parsed.mounts.length > 0) {
+    resolveSubprojectMounts(parsed.projectId, rec.rootPath, parsed.mounts);
+  }
+}
+function narrowingCovers(entry, target) {
+  return target === entry || target.startsWith(entry + SUBPROJECT_SEPARATOR);
+}
+function resolveProjectBinding(dataDir, principal, selector) {
+  const authorized = principal.projects;
+  const wildcard = authorized.includes("*");
+  let target;
+  if (selector) {
+    if (!wildcard && !authorized.some((e) => e !== "*" && narrowingCovers(e, selector))) return null;
+    target = selector;
+  } else if (!wildcard && authorized.length === 1) {
+    target = authorized[0];
+  } else {
+    return null;
+  }
+  const parsed = parseQualifiedSelector(target);
+  if (!parsed) return null;
+  const rec = load7(dataDir).find((r) => r.id === parsed.projectId);
+  if (!rec || rec.status !== "active") return null;
+  let rootPath = rec.rootPath;
+  if (parsed.mounts.length > 0) {
+    try {
+      rootPath = resolveSubprojectMounts(parsed.projectId, rec.rootPath, parsed.mounts);
+    } catch {
+      return null;
+    }
+  }
+  const binding = { rootPath, projectId: parsed.projectId };
+  if (parsed.mounts.length > 0) binding.subproject = parsed.mounts.join(SUBPROJECT_SEPARATOR);
+  return binding;
+}
+function resolveProjectRoot(dataDir, principal, selector) {
+  return resolveProjectBinding(dataDir, principal, selector)?.rootPath ?? null;
+}
+
 // src/server/errors.ts
 var UnauthenticatedError = class extends Error {
   constructor() {
@@ -28525,11 +29361,8 @@ function mintToken(cfg, credential, request) {
   }
   assertNotReservedSubjectId(cfg, [request.ownerUserId]);
   const projects = request.projects?.length ? request.projects : ["*"];
-  const knownProjects = new Set(listProjectRecords(cfg.dataDir).map((p) => p.id));
   for (const p of projects) {
-    if (p !== "*" && !knownProjects.has(p)) {
-      throw new Error(`unknown project "${p}"`);
-    }
+    assertMintableNarrowingEntry(cfg.dataDir, p);
   }
   const owner = findUserByRecordOrSubjectId(cfg.dataDir, request.ownerUserId);
   if (owner && owner.status !== "active") {
@@ -28566,12 +29399,21 @@ function revokeToken(cfg, credential, tokenId) {
 }
 function mintSelfToken(cfg, credential, projectId, write) {
   const principal = requirePrincipal5(cfg, credential);
-  if (authorize(cfg.dataDir, principal, PROJECT_READ_CAPABILITY2, "project", projectId).value !== "yes") {
+  const parsed = parseQualifiedSelector(projectId);
+  if (!parsed) {
+    throw new Error(
+      `invalid project id "${projectId}" (expected a project id, optionally subproject-qualified as projectId::subsystemId)`
+    );
+  }
+  if (authorize(cfg.dataDir, principal, PROJECT_READ_CAPABILITY2, "project", parsed.projectId).value !== "yes") {
     throw new ForbiddenError("caller lacks project:read on the requested project");
   }
-  if (write && authorize(cfg.dataDir, principal, PROJECT_WRITE_CAPABILITY2, "project", projectId).value !== "yes") {
+  if (write && authorize(cfg.dataDir, principal, PROJECT_WRITE_CAPABILITY2, "project", parsed.projectId).value !== "yes") {
     throw new ForbiddenError("caller lacks project:write on the requested project");
   }
+  if (parsed.mounts.length > 0) {
+    assertMintableNarrowingEntry(cfg.dataDir, projectId);
+  }
   const token = "wk_" + crypto10.randomBytes(24).toString("hex");
   const owner = auditActor(principal);
   const record2 = {
@@ -29183,12 +30025,12 @@ function resolveVisibility(observerProjectId, units, placements) {
   const best = /* @__PURE__ */ new Map();
   for (const placement of placements) {
     if (placement.projectId === observerProjectId) continue;
-    const path62 = chainOf(placement.unitId, unitById);
-    if (!path62.length) continue;
-    const closedOk = path62.every((u) => effectivePosture(u, unitById) !== "closed" || observerInside(u.id) || grantedTo(u));
+    const path61 = chainOf(placement.unitId, unitById);
+    if (!path61.length) continue;
+    const closedOk = path61.every((u) => effectivePosture(u, unitById) !== "closed" || observerInside(u.id) || grantedTo(u));
     if (!closedOk) continue;
-    const crossTenant = !tenantRoots.has(path62[path62.length - 1].id);
-    if (crossTenant && !path62.some(grantedTo)) continue;
+    const crossTenant = !tenantRoots.has(path61[path61.length - 1].id);
+    if (crossTenant && !path61.some(grantedTo)) continue;
     if (crossTenant && directUnits.length === 0) continue;
     const distance = crossTenant ? "partner" : sameBranch(placement.unitId) ? "department" : "instance";
     const existing = best.get(placement.projectId);
@@ -30127,10 +30969,9 @@ function migratePermissionModel(dataDir, apply) {
 // src/server/http.ts
 var http2 = __toESM(require("http"));
 var fs49 = __toESM(require("fs"));
-var path59 = __toESM(require("path"));
+var path58 = __toESM(require("path"));
 
 // src/server/request.ts
-var path58 = __toESM(require("path"));
 var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 init_fs();
 
@@ -32537,7 +33378,31 @@ function reshapeLandscapeGraph(model, level) {
   }
   const kept = nodes.filter((n) => n.level <= level);
   const keptIds = new Set(kept.map((n) => n.id));
-  const edges = model.edges.filter((e) => keptIds.has(e.from) && keptIds.has(e.to));
+  const projectNodeIdByProject = /* @__PURE__ */ new Map();
+  const interfaceOwnerProject = /* @__PURE__ */ new Map();
+  for (const n of model.nodes) {
+    if (n.projectId === void 0) continue;
+    if (n.nodeKind === "project") projectNodeIdByProject.set(n.projectId, n.id);
+    else if (n.nodeKind === "publicInterface") interfaceOwnerProject.set(n.id, n.projectId);
+  }
+  const retarget = (endpoint) => {
+    if (keptIds.has(endpoint)) return endpoint;
+    const owner = interfaceOwnerProject.get(endpoint);
+    const projectNode = owner === void 0 ? void 0 : projectNodeIdByProject.get(owner);
+    return projectNode !== void 0 && keptIds.has(projectNode) ? projectNode : void 0;
+  };
+  const edges = [];
+  for (const e of model.edges) {
+    if (keptIds.has(e.from) && keptIds.has(e.to)) {
+      edges.push(e);
+      continue;
+    }
+    if (e.relationId === void 0) continue;
+    const from = retarget(e.from);
+    const to = retarget(e.to);
+    if (from === void 0 || to === void 0 || from === to) continue;
+    edges.push({ ...e, from, to });
+  }
   return {
     tier: "landscape",
     nodes: kept,
@@ -35144,8 +36009,8 @@ var RealtimeHub = class {
    *  complete the handshake, and register the connection. A bad path or session
    *  destroys the socket. */
   handleUpgrade(cfg, req, socket) {
-    const path62 = (req.url ?? "/").split("?")[0];
-    if (path62 !== REALTIME_PATH || !isWebSocketUpgrade(req)) {
+    const path61 = (req.url ?? "/").split("?")[0];
+    if (path61 !== REALTIME_PATH || !isWebSocketUpgrade(req)) {
       socket.destroy();
       return;
     }
@@ -35290,7 +36155,7 @@ function deriveMcpOutcome(response) {
   if (r.result && typeof r.result === "object" && r.result.isError) return "failed";
   return "success";
 }
-function auditToolCall(dataDir, principal, projectId, body, outcome) {
+function auditToolCall(dataDir, principal, projectId, body, outcome, subproject) {
   const target = mcpToolTarget(body);
   if (!target) return;
   const actor = principal.subject ?? {
@@ -35308,7 +36173,8 @@ function auditToolCall(dataDir, principal, projectId, body, outcome) {
     actor,
     tokenId: principal.tokenId,
     projectId,
-    target
+    target,
+    ...subproject ? { metadata: JSON.stringify({ subproject }) } : {}
   };
   try {
     appendAuditEvent(dataDir, event, DEFAULT_AUDIT_POLICY);
@@ -35512,8 +36378,8 @@ async function handleMcpRequest(cfg, req, res, body, credential) {
       permissionSubject: { subjectId: "anonymous", roleBindings: [], instanceAdmin: true }
     };
   }
-  const root = resolveProjectRoot(cfg.dataDir, principal, projectSelector(req));
-  if (!root) {
+  const binding = resolveProjectBinding(cfg.dataDir, principal, projectSelector(req));
+  if (!binding) {
     sendJson(res, 403, { error: "project not authorized, unknown, or not specified" });
     return;
   }
@@ -35528,19 +36394,20 @@ async function handleMcpRequest(cfg, req, res, body, credential) {
     });
     return;
   }
-  await runWithProjectRoot(root, async () => {
-    const projectId = path58.basename(root);
+  await runWithProjectRoot(binding.rootPath, async () => {
+    const projectId = binding.projectId;
+    const subproject = binding.subproject;
     const dispatchedResponse = await dispatchProjectLifecycleTool(cfg, cred, projectId, body);
     if (dispatchedResponse !== void 0) {
       sendJson(res, 200, dispatchedResponse);
-      auditToolCall(cfg.dataDir, principal, projectId, body, deriveMcpOutcome(dispatchedResponse));
+      auditToolCall(cfg.dataDir, principal, projectId, body, deriveMcpOutcome(dispatchedResponse), subproject);
       for (const ch of mcpChangeChannels(body, projectId, dispatchedResponse)) publishChange(ch);
       return;
     }
     const permissionError = dataPlanePermissionError(cfg, principal, projectId, body);
     if (permissionError !== void 0) {
       sendJson(res, 200, permissionError);
-      auditToolCall(cfg.dataDir, principal, projectId, body, deriveMcpOutcome(permissionError));
+      auditToolCall(cfg.dataDir, principal, projectId, body, deriveMcpOutcome(permissionError), subproject);
       return;
     }
     const server = createScopedServer();
@@ -35561,7 +36428,7 @@ async function handleMcpRequest(cfg, req, res, body, credential) {
     };
     await server.connect(transport);
     await transport.handleRequest(req, res, body);
-    auditToolCall(cfg.dataDir, principal, projectId, body, deriveMcpOutcome(response));
+    auditToolCall(cfg.dataDir, principal, projectId, body, deriveMcpOutcome(response), subproject);
     for (const ch of mcpChangeChannels(body, projectId, response)) publishChange(ch);
   });
 }
@@ -35996,7 +36863,7 @@ function routeData(cfg, req, res) {
 }
 function readExposurePolicyFile(dataDir) {
   try {
-    const raw = fs49.readFileSync(path59.join(dataDir, "exposure-policy.json"), "utf8");
+    const raw = fs49.readFileSync(path58.join(dataDir, "exposure-policy.json"), "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? parsed : void 0;
   } catch {
@@ -36681,9 +37548,9 @@ function seedDemoTree() {
 
 // src/commands/host.ts
 function resolveHostConfig(options) {
-  const dataDir = options.dataDir || process.env["WAIRON_DATA_DIR"] || path60.join(os9.homedir(), ".wairon", "data");
+  const dataDir = options.dataDir || process.env["WAIRON_DATA_DIR"] || path59.join(os10.homedir(), ".wairon", "data");
   if (!process.env["WAIRON_PACKS_DIR"]) {
-    process.env["WAIRON_PACKS_DIR"] = path60.join(dataDir, "packs");
+    process.env["WAIRON_PACKS_DIR"] = path59.join(dataDir, "packs");
   }
   const cfg = {
     host: options.host || "0.0.0.0",
@@ -36808,13 +37675,13 @@ function openBrowser(url) {
 }
 async function runDev(options = {}) {
   const cwd = process.cwd();
-  if (!fs50.existsSync(path60.join(cwd, ".wai"))) {
+  if (!fs50.existsSync(path59.join(cwd, ".wai"))) {
     throw new WaironError(
       "No .wai/ found in the current directory. Run `wairon dev` from a wairon project root (or run `wairon init` first)."
     );
   }
   const hash = crypto20.createHash("sha256").update(cwd).digest("hex").slice(0, 16);
-  const dataDir = path60.join(os9.tmpdir(), "wairon-dev", hash);
+  const dataDir = path59.join(os10.tmpdir(), "wairon-dev", hash);
   fs50.mkdirSync(dataDir, { recursive: true });
   registerLocalDevProject(dataDir, "local", cwd);
   const port = options.port ? Number(options.port) : 8080;
@@ -37223,8 +38090,8 @@ async function runHostPacks(action, options = {}) {
       }
       case "install": {
         if (!options.file) throw new WaironError("`--file <path>` (a declarative pack YAML) is required for install.");
-        const name = options.name ?? path60.basename(options.file).replace(/\.(ya?ml)$/i, "");
-        const content = fs50.readFileSync(path60.resolve(options.file), "utf8");
+        const name = options.name ?? path59.basename(options.file).replace(/\.(ya?ml)$/i, "");
+        const content = fs50.readFileSync(path59.resolve(options.file), "utf8");
         const desc = project2 ? installProjectPack(cfg, cred, project2, name, content) : installGlobalPack(cfg, cred, name, content);
         logger.success(`Installed ${scope} pack "${desc.name}" (${desc.profiles} profile(s), ${desc.languages} language(s)).`);
         if (project2) logger.info("Committed with the project \u2014 every clone and CI will enforce it.");
@@ -37430,13 +38297,27 @@ async function runSurface(action, options = {}) {
       for (const p of written) logger.info(`  ${p}`);
       return;
     }
+    case "externals": {
+      const entries = listExternalInterfaces();
+      if (!entries.length) {
+        logger.info("No external surfaces available (.wai/surfaces/ holds no snapshots).");
+        return;
+      }
+      const freshness = (f) => f === "fresh" ? import_chalk19.default.green(f) : f === "stale" ? import_chalk19.default.yellow(f) : import_chalk19.default.gray(f);
+      for (const e of entries) {
+        logger.info(
+          `${e.sourceKind.padEnd(8)} ${import_chalk19.default.cyan(e.projectName)} [${e.origin}] ${freshness(e.freshness)} \u2014 ${e.interfaceIds.length ? e.interfaceIds.join(", ") : "(no interfaces)"}`
+        );
+      }
+      return;
+    }
     default:
-      throw new WaironError(`Unknown surface action "${action}" (supported: export, import, list, generate-children).`);
+      throw new WaironError(`Unknown surface action "${action}" (supported: export, import, list, generate-children, externals).`);
   }
 }
 
 // src/commands/subsystem.ts
-var path61 = __toESM(require("path"));
+var path60 = __toESM(require("path"));
 init_logger();
 init_errors();
 init_fs();
@@ -37472,9 +38353,9 @@ async function runSubsystemAdd(id, options = {}) {
     updatedAt: now
   };
   createChainedSubsystem(subsystem, displayName);
-  const childDir = path61.resolve(getProjectRoot(), options.projectPath);
+  const childDir = path60.resolve(getProjectRoot(), options.projectPath);
   logger.success(`Added external subsystem "${id}" \u2192 ${options.projectPath}`);
-  logger.info(`Scaffolded child project at ${path61.relative(process.cwd(), childDir) || "."}`);
+  logger.info(`Scaffolded child project at ${path60.relative(process.cwd(), childDir) || "."}`);
   logger.info(`Design its spec tree from this parent using namespaced ids (e.g. ${id}::<component>).`);
 }
 async function runSubsystemMove(id, options = {}) {
@@ -37497,9 +38378,9 @@ async function runSubsystemExternalize(id, options = {}) {
     throw new WaironError("--project-path (the subproject destination) is required.");
   }
   externalizeSubsystem(id, options.projectPath);
-  const childDir = path61.resolve(getProjectRoot(), options.projectPath);
+  const childDir = path60.resolve(getProjectRoot(), options.projectPath);
   logger.success(`Externalized subsystem "${id}" \u2192 ${options.projectPath}`);
-  logger.info(`Moved its specs into ${path61.relative(process.cwd(), childDir) || "."} (now a standalone subproject).`);
+  logger.info(`Moved its specs into ${path60.relative(process.cwd(), childDir) || "."} (now a standalone subproject).`);
   logger.info("Move the source code there yourself, then run `wairon validate` to confirm the tree.");
 }
 async function runSubsystemInternalize(id) {
@@ -37538,8 +38419,64 @@ program.command("generate").description("Generate agent output files from the sp
     dryRun: opts.dryRun
   });
 });
+async function runLock2(options) {
+  assertProjectInitialized();
+  if (!pathExists(AI_PATHS.specsSystem())) {
+    logger.error("No SDD spec tree found (.wai/specs). Nothing to lock.");
+    process.exit(1);
+  }
+  const projectConfig = loadProjectConfig();
+  logger.info("Analyzing and validating specifications in-memory...");
+  const dry = validateAsComplete({
+    rules: projectConfig.rules,
+    projectType: projectConfig.projectType,
+    scopeSubsystem: options.subsystem,
+    recursive: options.recursive ?? true
+  });
+  const errors = dry.issues.filter((i) => i.severity === "error");
+  if (errors.length > 0) {
+    logger.header("Cannot lock \u2014 the spec tree does not validate as complete");
+    let errorCount = 0;
+    const MAX_PRINT = 100;
+    let skippedErrors = 0;
+    for (const i of errors) {
+      if (errorCount < MAX_PRINT) {
+        logger.error(`${i.specId ? `[${i.specId}] ` : ""}[${i.code}] ${i.message}`);
+        errorCount++;
+      } else {
+        skippedErrors++;
+      }
+    }
+    if (skippedErrors > 0) {
+      logger.error(`... and ${skippedErrors} more error(s) omitted.`);
+    }
+    logger.blank();
+    logger.info("Fix the errors above, then run `wairon lock` again. Nothing was changed.");
+    process.exit(1);
+  }
+  logger.header("Lock SDD specs");
+  const record2 = await runLock(options, dry);
+  if (!record2) {
+    logger.info("Cancelled. Nothing was changed.");
+    return;
+  }
+  const childPaths = generateChildSnapshots();
+  if (childPaths.length > 0) {
+    logger.blank();
+    logger.success(`Regenerated the family/sibling surfaces into ${childPaths.length} chained child snapshot(s):`);
+    for (const p of childPaths) logger.info(`  ${p}`);
+  }
+  logger.blank();
+  await runGenerate({ domain: options.subsystem });
+  logger.blank();
+  logger.success("Specs locked and agent topology generated.");
+  logger.info(`Lock record written (.wai/lock.json): stateId ${record2.stateId.algorithm}:${record2.stateId.digest} \u2014 status ${record2.status}.`);
+  logger.warn(
+    "Restart any running AI agent sessions (Claude Code / Antigravity / Codex) so the newly generated implementer agents load \u2014 they are not picked up mid-session."
+  );
+}
 program.command("lock").description("Final check before implementation: validate the spec tree as complete, freeze all specs to complete, and (re)generate the agent topology \u2014 only if it validates").option("-y, --yes", "skip the confirmation prompt (for scripts / CI)").option("--subsystem <id>", "only lock specs in the specified subsystem").option("--no-recursive", "do not recursively validate subprojects").action(async (opts) => {
-  await runLock({ yes: opts.yes, subsystem: opts.subsystem, recursive: opts.recursive });
+  await runLock2({ yes: opts.yes, subsystem: opts.subsystem, recursive: opts.recursive });
 });
 program.command("validate").description("Validate the project configuration and the SDD Spec Tree").option("--ci", "treat warnings as errors for CI pipelines").option("--subsystem <id>", "only validate the specified subsystem (granular)").option("--no-recursive", "do not recursively validate subprojects").action(async (opts) => {
   await runValidate({ ci: opts.ci, subsystem: opts.subsystem, recursive: opts.recursive });
@@ -37655,7 +38592,7 @@ mcpCmd.command("status").description("Show whether the wairon MCP server is regi
 program.command("produce <target>").description("project the local project's specs to a producer target (notion | miro)").option("--page <id>", "parent page/board id in the target").option("--token <token>", "integration token (else env, else interactive prompt)").action(async (target, opts) => {
   await runProduce(target, { page: opts.page, token: opts.token });
 });
-program.command("surface <action>").description("public surface exchange: export | import | list | generate-children").option("--audience <level>", "export ceiling: project | department | instance | partner | external (default instance)").option("--format <fmt>", "export format: native | openapi (default native)").option("--out <path>", "export output path (else print)").option("--portal <id>", "export: select one portal's OpenAPI spec (a multi-portal project renders one document per portal)").option("--source <path>", "import: the surface document (native snapshot YAML or OpenAPI)").option("--origin <origin>", "import provenance: exchanged | authored (default authored)").action(async (action, opts) => {
+program.command("surface <action>").description("public surface exchange: export | import | list | generate-children | externals").option("--audience <level>", "export ceiling: project | department | instance | partner | external (default instance)").option("--format <fmt>", "export format: native | openapi (default native)").option("--out <path>", "export output path (else print)").option("--portal <id>", "export: select one portal's OpenAPI spec (a multi-portal project renders one document per portal)").option("--source <path>", "import: the surface document (native snapshot YAML or OpenAPI)").option("--origin <origin>", "import provenance: exchanged | authored (default authored)").action(async (action, opts) => {
   await runSurface(action, {
     audience: opts.audience,
     format: opts.format,