@wairon/cli 5.1.1-dev.84 → 5.1.1-dev.85

package/dist/index.js

@@ -2510,8 +2510,8 @@ var require_dist = __commonJS({
       maxCompressionRatio: 100,
       maxDepth: 16
     };
-    function parseManifest(text2) {
-      const raw = (0, import_js_yaml.load)(text2);
+    function parseManifest(text3) {
+      const raw = (0, import_js_yaml.load)(text3);
       const manifest = validateEnvelope(raw);
       if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION) {
         throw new Error("unsupported pack-archive formatVersion (newer than this wairon understands)");
@@ -2597,7 +2597,7 @@ var require_dist = __commonJS({
       if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION) {
         return false;
       }
-      if (manifest.minWaironVersion && isBelow(waironVersion, manifest.minWaironVersion)) {
+      if (manifest.minWaironVersion && isBelow2(waironVersion, manifest.minWaironVersion)) {
         return false;
       }
       return true;
@@ -2662,7 +2662,7 @@ var require_dist = __commonJS({
     function sha2562(data) {
       return (0, import_crypto3.createHash)("sha256").update(data).digest("hex");
     }
-    function isBelow(running, minimum) {
+    function isBelow2(running, minimum) {
       const [rMaj, rMin, rPat] = parseSemverCore(running);
       const [mMaj, mMin, mPat] = parseSemverCore(minimum);
       if (rMaj !== mMaj) return rMaj < mMaj;
@@ -2689,8 +2689,8 @@ var require_dist = __commonJS({
     var DERIVED_ROOTS = ["generated", "docs"];
     var EXECUTABLE_EXT_RE = /\.(c|m)?js$/i;
     var WAI_SEGMENT = ".wai";
-    function parseTreeManifest(text2) {
-      const raw = (0, import_js_yaml2.load)(text2);
+    function parseTreeManifest(text3) {
+      const raw = (0, import_js_yaml2.load)(text3);
       const manifest = validateEnvelope2(raw);
       if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION2) {
         throw new Error("unsupported tree-archive formatVersion (newer than this wairon understands)");
@@ -2791,7 +2791,7 @@ var require_dist = __commonJS({
       if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION2) {
         return false;
       }
-      if (manifest.minWaironVersion && isBelow2(waironVersion, manifest.minWaironVersion)) {
+      if (manifest.minWaironVersion && isBelow22(waironVersion, manifest.minWaironVersion)) {
         return false;
       }
       return true;
@@ -2864,7 +2864,7 @@ var require_dist = __commonJS({
     function sha25622(data) {
       return (0, import_crypto22.createHash)("sha256").update(data).digest("hex");
     }
-    function isBelow2(running, minimum) {
+    function isBelow22(running, minimum) {
       const [rMaj, rMin, rPat] = parseSemverCore2(running);
       const [mMaj, mMin, mPat] = parseSemverCore2(minimum);
       if (rMaj !== mMaj) return rMaj < mMaj;
@@ -3061,7 +3061,7 @@ var require_dist = __commonJS({
       return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
     }
     var fs21 = __toESM2(require("fs"));
-    var path37 = __toESM2(require("path"));
+    var path38 = __toESM2(require("path"));
     var import_fflate = require_node();
     var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".hg", ".svn"]);
     function listEntries(archive) {
@@ -3099,8 +3099,8 @@ var require_dist = __commonJS({
     }
     function writeTree(destDir, files) {
       for (const file of files) {
-        const absolute = path37.join(destDir, file.path);
-        fs21.mkdirSync(path37.dirname(absolute), { recursive: true });
+        const absolute = path38.join(destDir, file.path);
+        fs21.mkdirSync(path38.dirname(absolute), { recursive: true });
         fs21.writeFileSync(absolute, file.contents);
       }
     }
@@ -3113,10 +3113,10 @@ var require_dist = __commonJS({
       for (const entry of fs21.readdirSync(current2, { withFileTypes: true })) {
         if (entry.isDirectory()) {
           if (SKIP_DIRS.has(entry.name)) continue;
-          walkPackDir(root, path37.join(current2, entry.name), out);
+          walkPackDir(root, path38.join(current2, entry.name), out);
         } else if (entry.isFile()) {
-          const absolute = path37.join(current2, entry.name);
-          const relative22 = path37.relative(root, absolute).split(path37.sep).join("/");
+          const absolute = path38.join(current2, entry.name);
+          const relative22 = path38.relative(root, absolute).split(path38.sep).join("/");
           out.push({ path: relative22, contents: fs21.readFileSync(absolute) });
         }
       }
@@ -3176,8 +3176,8 @@ var require_dist = __commonJS({
         throw new Error("pack build requires a wairon-pack.yaml envelope (run `wairon pack init` to scaffold one)");
       }
       const manifest = parseManifest(decode(envelope.contents));
-      const identity = readInnerIdentity(files, manifest);
-      verifyIdentity(manifest, identity.name, identity.version);
+      const identity2 = readInnerIdentity(files, manifest);
+      verifyIdentity(manifest, identity2.name, identity2.version);
       const sealed = sealIntegrity(manifest, files, `@wairon/sdk@${SDK_VERSION}`, (/* @__PURE__ */ new Date()).toISOString());
       const sealedText = serializeManifest(sealed);
       const finalFiles = upsertEnvelope(files, sealedText);
@@ -3408,6 +3408,7 @@ __export(src_exports, {
   ComplexityRuleConfigSchema: () => ComplexityRuleConfigSchema,
   ComponentSpecSchema: () => ComponentSpecSchema,
   ComponentTypeSchema: () => ComponentTypeSchema,
+  CompositionConfigSchema: () => CompositionConfigSchema,
   ConfigValidationError: () => ConfigValidationError,
   ConformanceRuleConfigSchema: () => ConformanceRuleConfigSchema,
   ConformanceTierSchema: () => ConformanceTierSchema,
@@ -3462,6 +3463,7 @@ __export(src_exports, {
   PROJECT_ID_RE: () => PROJECT_ID_RE,
   PROJECT_KINDS: () => PROJECT_KINDS,
   PUBLIC_NAME_RE: () => PUBLIC_NAME_RE,
+  PackRequirementSchema: () => PackRequirementSchema,
   PackSelectionSchema: () => PackSelectionSchema,
   ParallelBranchSchema: () => ParallelBranchSchema,
   PathsConfigSchema: () => PathsConfigSchema,
@@ -3517,6 +3519,7 @@ __export(src_exports, {
   WaironError: () => WaironError,
   activeTargetTypes: () => activeTargetTypes2,
   addDomain: () => addDomain,
+  admits: () => admits,
   aiDir: () => aiDir,
   aiDirAt: () => aiDirAt,
   aiPathsAt: () => aiPathsAt,
@@ -3639,6 +3642,7 @@ __export(src_exports, {
   loadComponentSpecs: () => loadComponentSpecs,
   loadExtensionPacks: () => loadExtensionPacks,
   loadExtensions: () => loadExtensions,
+  loadExtensionsFor: () => loadFor,
   loadImplementationSpec: () => loadImplementationSpec,
   loadImplementationSpecs: () => loadImplementationSpecs,
   loadInterfaceSpec: () => loadInterfaceSpec,
@@ -3678,7 +3682,9 @@ __export(src_exports, {
   packDirEntry: () => packDirEntry,
   packEntryLabel: () => packEntryLabel,
   packEntryRef: () => packEntryRef,
+  packManifest: () => manifestOf,
   packStoreDir: () => packStoreDir,
+  parseDeclarativePack: () => parseDeclarativePack,
   parseDeclaredCall: () => parseDeclaredCall,
   parseYaml: () => parseYaml,
   passesIntentFloor: () => passesIntentFloor,
@@ -3691,6 +3697,7 @@ __export(src_exports, {
   projectIdentity: () => projectIdentity,
   provisionProject: () => provisionProject,
   qualifiedTypeId: () => qualifiedTypeId,
+  rangeProblem: () => rangeProblem,
   readFileOrNull: () => readFileOrNull,
   readJsonFile: () => readJsonFile,
   readLockRecord: () => readLockRecord,
@@ -3707,6 +3714,7 @@ __export(src_exports, {
   renameMethod: () => renameMethod,
   renderDiagram: () => renderDiagram,
   repairForeignStepFields: () => repairForeignStepFields,
+  requiredPolicies: () => requiredPolicies,
   resolveAgentTopology: () => resolveAgentTopology,
   resolveBudget: () => resolveBudget,
   resolveChainingParent: () => resolveChainingParent,
@@ -3751,6 +3759,7 @@ __export(src_exports, {
   upsertPackSelection: () => upsertPackSelection,
   validateFamily: () => validateFamily,
   validateProject: () => validateProject,
+  withPack: () => withPack,
   writeFile: () => writeFile,
   writeFileIfChanged: () => writeFileIfChanged,
   writeJsonFile: () => writeJsonFile,
@@ -4192,7 +4201,7 @@ var AgentBriefSchema = import_zod2.z.object({
   profile: ExecutionProfileSchema.optional(),
   budget: ExecutionBudgetSchema.optional()
 });
-function createAgentRecord(partial) {
+function createAgentRecord(partial2) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return AgentRecordSchema.parse({
     description: "",
@@ -4205,10 +4214,32 @@ function createAgentRecord(partial) {
     targets: ["claude"],
     createdAt: now,
     updatedAt: now,
-    ...partial
+    ...partial2
   });
 }
 
+// src/utils/version.ts
+function isNewerVersion(current2, candidate) {
+  const baseVersion = (v) => v.replace(/-.*$/, "");
+  const preRelease = (v) => {
+    const match = v.match(/-(.+)\.(\d+)$/);
+    return match ? { label: match[1], n: parseInt(match[2], 10) } : null;
+  };
+  const parse = (v) => baseVersion(v).split(".").map((n) => parseInt(n, 10) || 0);
+  const [cMaj, cMin, cPat] = parse(current2);
+  const [nMaj, nMin, nPat] = parse(candidate);
+  if (nMaj !== cMaj) return nMaj > cMaj;
+  if (nMin !== cMin) return nMin > cMin;
+  if (nPat !== cPat) return nPat > cPat;
+  const cPre = preRelease(current2);
+  const nPre = preRelease(candidate);
+  if (!cPre && !nPre) return false;
+  if (!cPre && nPre) return false;
+  if (cPre && !nPre) return true;
+  if (cPre && nPre) return nPre.n > cPre.n;
+  return false;
+}
+
 // src/models/project.ts
 var BuiltinTargetConfigSchema = import_zod3.z.object({
   type: import_zod3.z.enum(["claude", "gemini", "agy", "cursor", "copilot", "codex"]),
@@ -4541,6 +4572,15 @@ var MemberDeclarationSchema = import_zod3.z.object({
   /** The member's public names this project imports, exactly as an external's `use`. */
   use: import_zod3.z.array(import_zod3.z.string()).optional()
 });
+var plainString = import_zod3.z.preprocess((v) => v === void 0 || v === null ? "" : String(v), import_zod3.z.string());
+var PackRequirementSchema = import_zod3.z.object({
+  pack: plainString,
+  version: plainString,
+  profile: import_zod3.z.string().optional()
+});
+var CompositionConfigSchema = import_zod3.z.object({
+  requirePolicies: import_zod3.z.array(PackRequirementSchema).optional()
+});
 var ProjectConfigSchema = import_zod3.z.object({
   /**
    * Schema version — used to detect incompatible config formats in future
@@ -4577,6 +4617,15 @@ var ProjectConfigSchema = import_zod3.z.object({
    * `projectPath` mount still loads for one release (DEPRECATED_MOUNT_FORM).
    */
   members: import_zod3.z.record(import_zod3.z.union([import_zod3.z.string(), MemberDeclarationSchema])).optional(),
+  /**
+   * What this project requires of the projects it contains when they are
+   * composed: `requirePolicies`, the packs each member must select (by semver
+   * range, optionally one profile). This project's own gate judges only its
+   * syntax (POLICY_REQUIREMENT_INVALID); the family run judges members against
+   * it, and createMember reads it once when it scaffolds a new member. No
+   * member's own gate reads it. Written by hand.
+   */
+  composition: CompositionConfigSchema.optional(),
   /**
    * The type/profile of the project, which configures targeted guidelines, rules,
    * templates, and validation constraints. Open string: built-ins are backend,
@@ -4684,6 +4733,135 @@ function declaredPackNames(config) {
 function declaredProfileIds(config) {
   return [...new Set(config.profileSelection?.profileIds ?? [])];
 }
+function withPack(config, entry, remove = false) {
+  const packs = config.extensions?.packs ?? [];
+  const same = (e) => typeof entry === "string" ? e === entry : typeof e !== "string" && e.name === entry.name;
+  const others = packs.filter((e) => !same(e));
+  let next;
+  if (remove) next = others;
+  else if (typeof entry === "string") next = packs.includes(entry) ? packs : [...packs, entry];
+  else next = [...others, entry];
+  return { ...config, extensions: { useGlobalPacks: false, ...config.extensions, packs: next } };
+}
+function requiredPolicies(config) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const requirement of config.composition?.requirePolicies ?? []) {
+    if (seen.has(requirement.pack)) continue;
+    seen.add(requirement.pack);
+    out.push(requirement);
+  }
+  return out;
+}
+var CONCRETE_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+var PARTIAL_RE = /^v?(\d+|[xX*])(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+var OPERATOR_RE = /^(>=|<=|>|<|=|\^|~)/;
+function concrete(v) {
+  const m = CONCRETE_RE.exec(v.trim());
+  if (!m) return null;
+  return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]), ...m[4] ? { pre: m[4] } : {} };
+}
+var text = (v) => `${v.major}.${v.minor}.${v.patch}${v.pre ? `-${v.pre}` : ""}`;
+function compare(a, b) {
+  if (isNewerVersion(text(a), text(b))) return -1;
+  if (isNewerVersion(text(b), text(a))) return 1;
+  return 0;
+}
+function partial(v) {
+  const m = PARTIAL_RE.exec(v);
+  if (!m) return null;
+  const num = (s) => s === void 0 || /^[xX*]$/.test(s) ? null : Number(s);
+  const major = num(m[1]);
+  const minor = major === null ? null : num(m[2]);
+  const patch = minor === null ? null : num(m[3]);
+  if (m[4] && patch === null) return null;
+  return { major, minor, patch, ...m[4] ? { pre: m[4] } : {} };
+}
+var cv = (major, minor, patch, pre) => ({ major, minor, patch, ...pre ? { pre } : {} });
+function nextOf(p) {
+  if (p.minor === null) return cv(p.major + 1, 0, 0);
+  return cv(p.major, p.minor + 1, 0);
+}
+function expand(token) {
+  const opMatch = OPERATOR_RE.exec(token);
+  const op = opMatch ? opMatch[1] : "";
+  const p = partial(token.slice(op.length));
+  if (!p) return null;
+  const low = cv(p.major ?? 0, p.minor ?? 0, p.patch ?? 0, p.pre);
+  const exact = p.patch !== null;
+  if (p.major === null) return op === "<" || op === ">" ? [{ op: "<", version: cv(0, 0, 0) }] : [];
+  switch (op) {
+    case "":
+    case "=":
+      return exact ? [{ op: "=", version: low }] : [{ op: ">=", version: low }, { op: "<", version: nextOf(p) }];
+    case "^": {
+      const upper = p.major > 0 || p.minor === null ? cv(p.major + 1, 0, 0) : p.minor > 0 || p.patch === null ? cv(0, p.minor + 1, 0) : cv(0, 0, p.patch + 1);
+      return [{ op: ">=", version: low }, { op: "<", version: upper }];
+    }
+    case "~":
+      return [{ op: ">=", version: low }, { op: "<", version: p.minor === null ? cv(p.major + 1, 0, 0) : cv(p.major, p.minor + 1, 0) }];
+    case ">=":
+      return [{ op: ">=", version: low }];
+    case "<":
+      return [{ op: "<", version: low }];
+    case ">":
+      return exact ? [{ op: ">", version: low }] : [{ op: ">=", version: nextOf(p) }];
+    case "<=":
+      return exact ? [{ op: "<=", version: low }] : [{ op: "<", version: nextOf(p) }];
+    default:
+      return null;
+  }
+}
+function readRange(range) {
+  if (range.trim() === "") return { problem: "the range is empty" };
+  const alternatives = [];
+  for (const raw of range.split("||")) {
+    const tokens = raw.trim().split(/\s+/).filter((t) => t !== "");
+    const joined = [];
+    for (const t of tokens) {
+      if (joined.length > 0 && /^(>=|<=|>|<|=|\^|~)$/.test(joined[joined.length - 1])) joined[joined.length - 1] += t;
+      else joined.push(t);
+    }
+    const comparators = [];
+    for (const token of joined) {
+      const expanded = expand(token);
+      if (!expanded) return { problem: `"${token}" is neither a version, an x-range nor a comparator` };
+      comparators.push(...expanded);
+    }
+    alternatives.push({ comparators, any: joined.length === 0 || joined.length === 1 && /^[xX*]$/.test(joined[0]) });
+  }
+  return { alternatives };
+}
+function satisfies(version, c) {
+  const d = compare(version, c.version);
+  switch (c.op) {
+    case "=":
+      return d === 0;
+    case ">=":
+      return d >= 0;
+    case ">":
+      return d > 0;
+    case "<":
+      return d < 0;
+    case "<=":
+      return d <= 0;
+  }
+}
+function rangeProblem(requirement) {
+  const read = readRange(requirement.version);
+  return "problem" in read ? read.problem : null;
+}
+function admits(requirement, version) {
+  const read = readRange(requirement.version);
+  if ("problem" in read) return false;
+  if (version === void 0 || version.trim() === "") return read.alternatives.some((a) => a.any);
+  const v = concrete(version);
+  if (!v) return false;
+  return read.alternatives.some((alt) => {
+    if (v.pre && !alt.comparators.some((c) => c.version.pre && c.version.major === v.major && c.version.minor === v.minor && c.version.patch === v.patch)) return false;
+    return alt.comparators.every((c) => satisfies(v, c));
+  });
+}
 var PROJECT_ID_RE = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/;
 function slugifyProjectName(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").replace(/[^a-z0-9]+$/, "");
@@ -4779,12 +4957,12 @@ function projectConfigFsAdapterAt(rootDir) {
       return readYamlFile(file());
     },
     writeDocument(document) {
-      const text2 = readFileOrNull(file());
-      if (text2 === null) {
+      const text3 = readFileOrNull(file());
+      if (text3 === null) {
         writeYamlFile(file(), document);
         return;
       }
-      writeFile(file(), editDocumentText(text2, document, root));
+      writeFile(file(), editDocumentText(text3, document, root));
     },
     documentExists() {
       return fs2.existsSync(file());
@@ -4792,8 +4970,8 @@ function projectConfigFsAdapterAt(rootDir) {
     readText() {
       return readFileOrNull(file());
     },
-    writeText(text2) {
-      writeFile(file(), text2);
+    writeText(text3) {
+      writeFile(file(), text3);
     }
   };
 }
@@ -4822,9 +5000,9 @@ function storeOver(adapter, root) {
     },
     rewriteScalars(edits, dryRun = false) {
       if (edits.length === 0) return;
-      const text2 = adapter.readText();
-      if (text2 === null) throw new ProjectNotInitializedError();
-      const next = rewriteScalarsInText(text2, edits, root);
+      const text3 = adapter.readText();
+      if (text3 === null) throw new ProjectNotInitializedError();
+      const next = rewriteScalarsInText(text3, edits, root);
       if (!dryRun) adapter.writeText(next);
     }
   };
@@ -4879,21 +5057,21 @@ function childrenOf(tokens, index) {
   }
   return out;
 }
-function locateScalar(tokens, path37) {
+function locateScalar(tokens, path38) {
   let region = tokens;
-  for (let k = 0; k < path37.length; k += 1) {
-    const segment = path37[k];
-    if (region.length === 0) return `nothing is nested at ${path37.slice(0, k).join(".")}`;
+  for (let k = 0; k < path38.length; k += 1) {
+    const segment = path38[k];
+    if (region.length === 0) return `nothing is nested at ${path38.slice(0, k).join(".")}`;
     const base = Math.min(...region.map((t) => t.col));
-    const last = k === path37.length - 1;
+    const last = k === path38.length - 1;
     let at;
     if (typeof segment === "string") {
       at = region.findIndex((t) => t.kind === "key" && t.col === base && t.name === segment);
-      if (at < 0) return `no block key "${segment}" at ${path37.slice(0, k).join(".") || "the document root"}`;
+      if (at < 0) return `no block key "${segment}" at ${path38.slice(0, k).join(".") || "the document root"}`;
       if (last) return region[at].valueStart !== void 0 ? region[at] : `"${segment}" holds no inline scalar`;
     } else {
       const items = region.map((t, i) => ({ t, i })).filter(({ t }) => t.kind === "item" && t.col === base);
-      if (segment >= items.length) return `no block sequence item ${segment} at ${path37.slice(0, k).join(".")}`;
+      if (segment >= items.length) return `no block sequence item ${segment} at ${path38.slice(0, k).join(".")}`;
       at = items[segment].i;
       if (last) {
         const value = region[at + 1];
@@ -4905,26 +5083,26 @@ function locateScalar(tokens, path37) {
   }
   return "an empty path addresses no scalar";
 }
-function readScalar(text2) {
-  if (text2.startsWith("'")) {
+function readScalar(text3) {
+  if (text3.startsWith("'")) {
     let i = 1;
     let value = "";
-    while (i < text2.length) {
-      if (text2[i] === "'") {
-        if (text2[i + 1] === "'") {
+    while (i < text3.length) {
+      if (text3[i] === "'") {
+        if (text3[i + 1] === "'") {
           value += "'";
           i += 2;
           continue;
         }
         return { value, style: "single", end: i + 1 };
       }
-      value += text2[i];
+      value += text3[i];
       i += 1;
     }
     return null;
   }
-  if (text2.startsWith('"')) {
-    const closing = /^"(?:[^"\\]|\\.)*"/.exec(text2);
+  if (text3.startsWith('"')) {
+    const closing = /^"(?:[^"\\]|\\.)*"/.exec(text3);
     if (!closing) return null;
     try {
       return { value: JSON.parse(closing[0]), style: "double", end: closing[0].length };
@@ -4932,8 +5110,8 @@ function readScalar(text2) {
       return null;
     }
   }
-  const comment = text2.search(/\s#/);
-  const body = (comment < 0 ? text2 : text2.slice(0, comment)).trimEnd();
+  const comment = text3.search(/\s#/);
+  const body = (comment < 0 ? text3 : text3.slice(0, comment)).trimEnd();
   return { value: body, style: "plain", end: body.length };
 }
 function writeScalar(value, style) {
@@ -4941,18 +5119,18 @@ function writeScalar(value, style) {
   if (style === "plain" && /^[A-Za-z0-9_][A-Za-z0-9_./-]*$/.test(value)) return value;
   return `'${value.replace(/'/g, "''")}'`;
 }
-function setAt(document, path37, value) {
+function setAt(document, path38, value) {
   let node = document;
-  for (const segment of path37.slice(0, -1)) node = node[segment];
-  node[path37[path37.length - 1]] = value;
+  for (const segment of path38.slice(0, -1)) node = node[segment];
+  node[path38[path38.length - 1]] = value;
 }
-function rewriteScalarsInText(text2, edits, root) {
+function rewriteScalarsInText(text3, edits, root) {
   const refuse = (why) => {
     throw new WaironError(`Cannot rewrite .wai/project.yaml at ${root} without disturbing its formatting: ${why}. Nothing was written.`);
   };
-  const lines = text2.split(/(?<=\n)/);
+  const lines = text3.split(/(?<=\n)/);
   const tokens = tokenize(lines);
-  const expected = parseYaml(text2);
+  const expected = parseYaml(text3);
   for (const edit of edits) {
     const where = edit.path.join(".");
     const token = locateScalar(tokens, edit.path);
@@ -4994,17 +5172,17 @@ function sameValue(a, b) {
   }
   return a === b;
 }
-function lineStartOf(text2, pos) {
-  return text2.lastIndexOf("\n", pos - 1) + 1;
+function lineStartOf(text3, pos) {
+  return text3.lastIndexOf("\n", pos - 1) + 1;
 }
-function lineEndFrom(text2, pos) {
-  if (pos === 0 || text2[pos - 1] === "\n") return pos;
-  const newline = text2.indexOf("\n", pos);
-  return newline < 0 ? text2.length : newline + 1;
+function lineEndFrom(text3, pos) {
+  if (pos === 0 || text3[pos - 1] === "\n") return pos;
+  const newline = text3.indexOf("\n", pos);
+  return newline < 0 ? text3.length : newline + 1;
 }
-function indentBlock(text2, col) {
+function indentBlock(text3, col) {
   const pad = " ".repeat(col);
-  const body = text2.endsWith("\n") ? text2 : `${text2}
+  const body = text3.endsWith("\n") ? text3 : `${text3}
 `;
   return body.split("\n").map((line, i, all) => line === "" || i === all.length - 1 ? line : pad + line).join("\n");
 }
@@ -5037,12 +5215,12 @@ function schemaFieldOrder(at) {
 function inlineScalar(value, style) {
   if (value !== null && typeof value === "object") return null;
   const quoting = style === "QUOTE_SINGLE" || style === "QUOTE_DOUBLE" ? style : "PLAIN";
-  const text2 = YAML.stringify(value, { ...FRESH_TEXT_OPTIONS, lineWidth: 0, defaultStringType: quoting }).replace(/\n$/, "");
-  return text2.includes("\n") ? null : text2;
+  const text3 = YAML.stringify(value, { ...FRESH_TEXT_OPTIONS, lineWidth: 0, defaultStringType: quoting }).replace(/\n$/, "");
+  return text3.includes("\n") ? null : text3;
 }
 var DocumentReconciler = class {
-  constructor(text2, doc) {
-    this.text = text2;
+  constructor(text3, doc) {
+    this.text = text3;
     this.doc = doc;
     this.splices = [];
   }
@@ -5151,18 +5329,18 @@ var DocumentReconciler = class {
     }
   }
 };
-function applySplices(text2, splices) {
+function applySplices(text3, splices) {
   const ordered = [...splices].sort((a, b) => b.start - a.start || b.end - a.end || b.rank - a.rank);
-  let out = text2;
+  let out = text3;
   for (const splice of ordered) out = out.slice(0, splice.start) + splice.text + out.slice(splice.end);
   return out;
 }
-function editDocumentText(text2, document, root) {
+function editDocumentText(text3, document, root) {
   const refuse = (why) => {
     throw new WaironError(`Cannot write .wai/project.yaml at ${root} as an edit of the file: ${why}. Nothing was written.`);
   };
-  const crlf = text2.includes("\r\n");
-  const source = crlf ? text2.replace(/\r\n/g, "\n") : text2;
+  const crlf = text3.includes("\r\n");
+  const source = crlf ? text3.replace(/\r\n/g, "\n") : text3;
   const doc = YAML.parseDocument(source, PARSE_OPTIONS);
   if (doc.errors.length > 0) refuse(`the file does not parse (${doc.errors[0].message})`);
   const reconciler = new DocumentReconciler(source, doc);
@@ -5271,19 +5449,21 @@ function registryOver(store, root) {
       }
       save(config);
     },
+    // The four pack writes read the change through project_config.withPack —
+    // the same reading a pack impact's dry run measures, so the report and the
+    // write cannot disagree about what the configuration becomes.
     upsertPackSelection(selection) {
       const config = current2();
       const existing = packsOf(config);
-      const without = existing.filter((entry) => typeof entry === "string" || entry.name !== selection.name);
-      save(withPacks(config, [...without, selection]));
-      return without.length !== existing.length;
+      const replaced = existing.some((entry) => typeof entry !== "string" && entry.name === selection.name);
+      save(withPacks(config, packsOf(withPack(config, selection))));
+      return replaced;
     },
     removePackSelection(packName) {
       const config = current2();
       const existing = packsOf(config);
-      const remaining = existing.filter((entry) => typeof entry === "string" || entry.name !== packName);
-      if (remaining.length === existing.length) return false;
-      save(withPacks(config, remaining));
+      if (!existing.some((entry) => typeof entry !== "string" && entry.name === packName)) return false;
+      save(withPacks(config, packsOf(withPack(config, { name: packName }, true))));
       return true;
     },
     setProjectType(projectType) {
@@ -5298,17 +5478,14 @@ function registryOver(store, root) {
     },
     registerPackRef(ref) {
       const config = current2();
-      const packs = packsOf(config);
-      if (packs.includes(ref)) return false;
-      save(withPacks(config, [...packs, ref]));
+      if (packsOf(config).includes(ref)) return false;
+      save(withPacks(config, packsOf(withPack(config, ref))));
       return true;
     },
     deregisterPackRef(ref) {
       const config = current2();
-      const packs = packsOf(config);
-      const remaining = packs.filter((entry) => entry !== ref);
-      if (remaining.length === packs.length) return false;
-      save(withPacks(config, remaining));
+      if (!packsOf(config).includes(ref)) return false;
+      save(withPacks(config, packsOf(withPack(config, ref, true))));
       return true;
     },
     markSelectionsBundled(bundled) {
@@ -5338,9 +5515,9 @@ function registryOver(store, root) {
           const next = rekeyAnchor(rename, { spec: entry.spec, at, covers });
           const base = ["rules", "conformance", "carried", g, "findings", f];
           const named2 = { code: String(entry.code), spec: entry.spec, at: at ?? "" };
-          const change = (path37, field, from, to) => {
+          const change = (path38, field, from, to) => {
             if (from === to) return;
-            edits.push({ path: [...base, ...path37], from, to });
+            edits.push({ path: [...base, ...path38], from, to });
             rekeys.push({ ...named2, field, from, to });
           };
           change(["spec"], "spec", entry.spec, next.spec);
@@ -5652,11 +5829,11 @@ var projectConfigRepository = {
 };
 
 // src/core/domain_projector.ts
-var path19 = __toESM(require("path"));
+var path20 = __toESM(require("path"));
 
 // src/core/specs.ts
 var fs12 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 
 // src/config/paths.ts
 var fs3 = __toESM(require("fs"));
@@ -6437,9 +6614,9 @@ var MethodSignatureSchema = import_zod8.z.object({
   ext: ExtDataSchema.optional()
 });
 var INTENT_FLOOR_MIN_CHARS = 40;
-function passesIntentFloor(text2, methodName) {
-  if (!text2) return false;
-  const t = text2.trim();
+function passesIntentFloor(text3, methodName) {
+  if (!text3) return false;
+  const t = text3.trim();
   if (t.length < INTENT_FLOOR_MIN_CHARS) return false;
   const norm = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
   if (norm(t) === norm(methodName)) return false;
@@ -7205,7 +7382,7 @@ function stepGraph(method) {
   for (const s of steps) byNum.set(s.stepNumber, s);
   const nums = [...byNum.keys()].sort((a, b) => a - b);
   const indexOf = new Map(nums.map((n, i) => [n, i]));
-  const nextOf = (n) => {
+  const nextOf2 = (n) => {
     const i = indexOf.get(n);
     return i !== void 0 && i + 1 < nums.length ? nums[i + 1] : void 0;
   };
@@ -7214,7 +7391,7 @@ function stepGraph(method) {
     return i !== void 0 && i > 0 ? nums[i - 1] : void 0;
   };
   const armEndJoin = /* @__PURE__ */ new Map();
-  const fallNext = (n) => armEndJoin.has(n) ? armEndJoin.get(n) : nextOf(n);
+  const fallNext = (n) => armEndJoin.has(n) ? armEndJoin.get(n) : nextOf2(n);
   for (const n of nums) {
     const s = byNum.get(n);
     if (s.type !== "parallel" || s.endStep === void 0 || !s.branches?.length) continue;
@@ -7243,11 +7420,11 @@ function stepGraph(method) {
         succ.push(...(s.cases ?? []).map((c) => c.step), s.defaultStep ?? fallNext(n));
         break;
       case "loop":
-        succ.push(nextOf(n), s.endStep !== void 0 ? fallNext(s.endStep) : void 0);
+        succ.push(nextOf2(n), s.endStep !== void 0 ? fallNext(s.endStep) : void 0);
         break;
       case "try":
         succ.push(
-          nextOf(n),
+          nextOf2(n),
           ...(s.catches ?? []).map((c) => c.step),
           s.finallyStep,
           s.endStep !== void 0 ? fallNext(s.endStep) : void 0
@@ -7265,7 +7442,7 @@ function stepGraph(method) {
     }
     return [...new Set(succ.filter((t) => t !== void 0 && byNum.has(t)))];
   };
-  return { stepNumbers: nums, stepAt: (n) => byNum.get(n), nextOf, successorsOf };
+  return { stepNumbers: nums, stepAt: (n) => byNum.get(n), nextOf: nextOf2, successorsOf };
 }
 
 // src/models/step-config.ts
@@ -7362,7 +7539,7 @@ function stepConfigVerdict(method) {
   }
   const nums = [...byNum.keys()].sort((a, b) => a - b);
   const indexOf = new Map(nums.map((n, i) => [n, i]));
-  const nextOf = (n) => {
+  const nextOf2 = (n) => {
     const i = indexOf.get(n);
     return i !== void 0 && i + 1 < nums.length ? nums[i + 1] : void 0;
   };
@@ -7414,7 +7591,7 @@ function stepConfigVerdict(method) {
           const sorted = [...entries].sort((a, b) => a - b);
           if (entries.some((e, i) => e !== sorted[i])) malformed(s.stepNumber, `parallel step ${s.stepNumber} "branches" must list arm entries in ascending order \u2014 arms are contiguous sub-regions of the body.`);
           if (new Set(entries).size !== entries.length) malformed(s.stepNumber, `parallel step ${s.stepNumber} "branches" lists the same entry step twice.`);
-          const bodyStart = nextOf(s.stepNumber);
+          const bodyStart = nextOf2(s.stepNumber);
           if (bodyStart !== void 0 && sorted[0] !== bodyStart) malformed(s.stepNumber, `parallel step ${s.stepNumber}: the first arm must start at the body's first step (${bodyStart}), got ${sorted[0]} \u2014 steps before the first arm would belong to no arm.`);
           if (s.endStep !== void 0 && sorted.some((e) => e > s.endStep)) malformed(s.stepNumber, `parallel step ${s.stepNumber}: every arm entry must lie within the body (..${s.endStep}).`);
         }
@@ -7524,8 +7701,8 @@ function ambiguityMessage(resolution, subject, ref) {
   const local = ref.split("::").filter((seg) => seg && seg !== "super").pop() ?? ref;
   return `${subject} cross-tree component "${ref}", which the surface snapshots of ${providers.map((p) => `"${p}"`).join(", ")} expose with different contracts \u2014 the reference matches more than one declared contract, so none of them can judge it. Name the provider it means (super::<provider>::${local}), or remove the snapshot that no longer applies.`;
 }
-function sha256(text2) {
-  return `sha256:${(0, import_crypto.createHash)("sha256").update(text2).digest("hex")}`;
+function sha256(text3) {
+  return `sha256:${(0, import_crypto.createHash)("sha256").update(text3).digest("hex")}`;
 }
 var TYPE_IDENTIFIER = /(?:::)?[A-Za-z0-9_][A-Za-z0-9_-]*(?:(?:::|\.)[A-Za-z0-9_][A-Za-z0-9_-]*)*/g;
 function closureTypeOf(snapshot, identifier) {
@@ -7781,9 +7958,9 @@ function shortestPath(from, to, members, edges, rank) {
     const v = queue.shift();
     for (const w of [...edges.get(v) ?? []].filter((x) => members.has(x)).sort((a, b) => rank(a) - rank(b))) {
       if (w === to) {
-        const path37 = [w];
-        for (let at = v; at !== from; at = prev.get(at)) path37.unshift(at);
-        return path37;
+        const path38 = [w];
+        for (let at = v; at !== from; at = prev.get(at)) path38.unshift(at);
+        return path38;
       }
       if (seen.has(w)) continue;
       seen.add(w);
@@ -8198,12 +8375,12 @@ function buildExcalidrawScene(model, L) {
       locked: false
     };
   }
-  function boundLabel(rect, text2, fontSize, verticalAlign) {
+  function boundLabel(rect, text3, fontSize, verticalAlign) {
     const id = rect.id + "-label";
     const label2 = base(id, "text", { x: rect.x + 8, y: rect.y + 6, w: rect.width - 16, h: 20 });
     label2.roundness = null;
-    label2.text = text2;
-    label2.originalText = text2;
+    label2.text = text3;
+    label2.originalText = text3;
     label2.fontSize = fontSize;
     label2.fontFamily = 1;
     label2.textAlign = "center";
@@ -12742,10 +12919,10 @@ function lockPath2(root) {
 function snapshotPath(root, alias) {
   return path9.join(root, ".wai", "externals", `${alias}.yaml`);
 }
-function writeAtomically(file, text2) {
+function writeAtomically(file, text3) {
   fs7.mkdirSync(path9.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs7.writeFileSync(tmp, text2);
+  fs7.writeFileSync(tmp, text3);
   fs7.renameSync(tmp, file);
 }
 function sortedLock(lock) {
@@ -13214,6 +13391,109 @@ function listPinnedExternals2() {
 
 // src/core/family-validation.ts
 var path11 = __toESM(require("path"));
+
+// src/models/pack-impact.ts
+function packSettings(manifest, profile) {
+  const severities = {};
+  for (const rule of manifest.rules) {
+    for (const code of rule.codes) severities[code.code] = code.defaultSeverity;
+  }
+  for (const assertion of manifest.assertions) severities[assertionCode(manifest.name, assertion.code)] = assertion.severity;
+  const def = profile !== null ? manifest.profiles[profile] : void 0;
+  if (!def) return { pack: manifest.name, severities };
+  Object.assign(severities, def.rules?.sddRuleSeverity ?? {});
+  const rules = def.rules;
+  return {
+    pack: manifest.name,
+    profile,
+    severities,
+    ...rules?.designDepth ? { designDepth: rules.designDepth } : {},
+    ...rules?.naming ? { naming: rules.naming } : {},
+    ...rules?.complexity ? { complexity: rules.complexity } : {},
+    ...rules?.documentation ? { documentation: rules.documentation } : {}
+  };
+}
+function assertionCode(packName, code) {
+  const norm = (s) => s.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return `${norm(packName)}_${norm(code)}`;
+}
+var RANK = { notice: 1, warning: 2, error: 3 };
+function severityChange(code, to, profile, baseline, packCodes) {
+  const from = baseline.ruleDefaults[code];
+  if (from === void 0) {
+    return { axis: "rule", change: packCodes.has(code) ? "added" : "inert", subject: code, profile, to };
+  }
+  if (from === to) return null;
+  if (to === "off") return { axis: "rule", change: "off", subject: code, profile, from, to };
+  return { axis: "rule", change: (RANK[to] ?? 0) < (RANK[from] ?? 0) ? "loosened" : "raised", subject: code, profile, from, to };
+}
+function profileChanges(id, manifest, baseline, packCodes) {
+  const def = manifest.profiles[id];
+  const out = [{ axis: "concept", change: baseline.profiles.includes(id) ? "redefined" : "added", subject: id, profile: id }];
+  for (const [code, to] of Object.entries(def.rules?.sddRuleSeverity ?? {})) {
+    const change = severityChange(code, to, id, baseline, packCodes);
+    if (change) out.push(change);
+  }
+  const depth = def.rules?.designDepth;
+  if (depth && depth !== baseline.designDepth) out.push({ axis: "rule", change: "depth", subject: "designDepth", profile: id, from: baseline.designDepth, to: depth });
+  for (const f of def.forbiddenStereotypes) for (const t of f.types) out.push({ axis: "concept", change: "removed", subject: t, profile: id, reason: f.reason });
+  for (const d of def.discouragedStereotypes) for (const t of d.types) out.push({ axis: "concept", change: "discouraged", subject: t, profile: id, reason: d.reason });
+  for (const e of def.allowedEdges) {
+    for (const from of e.from) for (const to of e.to) out.push({ axis: "concept", change: "licensed", subject: `${from} \u2192 ${to}`, profile: id, reason: e.reason });
+  }
+  return out;
+}
+function packWideChanges(manifest, baseline) {
+  const out = [];
+  for (const a of manifest.assertions) {
+    out.push({ axis: "rule", change: "added", subject: assertionCode(manifest.name, a.code), to: a.severity, reason: a.reason });
+  }
+  for (const rule of manifest.rules) {
+    for (const code of rule.codes) out.push({ axis: "rule", change: "added", subject: code.code, to: code.defaultSeverity });
+  }
+  for (const p of manifest.patterns) out.push({ axis: "concept", change: "added", subject: `pattern ${p.id}@${p.version}` });
+  for (const g of manifest.guarantees) {
+    if (!baseline.guarantees.includes(g)) out.push({ axis: "concept", change: "added", subject: `guarantee ${g}` });
+  }
+  for (const [lang, def] of Object.entries(manifest.languages)) {
+    out.push({ axis: "concept", change: "added", subject: `language ${lang}` });
+    for (const [construct, guidance] of Object.entries(def.unsupportedFlow)) {
+      out.push({ axis: "concept", change: "gated", subject: `${lang}: ${construct}`, reason: guidance });
+    }
+  }
+  return out;
+}
+function doctrineChanges(manifest, baseline) {
+  const packCodes = /* @__PURE__ */ new Set([
+    ...manifest.assertions.map((a) => assertionCode(manifest.name, a.code)),
+    ...manifest.rules.flatMap((r) => r.codes.map((c) => c.code))
+  ]);
+  const perProfile = Object.keys(manifest.profiles).flatMap((id) => profileChanges(id, manifest, baseline, packCodes));
+  return [...perProfile, ...packWideChanges(manifest, baseline)];
+}
+function identity(issue2) {
+  const message = issue2.message.replace(/\b(error|warning|notice)s?\b/gi, "").replace(/\s+/g, " ").trim();
+  return [issue2.code, issue2.project ?? "", issue2.specId ?? "", message].join("\0");
+}
+function findingChanges(before, after) {
+  const pending = /* @__PURE__ */ new Map();
+  for (const issue2 of before.issues) {
+    const key = identity(issue2);
+    pending.set(key, [...pending.get(key) ?? [], issue2]);
+  }
+  const introduced = [];
+  const regraded = [];
+  for (const issue2 of after.issues) {
+    const matches = pending.get(identity(issue2));
+    const earlier = matches?.shift();
+    if (!earlier) introduced.push(issue2);
+    else if (earlier.severity !== issue2.severity) regraded.push({ finding: issue2, from: earlier.severity });
+  }
+  const resolved = [...pending.values()].flat();
+  return { introduced, resolved, regraded };
+}
+
+// src/core/family-validation.ts
 var FAMILY_SEVERITY = {
   EXTERNAL_INCOMPATIBLE: "error",
   EXTERNAL_DRIFTED: "notice",
@@ -13224,7 +13504,11 @@ var FAMILY_SEVERITY = {
   MEMBER_UNAPPROVED: "warning",
   MEMBER_DRIFTED: "warning",
   PROJECT_ID_DEFAULTED: "notice",
-  PROJECT_ID_AMBIGUOUS: "warning"
+  PROJECT_ID_AMBIGUOUS: "warning",
+  // Governance: a required pack not adopted blocks; a member's deviation from
+  // an adopted pack's settings is visible and never fails --ci.
+  POLICY_NOT_ADOPTED: "error",
+  POLICY_DEVIATION: "notice"
 };
 function configOrNull() {
   try {
@@ -13326,6 +13610,7 @@ function run(options) {
     left.push(...judged.composed.notSelected.map((alias) => ({ project: node.namespace, alias })));
   }
   issues.push(...within(root, ceiling, () => checkMembers(narrowed(family, selected))));
+  issues.push(...within(root, ceiling, () => checkPolicies(narrowed(family, selected))));
   const hint = notSelectedHint(left);
   return {
     valid: issues.every((i) => i.severity !== "error"),
@@ -13476,6 +13761,147 @@ function checkMembers(family) {
   }
   return out.filter((f) => f !== null);
 }
+function requiredBy(key) {
+  return key === "" ? "the family root" : `"${key}"`;
+}
+function requirementText(requirement) {
+  return `"${requirement.pack}" ${requirement.version}${requirement.profile ? ` (profile "${requirement.profile}")` : ""}`;
+}
+function isBelow(family, node, ancestor) {
+  let at = node;
+  while (at && at.parent !== void 0) {
+    if (at.parent === ancestor) return true;
+    at = familyNode(family, at.parent);
+  }
+  return false;
+}
+function policyIssue(code, message, member, specId) {
+  return { severity: FAMILY_SEVERITY[code], code, message, project: member, ...specId !== void 0 ? { specId } : {} };
+}
+function tunedBy(config, issues) {
+  const out = [];
+  for (const issue2 of issues) {
+    const tuned = finding(config, issue2.code, issue2.message, issue2.project ?? "", issue2.specId);
+    if (tuned) out.push(tuned);
+  }
+  return out;
+}
+function checkPolicies(family) {
+  const out = [];
+  for (const requirer of family.nodes) {
+    const members = family.nodes.filter((n) => isBelow(family, n, requirer.namespace));
+    if (members.length === 0) continue;
+    const config = runWithProjectRoot(requirer.directory, configOrNull);
+    const valid = config ? requiredPolicies(config).filter((r) => r.pack.trim() !== "" && rangeProblem(r) === null) : [];
+    if (valid.length === 0) continue;
+    const caused = [];
+    for (const member of members) {
+      caused.push(...runWithProjectRoot(member.directory, () => judgeAdoption(requirer.namespace, member.namespace, valid)));
+    }
+    out.push(...tunedBy(config, caused));
+  }
+  return out;
+}
+function entryFor(config, loaded, pack) {
+  const entries = config.extensions?.packs ?? [];
+  const selection = entries.find((e) => typeof e !== "string" && e.name === pack);
+  if (selection) return { entry: selection, ...selection.version ? { version: selection.version } : {}, label: selection.version ? `${selection.name}@${selection.version}` : selection.name };
+  for (const ref of entries.filter((e) => typeof e === "string")) {
+    const committed = loaded.packs.find((p) => p.scope === "project" && p.ref === ref && p.name === pack);
+    if (committed) return { entry: ref, ...committed.version ? { version: committed.version } : {}, label: `${ref} (${committed.name}${committed.version ? `@${committed.version}` : ", unversioned"})` };
+  }
+  return null;
+}
+function judgeAdoption(requiring, member, requirements) {
+  const config = configOrNull();
+  if (!config) return [];
+  const loaded = loadProjectExtensions();
+  const out = [];
+  const who = `The member ${named(member)}`;
+  for (const requirement of requirements) {
+    const wanted = `${requirementText(requirement)}, required by ${requiredBy(requiring)}`;
+    const adopted = entryFor(config, loaded, requirement.pack);
+    if (!adopted) {
+      out.push(policyIssue("POLICY_NOT_ADOPTED", `${who} does not select the pack ${wanted}. Select it in the member's own configuration (\`wairon pack use ${requirement.pack}@<version> --pin\` at its root).`, member));
+      continue;
+    }
+    if (typeof adopted.entry !== "string" && !adopted.entry.version) {
+      out.push(policyIssue("POLICY_NOT_ADOPTED", `${who} selects "${adopted.label}" for the pack ${wanted}, unpinned \u2014 a family cannot judge a floating selection; pin a version (\`wairon pack use ${requirement.pack}@<version> --pin\`).`, member));
+      continue;
+    }
+    if (!admits(requirement, adopted.version)) {
+      out.push(policyIssue("POLICY_NOT_ADOPTED", `${who} selects "${adopted.label}", outside the range of the pack ${wanted}: ${adopted.version ? `version ${adopted.version} is not admitted by "${requirement.version}"` : `an unversioned pack is admitted by "*" only`}.`, member));
+      continue;
+    }
+    if (requirement.profile && config.projectType !== requirement.profile) {
+      out.push(policyIssue("POLICY_NOT_ADOPTED", `${who} selects "${adopted.label}" for the pack ${wanted}, but is governed by "${config.projectType}", not the required profile "${requirement.profile}". Set its projectType to "${requirement.profile}".`, member));
+      continue;
+    }
+    const manifest = manifestOf(adopted.entry);
+    if (!manifest) continue;
+    const governing = requirement.profile ?? (config.projectType in manifest.profiles ? config.projectType : null);
+    out.push(...policyDeviations(member, requirement, packSettings(manifest, governing)));
+  }
+  return out;
+}
+function shown(value) {
+  return typeof value === "string" ? `"${value}"` : JSON.stringify(value);
+}
+function keyDeviations(label2, packValues, memberValues) {
+  const out = [];
+  for (const [key, value] of Object.entries(packValues ?? {})) {
+    if (value === void 0 || key === "stereotypes") continue;
+    const mine = memberValues?.[key];
+    if (mine !== void 0 && JSON.stringify(mine) !== JSON.stringify(value)) out.push({ setting: `${label2}.${key}`, pack: value, member: mine });
+  }
+  return out;
+}
+function lintAllows() {
+  const specs = [
+    ...loadSubsystemSpecs(),
+    ...loadComponentSpecs(),
+    ...loadInterfaceSpecs(),
+    ...loadImplementationSpecs(),
+    ...loadTypeSpecs()
+  ];
+  return specs.flatMap((s) => (s.lint?.allow ?? []).map((a) => ({ specId: s.id, code: a.code, ...a.at !== void 0 ? { at: a.at } : {} })));
+}
+function policyDeviations(member, requirement, settings) {
+  const rules = configOrNull()?.rules;
+  const subsystems = loadSubsystemSpecs();
+  const allows = lintAllows();
+  const under = settings.profile ? `under its profile "${settings.profile}"` : "with none of its profiles governing";
+  const about = `the pack "${requirement.pack}" (required ${requirement.version})`;
+  const deviation = (setting, pack, mine, specId) => policyIssue("POLICY_DEVIATION", `The member ${named(member)} adopted ${about} but changes ${setting}: the pack sets ${shown(pack)} ${under}, the member ${shown(mine)}. Visible, not blocking \u2014 the member's own configuration decides.`, member, specId);
+  const out = [];
+  for (const [code, severity] of Object.entries(rules?.sddRuleSeverity ?? {})) {
+    const packs = settings.severities[code];
+    if (packs !== void 0 && packs !== severity) out.push(deviation(`rules.sddRuleSeverity.${code}`, packs, severity));
+  }
+  if (settings.designDepth) {
+    if (rules?.designDepth && rules.designDepth !== settings.designDepth) out.push(deviation("rules.designDepth", settings.designDepth, rules.designDepth));
+    for (const s of subsystems) {
+      if (s.designDepth && s.designDepth !== settings.designDepth) out.push(deviation(`the designDepth of subsystem "${s.id}"`, settings.designDepth, s.designDepth, s.id));
+    }
+  }
+  const overlays = [
+    ...keyDeviations("rules.naming", settings.naming, rules?.naming),
+    ...keyDeviations("rules.naming.stereotypes", settings.naming?.stereotypes, rules?.naming?.stereotypes),
+    ...keyDeviations("rules.complexity", settings.complexity, rules?.complexity),
+    ...keyDeviations("rules.documentation", settings.documentation, rules?.documentation)
+  ];
+  for (const o of overlays) out.push(deviation(o.setting, o.pack, o.member));
+  if (settings.profile) {
+    for (const s of subsystems) {
+      if (s.profile && s.profile !== settings.profile) out.push(deviation(`the profile of subsystem "${s.id}"`, settings.profile, s.profile, s.id));
+    }
+  }
+  for (const allow of allows) {
+    if (settings.severities[allow.code] === void 0) continue;
+    out.push(deviation(`a lint.allow of ${allow.code}${allow.at ? ` at "${allow.at}"` : ""} on "${allow.specId}"`, settings.severities[allow.code], "allowed", allow.specId));
+  }
+  return out;
+}
 
 // src/core/rules/index.ts
 var import_crypto2 = require("crypto");
@@ -13487,28 +13913,6 @@ var path14 = __toESM(require("path"));
 var import_module = require("module");
 var import_zod9 = require("zod");
 
-// src/utils/version.ts
-function isNewerVersion(current2, candidate) {
-  const baseVersion = (v) => v.replace(/-.*$/, "");
-  const preRelease = (v) => {
-    const match = v.match(/-(.+)\.(\d+)$/);
-    return match ? { label: match[1], n: parseInt(match[2], 10) } : null;
-  };
-  const parse = (v) => baseVersion(v).split(".").map((n) => parseInt(n, 10) || 0);
-  const [cMaj, cMin, cPat] = parse(current2);
-  const [nMaj, nMin, nPat] = parse(candidate);
-  if (nMaj !== cMaj) return nMaj > cMaj;
-  if (nMin !== cMin) return nMin > cMin;
-  if (nPat !== cPat) return nPat > cPat;
-  const cPre = preRelease(current2);
-  const nPre = preRelease(candidate);
-  if (!cPre && !nPre) return false;
-  if (!cPre && nPre) return false;
-  if (cPre && !nPre) return true;
-  if (cPre && nPre) return nPre.n > cPre.n;
-  return false;
-}
-
 // src/core/packstore.ts
 var crypto2 = __toESM(require("crypto"));
 var fs9 = __toESM(require("fs"));
@@ -13532,7 +13936,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.84";
+var WAIRON_VERSION = "5.1.1-dev.85";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -13783,7 +14187,7 @@ var PackSkillSchema = import_zod9.z.object({
 });
 var PackInstructionBlockSchema = import_zod9.z.union([
   // Scalar shorthand: `instructions: >- …` — the common case, unscoped.
-  import_zod9.z.string().min(1).transform((text2) => ({ text: text2 })),
+  import_zod9.z.string().min(1).transform((text3) => ({ text: text3 })),
   import_zod9.z.object({
     text: import_zod9.z.string().min(1),
     profile: import_zod9.z.array(import_zod9.z.string().min(1)).min(1).optional()
@@ -13884,6 +14288,11 @@ function checkDeclarativePack(manifest) {
   const result = DeclarativePackSchema.safeParse(manifest);
   return result.success ? null : result.error.issues[0]?.message ?? "shape mismatch";
 }
+function parseDeclarativePack(manifest) {
+  const result = DeclarativePackSchema.safeParse(manifest);
+  if (!result.success) throw new Error(result.error.issues[0]?.message ?? "shape mismatch");
+  return { ...result.data, rules: [] };
+}
 function globalPacksEnabled(config) {
   return config.extensions?.useGlobalPacks ?? GLOBAL_PACKS_DEFAULT;
 }
@@ -14004,32 +14413,57 @@ function readManifest(target, projectRoot) {
 }
 function loadExtensionPacks(refs, projectRoot) {
   const out = emptyExtensions();
-  for (const { ref, scope } of refs) {
-    try {
-      const target = resolvePackRef(ref, projectRoot);
-      const manifest = readManifest(target, projectRoot);
-      mergePack(out, manifest, ref, scope, path14.dirname(target));
-      for (const r of manifest.rules) out.rules.push(r);
-    } catch (e) {
-      out.errors.push(`Extension pack "${ref}" failed to load: ${e instanceof Error ? e.message : String(e)}`);
+  for (const ref of refs) loadRefInto(out, ref, projectRoot);
+  return out;
+}
+function loadRefInto(out, { ref, scope, manifest: supplied }, projectRoot) {
+  try {
+    if (supplied) {
+      mergePack(out, supplied, ref, scope, path14.resolve(projectRoot, ref));
+      for (const r of supplied.rules) out.rules.push(r);
+      return;
     }
+    const target = resolvePackRef(ref, projectRoot);
+    const manifest = readManifest(target, projectRoot);
+    mergePack(out, manifest, ref, scope, path14.dirname(target));
+    for (const r of manifest.rules) out.rules.push(r);
+  } catch (e) {
+    out.errors.push(`Extension pack "${ref}" failed to load: ${e instanceof Error ? e.message : String(e)}`);
   }
-  return out;
 }
 function loadExtensions(packRefs, projectRoot) {
   return loadExtensionPacks(packRefs.map((ref) => ({ ref, scope: "project" })), projectRoot);
 }
 function loadProjectExtensions() {
+  let config;
+  try {
+    config = projectConfigRepository.load();
+  } catch {
+    config = null;
+  }
+  if (!config) return emptyExtensions();
+  return loadFor(config);
+}
+function isCandidateEntry(entry, candidate) {
+  const target = candidate?.entry;
+  if (target === void 0) return false;
+  if (typeof target === "string") return entry === target;
+  return typeof entry !== "string" && entry.name === target.name;
+}
+function loadFor(config, candidate) {
   try {
-    const config = projectConfigRepository.load();
-    if (!config) return emptyExtensions();
     const projectRoot = getProjectRoot();
     const refs = [];
     const unresolved = [];
+    const supplied = candidate?.manifest && !candidate.remove ? candidate.manifest : void 0;
     if (globalPacksEnabled(config)) {
       for (const ref of discoverPacks(globalPacksDir())) refs.push({ ref, scope: "global" });
     }
     for (const entry of config.extensions?.packs ?? []) {
+      if (supplied && isCandidateEntry(entry, candidate)) {
+        refs.push({ ref: packEntryLabel(entry), scope: "project", manifest: supplied });
+        continue;
+      }
       if (typeof entry === "string") {
         refs.push({ ref: entry, scope: "project" });
         continue;
@@ -14039,7 +14473,8 @@ function loadProjectExtensions() {
       if (resolution.failure) unresolved.push(resolution.failure);
     }
     if (refs.length === 0 && unresolved.length === 0) return emptyExtensions();
-    const loaded = loadExtensionPacks(refs, projectRoot);
+    const loaded = emptyExtensions();
+    for (const item of refs) loadRefInto(loaded, item, projectRoot);
     for (const problem of skillExtendErrors(loaded.skills)) loaded.errors.push(problem);
     loaded.selectionFailures.push(...unresolved);
     return loaded;
@@ -14047,6 +14482,23 @@ function loadProjectExtensions() {
     return emptyExtensions();
   }
 }
+function manifestOf(entry) {
+  const projectRoot = getProjectRoot();
+  let ref;
+  if (typeof entry !== "string") {
+    const resolution = resolveSelection(entry, projectRoot);
+    if (!resolution.ref) return null;
+    ref = resolution.ref;
+  } else {
+    ref = entry;
+  }
+  try {
+    const target = resolvePackRef(ref, projectRoot);
+    return readManifest(target, projectRoot);
+  } catch {
+    return null;
+  }
+}
 function defaultPackSelections() {
   try {
     const out = [];
@@ -14243,21 +14695,21 @@ function buildCodeIndex(model) {
   const declarations = /* @__PURE__ */ new Map();
   const anchors = /* @__PURE__ */ new Map();
   const findingAnchors = /* @__PURE__ */ new Map();
-  const namesAt = (cache, path37, make) => {
-    const cached = cache.get(path37);
+  const namesAt = (cache, path38, make) => {
+    const cached = cache.get(path38);
     if (cached) return cached;
-    const f = facts.get(path37);
+    const f = facts.get(path38);
     if (!f) return NO_NAMES;
     const built = make(f);
-    cache.set(path37, built);
+    cache.set(path38, built);
     return built;
   };
   const republished = /* @__PURE__ */ new Map();
-  const republishedFrom = (path37) => {
-    const cached = republished.get(path37);
+  const republishedFrom = (path38) => {
+    const cached = republished.get(path38);
     if (cached) return cached;
-    const out = /* @__PURE__ */ new Set([path37]);
-    const queue = [path37];
+    const out = /* @__PURE__ */ new Set([path38]);
+    const queue = [path38];
     while (queue.length) {
       const from = queue.pop();
       const f = facts.get(from);
@@ -14270,7 +14722,7 @@ function buildCodeIndex(model) {
         }
       }
     }
-    republished.set(path37, out);
+    republished.set(path38, out);
     return out;
   };
   const NO_ORIGIN = /* @__PURE__ */ new Set();
@@ -14279,9 +14731,9 @@ function buildCodeIndex(model) {
     return to ? republishedFrom(to) : NO_ORIGIN;
   };
   const scopeOf = (site, from) => {
-    const path37 = pathKey(site.from ?? from);
-    const f = facts.get(path37);
-    return f?.status === "analyzed" && f.analysisGrade === "exact" ? { path: path37, facts: f } : void 0;
+    const path38 = pathKey(site.from ?? from);
+    const f = facts.get(path38);
+    return f?.status === "analyzed" && f.analysisGrade === "exact" ? { path: path38, facts: f } : void 0;
   };
   const originOf2 = (site, from) => {
     const resolved = scopeOf(site, from);
@@ -14320,7 +14772,7 @@ function buildCodeIndex(model) {
     if (site.via) for (const typeName of localTypesOf(f, site.via)) widenThroughType(typeName);
     return out;
   };
-  const declarationsAt = (path37) => namesAt(declarations, pathKey(path37), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
+  const declarationsAt = (path38) => namesAt(declarations, pathKey(path38), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
   const forwardsOf = (start, name) => {
     const out = [];
     const seen = /* @__PURE__ */ new Set();
@@ -14346,10 +14798,10 @@ function buildCodeIndex(model) {
   return {
     paths,
     exactPaths,
-    factsAt: (path37) => facts.get(pathKey(path37)),
+    factsAt: (path38) => facts.get(pathKey(path38)),
     declarationsAt,
-    anchorsAt: (path37) => namesAt(anchors, pathKey(path37), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
-    findingAnchorsAt: (path37) => namesAt(findingAnchors, pathKey(path37), (f) => new Set(f.anchoredNames)),
+    anchorsAt: (path38) => namesAt(anchors, pathKey(path38), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
+    findingAnchorsAt: (path38) => namesAt(findingAnchors, pathKey(path38), (f) => new Set(f.anchoredNames)),
     originOf: originOf2,
     possibleOriginsOf,
     forwardsOf
@@ -14388,10 +14840,10 @@ function buildRealizationIndex(ctx) {
   return {
     paths,
     implementationsOf: (compId) => implsByComponent.get(compId) ?? NONE_IMPL,
-    implementationsAt: (path37) => implsByPath.get(pathKey(path37)) ?? NONE_IMPL,
+    implementationsAt: (path38) => implsByPath.get(pathKey(path38)) ?? NONE_IMPL,
     filesOf: (compId) => filesByComponent.get(compId) ?? NONE_PATH,
     filesIn: (subsystemId) => filesBySubsystem.get(subsystemId) ?? NONE_PATH,
-    componentsAt: (path37) => componentsByPath.get(pathKey(path37)) ?? NONE_COMP
+    componentsAt: (path38) => componentsByPath.get(pathKey(path38)) ?? NONE_COMP
   };
 }
 function buildImportGraph(index, universe) {
@@ -14403,22 +14855,22 @@ function buildImportGraph(index, universe) {
       if (to && to !== from) into.add(to);
     }
   };
-  const importsOf = (path37) => {
-    const cached = imports.get(path37);
+  const importsOf = (path38) => {
+    const cached = imports.get(path38);
     if (cached) return cached;
-    const facts = index.factsAt(path37);
+    const facts = index.factsAt(path38);
     const out = /* @__PURE__ */ new Set();
-    if (facts?.status === "analyzed") resolveAll(path37, facts.imports, out);
-    imports.set(path37, out);
+    if (facts?.status === "analyzed") resolveAll(path38, facts.imports, out);
+    imports.set(path38, out);
     return out;
   };
-  const tracesOf = (path37) => {
-    const cached = traces.get(path37);
+  const tracesOf = (path38) => {
+    const cached = traces.get(path38);
     if (cached) return cached;
-    const facts = index.factsAt(path37);
-    const out = new Set(importsOf(path37));
-    if (facts?.status === "analyzed") resolveAll(path37, facts.reexports, out);
-    traces.set(path37, out);
+    const facts = index.factsAt(path38);
+    const out = new Set(importsOf(path38));
+    if (facts?.status === "analyzed") resolveAll(path38, facts.reexports, out);
+    traces.set(path38, out);
     return out;
   };
   return {
@@ -14698,17 +15150,17 @@ var projectIdentityRule = {
     { code: "PROJECT_ID_DEFAULTED", defaultSeverity: "notice", summary: "Project declares no id; it answers to one derived from its display name" }
   ],
   check(ctx) {
-    const identity = ctx.projectIdentity;
-    if (identity) judgeOwnIdentity(ctx, identity);
+    const identity2 = ctx.projectIdentity;
+    if (identity2) judgeOwnIdentity(ctx, identity2);
   }
 };
-function judgeOwnIdentity(ctx, identity) {
-  const problem = (kind) => identity.problems.find((p) => p.kind === kind);
+function judgeOwnIdentity(ctx, identity2) {
+  const problem = (kind) => identity2.problems.find((p) => p.kind === kind);
   if (problem("defaulted")) {
     ctx.addIssue(
       "notice",
       "PROJECT_ID_DEFAULTED",
-      `Project "${identity.name}" declares no id in .wai/project.yaml, so it answers to "${identity.id}", derived from its display name \u2014 renaming the project would move it. No save writes it for you; declare it with \`id: ${identity.id}\` (stage 3 requires an explicit id).`
+      `Project "${identity2.name}" declares no id in .wai/project.yaml, so it answers to "${identity2.id}", derived from its display name \u2014 renaming the project would move it. No save writes it for you; declare it with \`id: ${identity2.id}\` (stage 3 requires an explicit id).`
     );
   }
   const ambiguous = problem("ambiguous");
@@ -14716,15 +15168,15 @@ function judgeOwnIdentity(ctx, identity) {
     ctx.addIssue(
       "warning",
       "PROJECT_ID_AMBIGUOUS",
-      `Project "${identity.name}" has no usable id: ${ambiguous.detail}. A project id is lower-case letters, digits, "-", "_" and ".", starting and ending with a letter or a digit \u2014 declare one in .wai/project.yaml.`
+      `Project "${identity2.name}" has no usable id: ${ambiguous.detail}. A project id is lower-case letters, digits, "-", "_" and ".", starting and ending with a letter or a digit \u2014 declare one in .wai/project.yaml.`
     );
   }
   if (problem("changed")) {
-    const now = identity.id === void 0 ? "no id at all" : `"${identity.id}"`;
+    const now = identity2.id === void 0 ? "no id at all" : `"${identity2.id}"`;
     ctx.addIssue(
       "error",
       "PROJECT_ID_CHANGED",
-      `Project "${identity.name}" now resolves to ${now}, but its lock approved "${identity.lockedId}" \u2014 everything keyed on the approved id no longer finds this project. Restore \`id: ${identity.lockedId}\` in .wai/project.yaml, or rename deliberately and re-lock.`
+      `Project "${identity2.name}" now resolves to ${now}, but its lock approved "${identity2.lockedId}" \u2014 everything keyed on the approved id no longer finds this project. Restore \`id: ${identity2.lockedId}\` in .wai/project.yaml, or rename deliberately and re-lock.`
     );
   }
 }
@@ -15848,7 +16300,7 @@ var narrativeJumpEdgesRule = {
         const byNum = /* @__PURE__ */ new Map();
         for (const s of steps) byNum.set(s.stepNumber, s);
         const nums = [...byNum.keys()].sort((a, b) => a - b);
-        const nextOf = (n) => {
+        const nextOf2 = (n) => {
           const i = nums.indexOf(n);
           return i !== -1 && i + 1 < nums.length ? nums[i + 1] : void 0;
         };
@@ -15857,7 +16309,7 @@ var narrativeJumpEdgesRule = {
           const handlerStarts = new Set((s.catches ?? []).map((c) => c.step));
           if (s.finallyStep !== void 0) handlerStarts.add(s.finallyStep);
           const last = byNum.get(s.endStep);
-          const nxt = nextOf(s.endStep);
+          const nxt = nextOf2(s.endStep);
           if (last && (last.type === "local" || last.type === "call" || last.type === "register" || last.type === "dispatch") && nxt !== void 0 && handlerStarts.has(nxt)) {
             ctx.addIssue(
               "warning",
@@ -16155,11 +16607,11 @@ var unconditionalCallCyclesRule = {
       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) => byCodeUnit(a.fromKey, b.fromKey) || byCodeUnit(a.impl.id, b.impl.id) || a.stepNumber - b.stepNumber)[0];
-      const path37 = [...keys].sort(byCodeUnit).join(" \u2192 ");
+      const path38 = [...keys].sort(byCodeUnit).join(" \u2192 ");
       ctx.addIssue(
         "warning",
         "UNCONDITIONAL_CALL_CYCLE",
-        `Call cycle with no guard: ${path37} \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: ${path38} \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))
       );
@@ -17604,6 +18056,27 @@ var reproducibilityRule = {
   }
 };
 
+// src/core/rules/extension/pack-requirements.ts
+var packRequirementsRule = {
+  name: "pack-requirements",
+  description: "Every requirement in the bound project's own composition.requirePolicies must be readable: a pack name and a semver range that parses (pack_requirement.rangeProblem). One that does not is POLICY_REQUIREMENT_INVALID, quoting the range and the unreadable token \u2014 an error on the requiring project's own gate, because the requirement is its own configuration and the family run cannot judge a member against it. It judges only the syntax: whether members adopt the requirement is the family run's question (family_validator.adoption), and nothing here reads a parent's requirements.",
+  codes: [
+    { code: "POLICY_REQUIREMENT_INVALID", defaultSeverity: "error", summary: "A project's composition.requirePolicies names a pack range that does not parse" }
+  ],
+  check(ctx) {
+    for (const requirement of ctx.ext.packRequirements) {
+      const problem = requirement.pack.trim() === "" ? "it names no pack" : rangeProblem(requirement);
+      if (problem === null) continue;
+      const which = requirement.pack.trim() === "" ? "A requirement" : `The requirement for pack "${requirement.pack}"`;
+      ctx.addIssue(
+        "error",
+        "POLICY_REQUIREMENT_INVALID",
+        `${which} in composition.requirePolicies cannot be read: range "${requirement.version}" \u2014 ${problem}. The family run cannot judge any member against it until it parses; write an exact version (1.2.0), a caret or tilde range (^1.2, ~1.2.3), an x-range (1.x, *), a comparator set (>=1.2.0 <2.0.0) or alternatives joined by \`||\`.`
+      );
+    }
+  }
+};
+
 // src/core/rules/wiring/dependency-cycles.ts
 var cyclesRule = {
   name: "dependency-cycles",
@@ -17844,8 +18317,8 @@ var lifecycleRule = {
 };
 
 // src/core/rules/wiring/portal-mounts.ts
-function liesUnder(path37, prefix) {
-  return path37 === prefix || path37.startsWith(prefix + "/");
+function liesUnder(path38, prefix) {
+  return path38 === prefix || path38.startsWith(prefix + "/");
 }
 var portalMountsRule = {
   name: "portal-mounts",
@@ -18298,8 +18771,8 @@ function componentOfImpl(ctx, implContract) {
 }
 var CLAIM_PHRASES = /\b(persist(s|ed|ent|ing|ence)?|survives?\s+(a\s+)?restart|writ(es?|ten)\s+to\s+disk|registered\s+into|durabl[ey])\b/i;
 var QUOTED_SPAN = /"[^"]*"|“[^”]*”|`[^`]*`|(?<![\p{L}\p{N}])['‘](?:[^'‘’]|(?<=[\p{L}\p{N}])['’](?=[\p{L}\p{N}]))*['’](?![\p{L}\p{N}])/gu;
-function withoutQuotedText(text2) {
-  return text2.replace(QUOTED_SPAN, " ");
+function withoutQuotedText(text3) {
+  return text3.replace(QUOTED_SPAN, " ");
 }
 var proseClaimRule = {
   name: "prose-claims",
@@ -19052,11 +19525,11 @@ var hiddenStateRule = {
         byPath.set(key, list);
       }
     }
-    for (const path37 of code.exactPaths) {
-      const facts = code.factsAt(path37);
+    for (const path38 of code.exactPaths) {
+      const facts = code.factsAt(path38);
       const bindings = facts.topLevelMutableBindings ?? [];
       if (bindings.length === 0) continue;
-      const mapped = byPath.get(path37) ?? [];
+      const mapped = byPath.get(path38) ?? [];
       if (mapped.length === 0) continue;
       if (!mapped.every((m) => isStatelessLogic(m.component))) continue;
       const anchor = [...mapped].sort((a, b) => a.impl.id.localeCompare(b.impl.id))[0];
@@ -19122,7 +19595,7 @@ var dependencyConformanceRule = {
       }
       return false;
     };
-    const draftAt = (path37) => realization.implementationsAt(path37).some((impl) => ctx.isImplementationDraft(impl));
+    const draftAt = (path38) => realization.implementationsAt(path38).some((impl) => ctx.isImplementationDraft(impl));
     for (const fromPath of mappedPaths) {
       const fromComponents = realization.componentsAt(fromPath);
       for (const toPath of graph2.importsOf(fromPath)) {
@@ -19207,7 +19680,7 @@ var portalImportsRule = {
       }
       return files;
     };
-    const draftAt = (path37) => realization.implementationsAt(path37).some((impl) => ctx.isImplementationDraft(impl));
+    const draftAt = (path38) => realization.implementationsAt(path38).some((impl) => ctx.isImplementationDraft(impl));
     for (const fromPath of mappedPaths) {
       const fromSubsystems = new Set(realization.componentsAt(fromPath).map((c) => c.subsystem));
       for (const toPath of graph2.importsOf(fromPath)) {
@@ -19668,7 +20141,7 @@ var paramConformanceRule = {
       codeNameOf.set(type.id, named2);
       if (type.subsystem) codeNameOf.set(`${type.subsystem}.${type.id}`, named2);
     }
-    const normalize3 = (text2) => text2.replace(/\s+/g, " ").trim();
+    const normalize3 = (text3) => text3.replace(/\s+/g, " ").trim();
     const typeAgrees = (declared, realized) => {
       if (!realized.type) return false;
       const stated = normalize3(declared.type);
@@ -19743,8 +20216,8 @@ var paramConformanceRule = {
 };
 
 // src/core/rules/conformance/route-coverage.ts
-function liesUnder2(path37, prefix) {
-  return path37 === prefix || path37.startsWith(prefix + "/");
+function liesUnder2(path38, prefix) {
+  return path38 === prefix || path38.startsWith(prefix + "/");
 }
 function normalizeSegment(segment) {
   return /^\{.+\}$/.test(segment) || segment.startsWith(":") ? "*" : segment;
@@ -20499,9 +20972,9 @@ function makeMatcher(tech) {
   const joined = parts.join("");
   if (joined.length < 3) return null;
   const n = parts.length;
-  return (text2) => {
-    if (!text2) return false;
-    const words2 = text2.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  return (text3) => {
+    if (!text3) return false;
+    const words2 = text3.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
     if (words2.some((w) => w.includes(joined))) return true;
     if (n < 2) return false;
     for (let i = 0; i + n <= words2.length; i++) {
@@ -21425,6 +21898,10 @@ var SDD_RULES = [
   // elsewhere?) rather than spec content.
   packResolutionRule,
   reproducibilityRule,
+  // The syntax of this project's own composition.requirePolicies (governance
+  // stage): configuration too, and the family run cannot judge a member against
+  // a requirement that does not parse.
+  packRequirementsRule,
   // MUST run last, in this order: each audits what the earlier rules did
   // with a declared exception. The debt register first (which carried
   // findings the conformance family actually matched), then the allows
@@ -21590,8 +22067,8 @@ LANGUAGE_PATTERNS.cpp = LANGUAGE_PATTERNS.c;
 var PATTERN_ANALYSIS_MAX_BYTES = 1e6;
 var IDENTIFIER_RE = /[A-Za-z_$][\w$]*/g;
 var STRING_RE = /'([^'\\\n]*(?:\\.[^'\\\n]*)*)'|"([^"\\\n]*(?:\\.[^"\\\n]*)*)"|`([^`\\]*(?:\\.[^`\\]*)*)`/g;
-function stripComments(text2, patterns) {
-  let out = text2;
+function stripComments(text3, patterns) {
+  let out = text3;
   for (const [open, close] of patterns.blockComments) {
     const re = new RegExp(`${escapeRe(open)}[\\s\\S]*?${escapeRe(close)}`, "g");
     out = out.replace(re, " ");
@@ -21617,16 +22094,16 @@ function boundNames(captured, localOnly) {
   }
   return names;
 }
-function collectStrings(text2) {
+function collectStrings(text3) {
   const anchors = /* @__PURE__ */ new Set();
-  for (const m of text2.matchAll(STRING_RE)) {
+  for (const m of text3.matchAll(STRING_RE)) {
     const value = m[1] ?? m[2] ?? m[3];
     if (value) anchors.add(value);
   }
   return anchors;
 }
-function analyzeWithPatterns(text2, patterns) {
-  const stripped = stripComments(text2, patterns);
+function analyzeWithPatterns(text3, patterns) {
+  const stripped = stripComments(text3, patterns);
   const declared = /* @__PURE__ */ new Set();
   const exported = /* @__PURE__ */ new Set();
   const imports = /* @__PURE__ */ new Set();
@@ -21654,7 +22131,7 @@ function analyzeWithPatterns(text2, patterns) {
       }
     }
   }
-  const anchors = collectStrings(text2);
+  const anchors = collectStrings(text3);
   for (const m of stripped.matchAll(IDENTIFIER_RE)) anchors.add(m[0]);
   return {
     analysisGrade: "pattern",
@@ -21665,11 +22142,11 @@ function analyzeWithPatterns(text2, patterns) {
     reexports: []
   };
 }
-function analyzeGeneric(text2) {
+function analyzeGeneric(text3) {
   const words2 = /* @__PURE__ */ new Set();
-  for (const m of text2.matchAll(IDENTIFIER_RE)) words2.add(m[0]);
+  for (const m of text3.matchAll(IDENTIFIER_RE)) words2.add(m[0]);
   const anchors = new Set(words2);
-  for (const s of collectStrings(text2)) anchors.add(s);
+  for (const s of collectStrings(text3)) anchors.add(s);
   return {
     analysisGrade: "generic",
     declaredNames: [...words2],
@@ -22239,14 +22716,14 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
       files.push({ path: sourcePath, status: "unreadable", ...empty });
       continue;
     }
-    const text2 = buffer.toString("utf8");
+    const text3 = buffer.toString("utf8");
     const language = EXTENSION_LANGUAGE[path15.extname(sourcePath).toLowerCase()];
     let analyzed;
     if (language === "typescript" || language === "javascript") {
       const ts = resolveTypeScript(projectRoot);
       if (ts) {
         try {
-          const facts = walkExact(ts, text2, absolute);
+          const facts = walkExact(ts, text3, absolute);
           chaseReexports(ts, facts, absolute, projectRoot, /* @__PURE__ */ new Set([absolute]), exactCache);
           analyzed = {
             analysisGrade: "exact",
@@ -22272,15 +22749,15 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
             reexportOnly: facts.reexportOnly
           };
         } catch {
-          analyzed = analyzeGeneric(text2);
+          analyzed = analyzeGeneric(text3);
         }
       } else {
-        analyzed = analyzeWithPatterns(text2, LANGUAGE_PATTERNS[language]);
+        analyzed = analyzeWithPatterns(text3, LANGUAGE_PATTERNS[language]);
       }
-    } else if (language && LANGUAGE_PATTERNS[language] && text2.length <= PATTERN_ANALYSIS_MAX_BYTES) {
-      analyzed = analyzeWithPatterns(text2, LANGUAGE_PATTERNS[language]);
+    } else if (language && LANGUAGE_PATTERNS[language] && text3.length <= PATTERN_ANALYSIS_MAX_BYTES) {
+      analyzed = analyzeWithPatterns(text3, LANGUAGE_PATTERNS[language]);
     } else {
-      analyzed = analyzeGeneric(text2);
+      analyzed = analyzeGeneric(text3);
     }
     files.push({ path: sourcePath, status: "analyzed", language, ...analyzed });
   }
@@ -22311,24 +22788,24 @@ function clauseBindings(clause, specifier) {
 function readTestFiles(testRoots, projectRoot) {
   const scanned = [];
   for (const key of walkDeclaredRoots(testRoots, [], projectRoot)) {
-    let text2;
+    let text3;
     try {
       const buffer = fs11.readFileSync(path15.resolve(projectRoot, key));
       if (looksBinary(buffer)) continue;
-      text2 = buffer.toString("utf8");
+      text3 = buffer.toString("utf8");
     } catch {
       continue;
     }
     const imports = /* @__PURE__ */ new Set();
-    for (const m of text2.matchAll(NAMED_IMPORT_BINDINGS_RE)) {
+    for (const m of text3.matchAll(NAMED_IMPORT_BINDINGS_RE)) {
       for (const name of boundNames(m[1] ?? "", false)) imports.add(name);
     }
-    const code = stripComments(text2, JS_PATTERNS);
+    const code = stripComments(text3, JS_PATTERNS);
     const bindings = [];
     for (const m of code.matchAll(IMPORT_FROM_RE)) bindings.push(...clauseBindings(m[1], m[2]));
     for (const m of code.matchAll(DYNAMIC_IMPORT_RE)) bindings.push(...clauseBindings(`{${m[1].replace(/:/g, " as ")}}`, m[2]));
     const words2 = /* @__PURE__ */ new Set();
-    for (const m of text2.matchAll(IDENTIFIER_RE)) words2.add(m[0]);
+    for (const m of text3.matchAll(IDENTIFIER_RE)) words2.add(m[0]);
     scanned.push({ path: key, imports, bindings, words: words2 });
   }
   return scanned;
@@ -22745,8 +23222,8 @@ function buildRuleContext(opts) {
   };
   const authoredIndex = /* @__PURE__ */ new Map();
   for (const r of family?.authoredReferences ?? []) {
-    for (const text2 of [r.authored, r.resolved]) {
-      const k = `${r.specId}\0${r.position}\0${text2}`;
+    for (const text3 of [r.authored, r.resolved]) {
+      const k = `${r.specId}\0${r.position}\0${text3}`;
       if (!authoredIndex.has(k)) authoredIndex.set(k, r);
     }
   }
@@ -22926,12 +23403,12 @@ function buildRuleContext(opts) {
     }
     return defaultSeverity;
   };
-  const lintAllows = [];
+  const lintAllows2 = [];
   const allowLookup = /* @__PURE__ */ new Map();
   const collectAllows = (specId, lint) => {
     for (const a of lint?.allow ?? []) {
       const entry = { specId, code: a.code, at: a.at, covers: a.covers, reason: a.reason, used: false };
-      lintAllows.push(entry);
+      lintAllows2.push(entry);
       if (!allowLookup.has(specId)) allowLookup.set(specId, /* @__PURE__ */ new Map());
       const forSpec = allowLookup.get(specId);
       const forCode = forSpec.get(a.code) ?? [];
@@ -22981,7 +23458,7 @@ function buildRuleContext(opts) {
     }
     const severity = getRuleSeverity(code, defaultSeverity, isDraftContext, owner);
     if (severity === "off") return;
-    let text2 = message;
+    let text3 = message;
     if (specId) {
       const key = `${specId}\0${code}`;
       let seen = sitesSeen.get(key);
@@ -22999,7 +23476,7 @@ function buildRuleContext(opts) {
         if (grew.length === 0) {
           if (severity !== "error") return;
         } else {
-          text2 = `${text2} A lint.allow covers this site, but not ${grew.length} part(s) of it \u2014 ${grew.map((u) => `"${u}"`).join("; ")} ${grew.length === 1 ? "is" : "are"} new. Decide on them: add them to the allow's \`covers\` with a reason that is actually true, or fix them.`;
+          text3 = `${text3} A lint.allow covers this site, but not ${grew.length} part(s) of it \u2014 ${grew.map((u) => `"${u}"`).join("; ")} ${grew.length === 1 ? "is" : "are"} new. Decide on them: add them to the allow's \`covers\` with a reason that is actually true, or fix them.`;
         }
       }
     }
@@ -23014,13 +23491,13 @@ function buildRuleContext(opts) {
           else grew.push(unit);
         }
         if (grew.length === 0) return;
-        text2 = `${text2} The conformance debt register carries this finding, but not ${grew.length} part(s) of it \u2014 ${grew.map((u) => `"${u}"`).join("; ")} ${grew.length === 1 ? "is" : "are"} new. Fix them, or add them to the entry's \`covers\` with a reason that is actually true.`;
+        text3 = `${text3} The conformance debt register carries this finding, but not ${grew.length} part(s) of it \u2014 ${grew.map((u) => `"${u}"`).join("; ")} ${grew.length === 1 ? "is" : "are"} new. Fix them, or add them to the entry's \`covers\` with a reason that is actually true.`;
       }
     }
     issues.push({
       severity,
       code,
-      message: text2,
+      message: text3,
       specId,
       ...isDraftContext ? { draftContext: true } : {},
       ...resolution ? { resolution } : {}
@@ -23089,7 +23566,7 @@ function buildRuleContext(opts) {
     documentationConfigFor,
     namingConfigFor,
     isBuiltinType,
-    ext: { profiles: extensions.profiles, languages: extensions.languages, patterns: extensions.patterns, guarantees: extensions.guarantees, assertions: extensions.assertions, packSelections: opts.packSelections ?? [], selectionFailures: extensions.selectionFailures ?? [] },
+    ext: { profiles: extensions.profiles, languages: extensions.languages, patterns: extensions.patterns, guarantees: extensions.guarantees, assertions: extensions.assertions, packSelections: opts.packSelections ?? [], selectionFailures: extensions.selectionFailures ?? [], packRequirements: opts.packRequirements ?? [] },
     variants: opts.variants ?? [],
     surfaceSnapshots,
     ...opts.projectIdentity ? { projectIdentity: opts.projectIdentity } : {},
@@ -23099,7 +23576,7 @@ function buildRuleContext(opts) {
     pinnedExternals,
     codeModel: opts.codeModel ?? emptyCodeModel(),
     roundTripIssues: opts.roundTripIssues,
-    lintAllows,
+    lintAllows: lintAllows2,
     sitesReported,
     knownIssueCodes: opts.knownIssueCodes,
     carriedFindings,
@@ -23158,10 +23635,103 @@ function validateComponentCandidate(candidate, opts = {}) {
   };
 }
 
+// src/core/pack-impact.ts
+var path16 = __toESM(require("path"));
+function authorableStereotypes() {
+  return ComponentTypeSchema.options.filter((t) => !RETIRED_STEREOTYPES.has(t));
+}
+function defaultsBaseline() {
+  registerBuiltinRules();
+  const ruleDefaults = {};
+  for (const code of knownIssueCodes()) ruleDefaults[code.code] = code.defaultSeverity;
+  return {
+    ruleDefaults,
+    profiles: builtinProfileIds(),
+    projectKinds: builtinProjectKinds(),
+    stereotypes: authorableStereotypes(),
+    guarantees: [...SEMANTIC_GUARANTEES],
+    designDepth: "narratives"
+  };
+}
+function sameEntry(a, b) {
+  if (typeof b === "string") return a === b;
+  return typeof a !== "string" && a.name === b.name;
+}
+function entryName(entry) {
+  return typeof entry === "string" ? path16.basename(entry).replace(/\.(ya?ml|cjs|js)$/i, "") : entry.name;
+}
+function unresolvedReason(config, entry) {
+  const alone = { ...config, extensions: { useGlobalPacks: false, packs: [entry] } };
+  const loaded = loadFor(alone);
+  const failure = loaded.selectionFailures[0];
+  if (failure) return `[${failure.code}] ${failure.message}`;
+  return loaded.errors[0] ?? `the pack "${entryName(entry)}" does not resolve`;
+}
+function totals(config, result) {
+  const count = (severity) => result.issues.filter((i) => i.severity === severity).length;
+  const id = effectiveProjectId(config);
+  return {
+    key: "",
+    ...id !== null ? { id } : {},
+    directory: getProjectRoot(),
+    valid: result.valid,
+    errors: count("error"),
+    warnings: count("warning"),
+    notices: count("notice")
+  };
+}
+function governingProfiles(manifest, config) {
+  if (!manifest) return [];
+  const named2 = [config.projectType, ...loadSubsystemSpecs().map((s) => s.profile ?? "")];
+  return [...new Set(named2.filter((p) => p !== "" && p in manifest.profiles))];
+}
+function measure(candidate) {
+  const config = loadProjectConfig();
+  if (!config) throw new Error("Not inside a wairon project: a pack impact is measured on a project \u2014 run `wairon init` first.");
+  const entry = candidate.entry;
+  const remove = candidate.remove === true;
+  let next = entry !== void 0 ? withPack(config, entry, remove) : config;
+  if (candidate.projectType !== void 0) next = { ...next, projectType: candidate.projectType };
+  const current2 = entry !== void 0 ? (config.extensions?.packs ?? []).find((e) => sameEntry(e, entry)) : void 0;
+  let manifest = null;
+  if (candidate.manifest && !remove || entry === void 0) {
+    manifest = candidate.manifest ?? null;
+  } else {
+    const measured = remove ? current2 ?? entry : entry;
+    manifest = manifestOf(measured);
+    if (!manifest) throw new Error(`Cannot measure the pack: ${unresolvedReason(config, measured)}`);
+  }
+  const previous = !remove && current2 !== void 0 ? manifestOf(current2) : null;
+  const baseline = defaultsBaseline();
+  const doctrine2 = manifest ? doctrineChanges(manifest, baseline) : [];
+  const previousDoctrine = previous ? doctrineChanges(previous, baseline) : void 0;
+  const before = validateProject({ rules: config.rules, projectType: config.projectType });
+  const extensions = loadFor(next, candidate);
+  const after = validateProject({
+    rules: next.rules,
+    projectType: next.projectType,
+    extensions,
+    packSelections: (next.extensions?.packs ?? []).filter((e) => typeof e !== "string")
+  });
+  const replaces = previous?.version ?? (current2 !== void 0 && typeof current2 !== "string" ? current2.version : void 0);
+  return {
+    pack: manifest?.name ?? (entry !== void 0 ? entryName(entry) : `projectType ${next.projectType}`),
+    ...manifest?.version ? { version: manifest.version } : {},
+    ...!remove && current2 !== void 0 && replaces ? { replaces } : {},
+    direction: remove ? "remove" : "apply",
+    doctrine: doctrine2,
+    ...previousDoctrine && !remove ? { previousDoctrine } : {},
+    governing: governingProfiles(manifest, remove ? config : next),
+    findings: findingChanges(before, after),
+    before: totals(config, before),
+    after: totals(next, after)
+  };
+}
+
 // src/core/rules/gate-identity.ts
 var crypto3 = __toESM(require("crypto"));
 var GATE_ALGORITHM = "sha256+content+doctrine+inputs";
-function doctrineIdentity(doctrine, builtinRules, gate) {
+function doctrineIdentity(doctrine2, builtinRules, gate) {
   const byKey = (items, key) => [...items].sort((a, b) => compareOrdinal(key(a), key(b)));
   return {
     /**
@@ -23194,29 +23764,29 @@ function doctrineIdentity(doctrine, builtinRules, gate) {
     projectType: gate.projectType ?? null,
     rulesConfig: gate.rules ?? null,
     packs: byKey(
-      doctrine.packs.map((p) => ({ name: p.name, version: p.version ?? null, scope: p.scope })),
+      doctrine2.packs.map((p) => ({ name: p.name, version: p.version ?? null, scope: p.scope })),
       (p) => `${p.name}@${p.version ?? ""}#${p.scope}`
     ),
     // Merged records already encode pack precedence, so their resolved content is
     // the identity — a load-order change that flips a collision winner shows up here.
-    profiles: doctrine.profiles,
-    languages: doctrine.languages,
+    profiles: doctrine2.profiles,
+    languages: doctrine2.languages,
     patterns: byKey(
-      doctrine.patterns.map((p) => ({ id: p.id, version: p.version, pack: p.pack })),
+      doctrine2.patterns.map((p) => ({ id: p.id, version: p.version, pack: p.pack })),
       (p) => `${p.pack}/${p.id}@${p.version}`
     ),
-    guarantees: [...doctrine.guarantees].sort(),
-    assertions: byKey(doctrine.assertions.map((a) => ({ ...a })), (a) => a.fullCode),
+    guarantees: [...doctrine2.guarantees].sort(),
+    assertions: byKey(doctrine2.assertions.map((a) => ({ ...a })), (a) => a.fullCode),
     rules: byKey(
-      doctrine.rules.map((r) => ({ name: r.name, codes: r.codes.map((c) => c.code).sort() })),
+      doctrine2.rules.map((r) => ({ name: r.name, codes: r.codes.map((c) => c.code).sort() })),
       (r) => r.name
     )
   };
 }
-function computeGateIdentity(content, doctrine, builtinRules, inputs, gate) {
+function computeGateIdentity(content, doctrine2, builtinRules, inputs, gate) {
   const payload = {
     content: content.digest,
-    doctrine: doctrineIdentity(doctrine, builtinRules, gate),
+    doctrine: doctrineIdentity(doctrine2, builtinRules, gate),
     inputs: [...inputs].sort()
   };
   const digest2 = crypto3.createHash("sha256").update(canonicalize(payload)).digest("hex");
@@ -23224,7 +23794,7 @@ function computeGateIdentity(content, doctrine, builtinRules, inputs, gate) {
 }
 
 // src/core/validation.ts
-var path16 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 function projectPackSelections() {
   try {
     return (loadProjectConfig()?.extensions?.packs ?? []).filter((e) => typeof e !== "string");
@@ -23232,6 +23802,14 @@ function projectPackSelections() {
     return [];
   }
 }
+function boundPackRequirements() {
+  try {
+    const config = loadProjectConfig();
+    return config ? requiredPolicies(config) : [];
+  } catch {
+    return [];
+  }
+}
 function boundProjectIdentity() {
   let config;
   try {
@@ -23324,13 +23902,15 @@ function validateProject(rulesOrOptions, projectType = "backend") {
   let scopeSubsystem;
   let extensions;
   let treatAllAsComplete = false;
-  if (rulesOrOptions && ("scopeSubsystem" in rulesOrOptions || "recursive" in rulesOrOptions || "rules" in rulesOrOptions || "projectType" in rulesOrOptions || "extensions" in rulesOrOptions || "treatAllAsComplete" in rulesOrOptions || "family" in rulesOrOptions)) {
+  let packSelections;
+  if (rulesOrOptions && ("scopeSubsystem" in rulesOrOptions || "recursive" in rulesOrOptions || "rules" in rulesOrOptions || "projectType" in rulesOrOptions || "extensions" in rulesOrOptions || "treatAllAsComplete" in rulesOrOptions || "family" in rulesOrOptions || "packSelections" in rulesOrOptions)) {
     const opts = rulesOrOptions;
     rules = opts.rules;
     projectType = opts.projectType ?? "backend";
     scopeSubsystem = opts.scopeSubsystem;
     extensions = opts.extensions;
     treatAllAsComplete = opts.treatAllAsComplete ?? false;
+    packSelections = opts.packSelections;
   }
   extensions ??= loadProjectExtensions();
   scanAllSpecs({ recursive: true });
@@ -23429,8 +24009,11 @@ function validateProject(rulesOrOptions, projectType = "backend") {
       projectFamily: family,
       exportUsages,
       pinnedExternals,
-      // By-name selections only: a legacy path ref pins nothing to check.
-      packSelections: projectPackSelections(),
+      // By-name selections only: a legacy path ref pins nothing to check. A dry
+      // run supplies its candidate's; otherwise the stored ones.
+      packSelections: packSelections ?? projectPackSelections(),
+      // The bound project's own requirements, for their syntax only.
+      packRequirements: boundPackRequirements(),
       projectIdentity: boundProjectIdentity(),
       surfaceSnapshots,
       codeModel,
@@ -23465,7 +24048,7 @@ function settledStatusBearing(loaded) {
   if (!settled || settled.size === 0) return [];
   const root = getProjectRoot();
   const index = scanAllSpecs();
-  const rel2 = (abs) => path16.relative(root, abs).split(path16.sep).join("/");
+  const rel2 = (abs) => path17.relative(root, abs).split(path17.sep).join("/");
   const out = [];
   const take = (specs, paths) => {
     for (const spec of specs) {
@@ -23482,6 +24065,15 @@ function settledStatusBearing(loaded) {
 function validateFamily(options) {
   return run(options);
 }
+function measurePackImpact(candidate) {
+  return measure(candidate);
+}
+function builtinProfileIds() {
+  return [...BUILTIN_PROFILES];
+}
+function builtinProjectKinds() {
+  return [...PROJECT_KINDS];
+}
 function computeGateStateId() {
   const content = computeStateId();
   const extensions = loadProjectExtensions();
@@ -23646,11 +24238,11 @@ var IdPool = class {
     return candidate;
   }
 };
-function escapeLabel(text2) {
-  return text2.replace(/"/g, "#quot;");
+function escapeLabel(text3) {
+  return text3.replace(/"/g, "#quot;");
 }
-function truncate(text2, max) {
-  const clean = text2.replace(/\s+/g, " ").trim();
+function truncate(text3, max) {
+  const clean = text3.replace(/\s+/g, " ").trim();
   return clean.length <= max ? clean : `${clean.slice(0, max - 1)}\u2026`;
 }
 function nodeDecl(id, label2, comp) {
@@ -24024,10 +24616,10 @@ function diagramSetIndex(files, systemName) {
 }
 
 // src/core/project-family.ts
-var path17 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 var memo = /* @__PURE__ */ new WeakMap();
 function dirKey(dir) {
-  const resolved = path17.resolve(dir);
+  const resolved = path18.resolve(dir);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function makeNodes(roots) {
@@ -24101,7 +24693,7 @@ function bindExternals(node, root, nodes) {
     const unresolved = (problem) => ({ alias: decl.alias, project: decl.project, sourceKind: "unresolved", audience: "instance", problem });
     if (decl.problem) return unresolved(decl.problem);
     if (decl.sourcePath !== void 0) {
-      const directory = path17.resolve(node.directory, decl.sourcePath);
+      const directory = path18.resolve(node.directory, decl.sourcePath);
       const found = nodes.find((n) => dirKey(n.directory) === dirKey(directory));
       if (!found) return { alias: decl.alias, project: decl.project, sourceKind: "path", directory, audience: "instance" };
       if (found.id !== decl.project) {
@@ -24717,42 +25309,42 @@ function emptyIndex() {
   };
 }
 function isWithin(dir, file) {
-  const d = path18.resolve(dir);
-  const f = path18.resolve(file);
-  return f === d || f.startsWith(d + path18.sep);
+  const d = path19.resolve(dir);
+  const f = path19.resolve(file);
+  return f === d || f.startsWith(d + path19.sep);
 }
 function canonicalPath(target) {
-  let existing = path18.resolve(target);
+  let existing = path19.resolve(target);
   const rest = [];
   for (; ; ) {
     try {
       fs12.lstatSync(existing);
       break;
     } catch {
-      const up = path18.dirname(existing);
-      if (up === existing) return path18.resolve(target);
-      rest.unshift(path18.basename(existing));
+      const up = path19.dirname(existing);
+      if (up === existing) return path19.resolve(target);
+      rest.unshift(path19.basename(existing));
       existing = up;
     }
   }
   try {
-    return path18.join(fs12.realpathSync.native(existing), ...rest);
+    return path19.join(fs12.realpathSync.native(existing), ...rest);
   } catch {
     return null;
   }
 }
 function chainDirKey(dir) {
-  return canonicalPath(dir) ?? path18.resolve(dir);
+  return canonicalPath(dir) ?? path19.resolve(dir);
 }
 function projectPathEscapesRoot(projectRoot, projectPath, resolvedChildDir) {
-  if (path18.isAbsolute(projectPath) || !isWithin(projectRoot, resolvedChildDir)) return true;
+  if (path19.isAbsolute(projectPath) || !isWithin(projectRoot, resolvedChildDir)) return true;
   const root = canonicalPath(projectRoot);
   const child = canonicalPath(resolvedChildDir);
   return root === null || child === null || !isWithin(root, child);
 }
 function assertContainedProjectPath(projectRoot, projectPath) {
-  const root = path18.resolve(projectRoot);
-  const resolved = path18.resolve(root, projectPath);
+  const root = path19.resolve(projectRoot);
+  const resolved = path19.resolve(root, projectPath);
   if (projectPathEscapesRoot(root, projectPath, resolved)) {
     throw new Error(
       `projectPath "${projectPath}" must resolve within the project root "${root}", but resolves to "${resolved}"; absolute, ../-escaping and link-escaping paths are rejected so a chained subproject is always contained by its parent.`
@@ -24822,19 +25414,19 @@ function memberDeclarationsAt(dir) {
 function findChainingParent(childRoot, ceiling) {
   let childResolved;
   try {
-    childResolved = path18.resolve(childRoot);
+    childResolved = path19.resolve(childRoot);
   } catch {
     return null;
   }
-  const bound2 = ceiling ? path18.resolve(ceiling) : void 0;
-  let dir = path18.dirname(childResolved);
+  const bound2 = ceiling ? path19.resolve(ceiling) : void 0;
+  let dir = path19.dirname(childResolved);
   for (let hops = 0; hops < 32; hops++) {
     if (bound2 && !isWithin(bound2, dir)) break;
     if (pathExists(aiPathsAt(dir).specsDir()) || pathExists(aiPathsAt(dir).projectConfig())) {
       for (const member of memberDeclarationsAt(dir)) {
         if (member.problem || member.path.trim() === "") continue;
         try {
-          const memberDir = path18.resolve(dir, member.path);
+          const memberDir = path19.resolve(dir, member.path);
           if (chainDirKey(memberDir) === chainDirKey(childResolved) && !projectPathEscapesRoot(dir, member.path, memberDir)) {
             return { parentRoot: dir, alias: member.alias, form: member.form };
           }
@@ -24842,14 +25434,14 @@ function findChainingParent(childRoot, ceiling) {
         }
       }
     }
-    const up = path18.dirname(dir);
+    const up = path19.dirname(dir);
     if (up === dir) break;
     dir = up;
   }
   return null;
 }
 function inspectChainedRoots(rootDir = getProjectRoot()) {
-  const root = path18.resolve(rootDir);
+  const root = path19.resolve(rootDir);
   const inspection = { roots: [], skipped: [] };
   const listed = /* @__PURE__ */ new Set();
   const walk2 = (projectDir, prefix, ancestors, depth) => {
@@ -24857,11 +25449,11 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
       const key = prefix ? `${prefix}::${member.alias}` : member.alias;
       let childDir;
       try {
-        childDir = path18.resolve(projectDir, member.path);
+        childDir = path19.resolve(projectDir, member.path);
       } catch {
         continue;
       }
-      if (member.problem && !path18.isAbsolute(member.path)) continue;
+      if (member.problem && !path19.isAbsolute(member.path)) continue;
       let reason;
       if (projectPathEscapesRoot(projectDir, member.path, childDir)) reason = "escapes";
       else if (ancestors.has(chainDirKey(childDir))) reason = "cyclic";
@@ -24874,7 +25466,7 @@ function inspectChainedRoots(rootDir = getProjectRoot()) {
       const dirKey3 = chainDirKey(childDir);
       if (listed.has(dirKey3)) continue;
       listed.add(dirKey3);
-      inspection.roots.push(path18.relative(root, childDir).split(path18.sep).join("/"));
+      inspection.roots.push(path19.relative(root, childDir).split(path19.sep).join("/"));
       walk2(childDir, key, /* @__PURE__ */ new Set([...ancestors, dirKey3]), depth + 1);
     }
   };
@@ -25079,9 +25671,9 @@ function mapRawReferences(kind, spec, map) {
 }
 function childRelativeFilePaths(spec, authoringRoot, childRoot) {
   const reexpress = (p) => {
-    if (path18.isAbsolute(p)) return p;
-    const rel2 = path18.relative(childRoot, path18.resolve(authoringRoot, p));
-    const inside = rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path18.sep}`) && !path18.isAbsolute(rel2);
+    if (path19.isAbsolute(p)) return p;
+    const rel2 = path19.relative(childRoot, path19.resolve(authoringRoot, p));
+    const inside = rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path19.sep}`) && !path19.isAbsolute(rel2);
     return inside ? rel2.replace(/\\/g, "/") : p;
   };
   return {
@@ -25335,9 +25927,9 @@ function findOwner(id, components) {
   }) ?? null;
 }
 function moveComponentFolder(fromDir, toDir) {
-  if (path18.normalize(fromDir) === path18.normalize(toDir)) return false;
+  if (path19.normalize(fromDir) === path19.normalize(toDir)) return false;
   if (!fs12.existsSync(fromDir) || fs12.existsSync(toDir)) return false;
-  ensureDir(path18.dirname(toDir));
+  ensureDir(path19.dirname(toDir));
   fs12.renameSync(fromDir, toDir);
   return true;
 }
@@ -25475,8 +26067,8 @@ function rewriteSpecRefs(raw, remap) {
 }
 function summarizeValue(value) {
   if (value === void 0) return "";
-  const text2 = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
-  return text2.length > 120 ? `${text2.slice(0, 117)}...` : text2;
+  const text3 = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+  return text3.length > 120 ? `${text3.slice(0, 117)}...` : text3;
 }
 function identityKeyOf(field, item) {
   if (item === null || typeof item !== "object") return null;
@@ -25799,13 +26391,13 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
   const isPlain = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
   const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
   const at = (prefix, key) => prefix ? `${prefix}.${key}` : key;
-  const say = (path37, why) => {
-    out.push(`${path37} \u2014 ${why}`);
+  const say = (path38, why) => {
+    out.push(`${path38} \u2014 ${why}`);
   };
-  const walkValue = (d, m, s, path37, field) => {
+  const walkValue = (d, m, s, path38, field) => {
     if (Array.isArray(d)) {
       if (!Array.isArray(m)) {
-        say(path37, "the level does not have this field, so the write dropped it");
+        say(path38, "the level does not have this field, so the write dropped it");
         return;
       }
       if (field === "narrative" && d.some(carriesEditMarker)) return;
@@ -25813,32 +26405,32 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
         if (carriesEditMarker(element)) continue;
         const key = reportIdentityOf(field, element);
         if (key === null) {
-          if (!same(m, d)) say(path37, "the level does not keep this value, so the write dropped it");
-          else if (same(s, d)) say(path37, "the stored spec already held this value");
+          if (!same(m, d)) say(path38, "the level does not keep this value, so the write dropped it");
+          else if (same(s, d)) say(path38, "the stored spec already held this value");
           return;
         }
         const mMatch = m.find((i) => reportIdentityOf(field, i) === key);
         const sMatch = Array.isArray(s) ? s.find((i) => reportIdentityOf(field, i) === key) : void 0;
         if (mMatch === void 0) {
-          say(at(path37, key), "the write did not store this element");
+          say(at(path38, key), "the write did not store this element");
           continue;
         }
-        walk2(element, mMatch, sMatch, at(path37, key), field);
+        walk2(element, mMatch, sMatch, at(path38, key), field);
       }
       return;
     }
     if (isPlain(d)) {
       if (!isPlain(m)) {
-        say(path37, "the level does not have this field, so the write dropped it");
+        say(path38, "the level does not have this field, so the write dropped it");
         return;
       }
-      walk2(d, m, s, path37, field);
+      walk2(d, m, s, path38, field);
       return;
     }
-    if (!same(m, d)) say(path37, "the write did not store it \u2014 the level's schema does not keep this value");
-    else if (same(s, d)) say(path37, "the stored spec already held this value");
+    if (!same(m, d)) say(path38, "the write did not store it \u2014 the level's schema does not keep this value");
+    else if (same(s, d)) say(path38, "the stored spec already held this value");
   };
-  function walk2(d, m, s, path37, container) {
+  function walk2(d, m, s, path38, container) {
     for (const [key, value] of Object.entries(d)) {
       if (DELTA_VERBS.has(key) || JUMP_LABEL_TWINS.has(key)) continue;
       if (key === "label" && LABEL_TWIN_CONTAINERS.has(container)) continue;
@@ -25848,13 +26440,13 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
           if (typeof name !== "string") continue;
           const had = isPlain(s) && s[name] !== void 0;
           const still = isPlain(m) && m[name] !== void 0;
-          if (!had) say(at(path37, name), "unset named a field the stored spec did not have");
-          else if (still) say(at(path37, name), "unset did not remove it");
+          if (!had) say(at(path38, name), "unset named a field the stored spec did not have");
+          else if (still) say(at(path38, name), "unset did not remove it");
         }
         continue;
       }
       if (value === void 0 || value === null) continue;
-      const here = at(path37, key);
+      const here = at(path38, key);
       const mValue = isPlain(m) ? m[key] : void 0;
       const sValue = isPlain(s) ? s[key] : void 0;
       if (mValue === void 0) {
@@ -25885,7 +26477,7 @@ var SpecWorkspace = class {
     /** Set while normalizeReferences writes: every reference in its canonical form, no authored text carried. */
     this.carryDisabled = false;
     this.loaderIssues = [];
-    this.rootDir = path18.resolve(rootDir);
+    this.rootDir = path19.resolve(rootDir);
     this.paths = aiPathsAt(this.rootDir);
   }
   /**
@@ -25948,8 +26540,8 @@ var SpecWorkspace = class {
    * itself — so scoping a validate to a member keeps it.
    */
   loaderIssueSpecId(file, rawId, key) {
-    const stem = path18.basename(file, ".yaml");
-    const local = rawId ?? (stem.startsWith(".") ? path18.basename(path18.dirname(file)) : stem);
+    const stem = path19.basename(file, ".yaml");
+    const local = rawId ?? (stem.startsWith(".") ? path19.basename(path19.dirname(file)) : stem);
     return keyIn(key, local);
   }
   /**
@@ -25999,7 +26591,7 @@ var SpecWorkspace = class {
       ...member ? { mountAlias: member.alias, mountForm: member.form } : {},
       legacyMount: member?.legacyMount ?? null,
       ...member?.description !== void 0 ? { memberDescription: member.description } : {},
-      directory: path18.resolve(dir),
+      directory: path19.resolve(dir),
       system: null,
       config,
       aliases: /* @__PURE__ */ new Map(),
@@ -26012,7 +26604,7 @@ var SpecWorkspace = class {
     const raw = {
       record,
       aliasPath,
-      dir: path18.resolve(dir),
+      dir: path19.resolve(dir),
       index: emptyIndex(),
       mounts: [],
       members: [],
@@ -26042,14 +26634,14 @@ var SpecWorkspace = class {
   followableMember(raw, decl, ancestors) {
     const memberKey = keyIn(raw.record.namespace, decl.alias);
     const by = decl.form === "mount" ? "subsystem" : "member";
-    const absolute = path18.isAbsolute(decl.path) || path18.win32.isAbsolute(decl.path);
+    const absolute = path19.isAbsolute(decl.path) || path19.win32.isAbsolute(decl.path);
     if (decl.problem && !absolute) {
       if (decl.problem.includes("`externals`")) {
         raw.record.problems.push({ kind: "alias-conflict", id: decl.alias, projects: [raw.record.namespace], detail: decl.problem });
       }
       return null;
     }
-    const childDir = path18.resolve(raw.dir, decl.path);
+    const childDir = path19.resolve(raw.dir, decl.path);
     if (projectPathEscapesRoot(raw.dir, decl.path, childDir)) {
       this.loaderIssues.push({
         severity: "error",
@@ -26086,7 +26678,7 @@ var SpecWorkspace = class {
     const specsDir = projectPaths.specsDir();
     this.scanVisitedSpecDirs.push(specsDir);
     if (!pathExists(specsDir)) return;
-    const systemYaml = path18.normalize(projectPaths.specsSystem());
+    const systemYaml = path19.normalize(projectPaths.specsSystem());
     if (pathExists(systemYaml)) {
       try {
         raw.rawSystem = SystemSpecSchema.parse(readSpecFile(systemYaml));
@@ -26110,7 +26702,7 @@ var SpecWorkspace = class {
       index.paths[kind][spec.id] = file;
     };
     for (const file of listSpecFiles(specsDir)) {
-      if (path18.normalize(file) === systemYaml) continue;
+      if (path19.normalize(file) === systemYaml) continue;
       let detectedType = "spec";
       let rawId;
       try {
@@ -26140,7 +26732,7 @@ var SpecWorkspace = class {
         } else if ("contract" in doc) {
           detectedType = "implementation";
           const parsed = ImplementationSpecSchema.parse(doc);
-          const normalizeSourcePath = (p) => path18.relative(raw.dir, path18.resolve(raw.dir, p)).replace(/\\/g, "/");
+          const normalizeSourcePath = (p) => path19.relative(raw.dir, path19.resolve(raw.dir, p)).replace(/\\/g, "/");
           if (parsed.sourcePath) parsed.sourcePath = normalizeSourcePath(parsed.sourcePath);
           for (const method of parsed.methods) {
             if (method.sourcePath) method.sourcePath = normalizeSourcePath(method.sourcePath);
@@ -26279,7 +26871,7 @@ var SpecWorkspace = class {
       const others = raws.filter((r) => r !== raw);
       let producer;
       if (decl.sourcePath !== void 0) {
-        const at = chainDirKey(path18.resolve(raw.dir, decl.sourcePath));
+        const at = chainDirKey(path19.resolve(raw.dir, decl.sourcePath));
         producer = others.find((r) => chainDirKey(r.dir) === at && idOf(r) === decl.project);
       } else {
         const holders = others.filter((r) => idOf(r) === decl.project);
@@ -26431,9 +27023,9 @@ var SpecWorkspace = class {
       return index.paths.subsystem[matches[0]];
     }
     if (pathExists(this.paths.specsSubsystemsDir()) && listFiles(this.paths.specsSubsystemsDir(), ".yaml").length > 0) {
-      return path18.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
+      return path19.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);
     }
-    return path18.join(this.paths.specsDir(), id, ".index.yaml");
+    return path19.join(this.paths.specsDir(), id, ".index.yaml");
   }
   getComponentPath(id, subsystemId) {
     const index = this.scanAll();
@@ -26453,21 +27045,21 @@ var SpecWorkspace = class {
     if (owner) {
       const ownerPath = index.paths.component[owner.id];
       if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-        return path18.join(path18.dirname(ownerPath), id, ".index.yaml");
+        return path19.join(path19.dirname(ownerPath), id, ".index.yaml");
       }
     }
     if (subsystemId) {
       const subPath = this.getSubsystemPath(subsystemId);
-      const subDir = path18.dirname(subPath);
+      const subDir = path19.dirname(subPath);
       if (subPath.endsWith(".index.yaml")) {
-        return path18.join(subDir, id, ".index.yaml");
+        return path19.join(subDir, id, ".index.yaml");
       }
     }
     if (pathExists(this.paths.specsComponentsDir()) && listFiles(this.paths.specsComponentsDir(), ".yaml").length > 0) {
-      return path18.join(this.paths.specsComponentsDir(), `${id}.yaml`);
+      return path19.join(this.paths.specsComponentsDir(), `${id}.yaml`);
     }
     const targetSubsystem = subsystemId || "default";
-    return path18.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
+    return path19.join(this.paths.specsDir(), targetSubsystem, id, ".index.yaml");
   }
   getInterfacePath(id, componentId) {
     const index = this.scanAll();
@@ -26493,16 +27085,16 @@ var SpecWorkspace = class {
     }
     if (componentId) {
       const compPath = this.getComponentPath(componentId);
-      const compDir = path18.dirname(compPath);
+      const compDir = path19.dirname(compPath);
       if (compPath.endsWith(".index.yaml")) {
-        return path18.join(compDir, ".interface.yaml");
+        return path19.join(compDir, ".interface.yaml");
       }
     }
     if (pathExists(this.paths.specsInterfacesDir()) && listFiles(this.paths.specsInterfacesDir(), ".yaml").length > 0) {
-      return path18.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
+      return path19.join(this.paths.specsInterfacesDir(), `${id}.yaml`);
     }
     const targetComponent = componentId || "default";
-    return path18.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
+    return path19.join(this.paths.specsDir(), "default", targetComponent, ".interface.yaml");
   }
   getImplementationPath(id, contractId) {
     const index = this.scanAll();
@@ -26528,16 +27120,16 @@ var SpecWorkspace = class {
     }
     if (contractId) {
       const intfPath = this.getInterfacePath(contractId);
-      const intfDir = path18.dirname(intfPath);
+      const intfDir = path19.dirname(intfPath);
       if (intfPath.endsWith(".interface.yaml")) {
-        return path18.join(intfDir, ".implementation.yaml");
+        return path19.join(intfDir, ".implementation.yaml");
       }
     }
     if (pathExists(this.paths.specsImplementationsDir()) && listFiles(this.paths.specsImplementationsDir(), ".yaml").length > 0) {
-      return path18.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
+      return path19.join(this.paths.specsImplementationsDir(), `${id}.yaml`);
     }
     const targetContract = contractId ? contractId.replace(/^i/, "") : "default";
-    return path18.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
+    return path19.join(this.paths.specsDir(), "default", targetContract, ".implementation.yaml");
   }
   getTypePath(id, subsystemId, group) {
     const index = this.scanAll();
@@ -26568,7 +27160,7 @@ var SpecWorkspace = class {
       const groupPath = index.paths.group[targetGroup] || index.paths.group[plainGroup];
       if (groupPath) {
         const localId2 = id.split("::").pop();
-        return path18.join(path18.dirname(groupPath), `${localId2}.yaml`);
+        return path19.join(path19.dirname(groupPath), `${localId2}.yaml`);
       }
     }
     let localId = id;
@@ -26581,12 +27173,12 @@ var SpecWorkspace = class {
     }
     if (subsystemId) {
       const subPath = this.getSubsystemPath(subsystemId);
-      const subDir = path18.dirname(subPath);
+      const subDir = path19.dirname(subPath);
       if (subPath.endsWith(".index.yaml")) {
-        return path18.join(subDir, "types", `${localId}.yaml`);
+        return path19.join(subDir, "types", `${localId}.yaml`);
       }
     }
-    return path18.join(this.paths.specsTypesDir(), `${localId}.yaml`);
+    return path19.join(this.paths.specsTypesDir(), `${localId}.yaml`);
   }
   getGroupPath(id, subsystemId) {
     const index = this.scanAll();
@@ -26620,12 +27212,12 @@ var SpecWorkspace = class {
     }
     if (subsystemId) {
       const subPath = this.getSubsystemPath(subsystemId);
-      const subDir = path18.dirname(subPath);
+      const subDir = path19.dirname(subPath);
       if (subPath.endsWith(".index.yaml")) {
-        return path18.join(subDir, "types", localId, ".index.yaml");
+        return path19.join(subDir, "types", localId, ".index.yaml");
       }
     }
-    return path18.join(this.paths.specsTypesDir(), localId, ".index.yaml");
+    return path19.join(this.paths.specsTypesDir(), localId, ".index.yaml");
   }
   // -------------------------------------------------------------------------
   // Level 0: System
@@ -26648,7 +27240,7 @@ var SpecWorkspace = class {
   }
   saveSystemSpec(spec) {
     const p = this.paths.specsSystem();
-    ensureDir(path18.dirname(p));
+    ensureDir(path19.dirname(p));
     writeSpecFile(p, parseOrThrow(SystemSpecSchema, spec, "system", spec.name));
     invalidateSpecCache();
   }
@@ -26769,7 +27361,7 @@ var SpecWorkspace = class {
    */
   writeSubsystemSpec(spec, opts) {
     const p = this.getSubsystemPath(spec.id);
-    ensureDir(path18.dirname(p));
+    ensureDir(path19.dirname(p));
     const { prefix } = splitNamespace(spec.id);
     let specToWrite = this.prepareSubsystemForWrite(spec);
     if (prefix) {
@@ -26833,7 +27425,7 @@ var SpecWorkspace = class {
   saveComponentSpec(spec, opts) {
     const notices = [];
     const p = this.getComponentPath(spec.id, spec.subsystem);
-    ensureDir(path18.dirname(p));
+    ensureDir(path19.dirname(p));
     const specToWrite = this.prepareComponentForWrite(spec);
     const existing = this.loadComponentSpec(spec.id);
     if (existing) {
@@ -26850,7 +27442,7 @@ var SpecWorkspace = class {
     const subsystemChanged = existing && existing.subsystem !== spec.subsystem && splitNamespace(existing.subsystem).localId !== splitNamespace(spec.subsystem).localId;
     if (subsystemChanged && !p.endsWith(".index.yaml")) {
       notices.push(
-        `component "${spec.id}" already exists at ${path18.relative(this.rootDir, p)} \u2014 the flat layout re-saves in place and never relocates the file. The subsystem field is now "${spec.subsystem}" (was "${existing.subsystem}").`
+        `component "${spec.id}" already exists at ${path19.relative(this.rootDir, p)} \u2014 the flat layout re-saves in place and never relocates the file. The subsystem field is now "${spec.subsystem}" (was "${existing.subsystem}").`
       );
     }
     specToWrite.updatedAt = opts?.preserveUpdatedAt && existing?.updatedAt ? existing.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
@@ -26874,12 +27466,12 @@ var SpecWorkspace = class {
     if (owner) {
       const ownerPath = index.paths.component[owner.id];
       if (ownerPath && ownerPath.endsWith(".index.yaml")) {
-        const ownerSubDir = path18.dirname(this.getSubsystemPath(owner.subsystem));
-        return path18.join(ownerSubDir, owner.id, comp.id);
+        const ownerSubDir = path19.dirname(this.getSubsystemPath(owner.subsystem));
+        return path19.join(ownerSubDir, owner.id, comp.id);
       }
     }
-    const subDir = path18.dirname(this.getSubsystemPath(comp.subsystem));
-    return path18.join(subDir, comp.id);
+    const subDir = path19.dirname(this.getSubsystemPath(comp.subsystem));
+    return path19.join(subDir, comp.id);
   }
   /**
    * Move component folders so the physical tree mirrors ownership: each owned
@@ -26895,7 +27487,7 @@ var SpecWorkspace = class {
       if (!currentPath) continue;
       const desiredDir = this.desiredComponentDir(comp, index);
       if (!desiredDir) continue;
-      if (moveComponentFolder(path18.dirname(currentPath), desiredDir)) moved.push(comp.id);
+      if (moveComponentFolder(path19.dirname(currentPath), desiredDir)) moved.push(comp.id);
     }
     if (moved.length) invalidateSpecCache();
     return moved;
@@ -26951,7 +27543,7 @@ var SpecWorkspace = class {
     if (!occupantId) return;
     if (occupantId === id || splitNamespace(occupantId).localId === splitNamespace(id).localId) return;
     throw new Error(
-      `Cannot write ${kind} "${id}": ${parentLabel} is already ${kind === "interface" ? "served by" : "implemented by"} "${occupantId}" at ${path18.relative(this.rootDir, p)}, and both ids resolve to that one file. Re-author "${occupantId}" instead, or delete it first if you meant to replace it.`
+      `Cannot write ${kind} "${id}": ${parentLabel} is already ${kind === "interface" ? "served by" : "implemented by"} "${occupantId}" at ${path19.relative(this.rootDir, p)}, and both ids resolve to that one file. Re-author "${occupantId}" instead, or delete it first if you meant to replace it.`
     );
   }
   /** Returns non-fatal placement notices (see saveTypeSpec) — empty when there is nothing to clarify. */
@@ -26959,12 +27551,12 @@ var SpecWorkspace = class {
     const notices = [];
     const p = this.getInterfacePath(spec.id, spec.component);
     this.assertPathHoldsNoOtherSpec(p, spec.id, "interface", `component "${spec.component}"`);
-    ensureDir(path18.dirname(p));
+    ensureDir(path19.dirname(p));
     const specToWrite = this.prepareInterfaceForWrite(spec);
     const existing = this.loadInterfaceSpec(spec.id);
     if (existing && existing.component !== spec.component && splitNamespace(existing.component).localId !== splitNamespace(spec.component).localId) {
       notices.push(
-        `interface "${spec.id}" already exists at ${path18.relative(this.rootDir, p)} \u2014 re-saving updates the component binding field in place (now "${spec.component}", was "${existing.component}") and never moves the file.`
+        `interface "${spec.id}" already exists at ${path19.relative(this.rootDir, p)} \u2014 re-saving updates the component binding field in place (now "${spec.component}", was "${existing.component}") and never moves the file.`
       );
     }
     if (existing) {
@@ -27021,12 +27613,12 @@ var SpecWorkspace = class {
     const notices = [];
     const p = this.getImplementationPath(spec.id, spec.contract);
     this.assertPathHoldsNoOtherSpec(p, spec.id, "implementation", `contract "${spec.contract}"`);
-    ensureDir(path18.dirname(p));
+    ensureDir(path19.dirname(p));
     const specToWrite = this.prepareImplementationForWrite(spec);
     const existing = this.loadImplementationSpec(spec.id);
     if (existing && existing.contract !== spec.contract && splitNamespace(existing.contract).localId !== splitNamespace(spec.contract).localId) {
       notices.push(
-        `implementation "${spec.id}" already exists at ${path18.relative(this.rootDir, p)} \u2014 re-saving updates the contract binding field in place (now "${spec.contract}", was "${existing.contract}") and never moves the file.`
+        `implementation "${spec.id}" already exists at ${path19.relative(this.rootDir, p)} \u2014 re-saving updates the contract binding field in place (now "${spec.contract}", was "${existing.contract}") and never moves the file.`
       );
     }
     if (existing) {
@@ -27067,11 +27659,11 @@ var SpecWorkspace = class {
     const existing = this.loadTypeSpec(spec.id);
     const group = spec.group || (existing ? existing.group : void 0);
     const p = this.getTypePath(spec.id, spec.subsystem, group);
-    ensureDir(path18.dirname(p));
+    ensureDir(path19.dirname(p));
     const subsystemChanged = existing && (existing.subsystem ?? "") !== (spec.subsystem ?? "") && splitNamespace(existing.subsystem ?? "").localId !== splitNamespace(spec.subsystem ?? "").localId;
     if (subsystemChanged) {
       notices.push(
-        `type "${spec.id}" already exists at ${path18.relative(this.rootDir, p)} \u2014 re-saving updates fields in place and never relocates the file. The subsystem field is now "${spec.subsystem ?? "(none)"}" (was "${existing.subsystem ?? "(none)"}").`
+        `type "${spec.id}" already exists at ${path19.relative(this.rootDir, p)} \u2014 re-saving updates fields in place and never relocates the file. The subsystem field is now "${spec.subsystem ?? "(none)"}" (was "${existing.subsystem ?? "(none)"}").`
       );
     }
     if (spec.subsystem && (!existing || subsystemChanged) && !this.getSubsystemPath(spec.subsystem).endsWith(".index.yaml")) {
@@ -27109,7 +27701,7 @@ var SpecWorkspace = class {
   }
   saveGroupSpec(spec, opts) {
     const p = this.getGroupPath(spec.id);
-    ensureDir(path18.dirname(p));
+    ensureDir(path19.dirname(p));
     const specToWrite = this.prepareGroupForWrite(spec);
     const existing = this.loadGroupSpec(spec.id);
     if (existing) {
@@ -27360,7 +27952,7 @@ var SpecWorkspace = class {
     };
     const out = /* @__PURE__ */ new Set();
     const add = (p) => {
-      if (p) out.add(path18.resolve(p));
+      if (p) out.add(path19.resolve(p));
     };
     for (const s of this.loadSubsystemSpecs()) {
       if (!scopeSubsystem || s.id === scopeSubsystem || s.id.startsWith(`${scopeSubsystem}::`)) {
@@ -27431,11 +28023,11 @@ var SpecWorkspace = class {
     const files = /* @__PURE__ */ new Set();
     const sysPath = this.paths.specsSystem();
     if (pathExists(sysPath)) {
-      files.add(path18.resolve(sysPath));
+      files.add(path19.resolve(sysPath));
     }
     for (const group of Object.values(index.paths)) {
       for (const file of Object.values(group)) {
-        files.add(path18.resolve(file));
+        files.add(path19.resolve(file));
       }
     }
     for (const file of files) {
@@ -27454,20 +28046,20 @@ var SpecWorkspace = class {
     const files = listSpecFiles(specsDir);
     const legacy = [];
     for (const f of files) {
-      const base = path18.basename(f);
-      const dir = path18.dirname(f);
+      const base = path19.basename(f);
+      const dir = path19.dirname(f);
       if (base === "system.yaml") {
-        legacy.push({ path: f, expected: path18.join(dir, ".index.yaml") });
+        legacy.push({ path: f, expected: path19.join(dir, ".index.yaml") });
       } else if (base === "subsystem.yaml") {
-        legacy.push({ path: f, expected: path18.join(dir, ".index.yaml") });
+        legacy.push({ path: f, expected: path19.join(dir, ".index.yaml") });
       } else if (base === "component.yaml") {
-        legacy.push({ path: f, expected: path18.join(dir, ".index.yaml") });
+        legacy.push({ path: f, expected: path19.join(dir, ".index.yaml") });
       } else if (base === "group.yaml") {
-        legacy.push({ path: f, expected: path18.join(dir, ".index.yaml") });
+        legacy.push({ path: f, expected: path19.join(dir, ".index.yaml") });
       } else if (base === "interface.yaml") {
-        legacy.push({ path: f, expected: path18.join(dir, ".interface.yaml") });
+        legacy.push({ path: f, expected: path19.join(dir, ".interface.yaml") });
       } else if (base === "implementation.yaml") {
-        legacy.push({ path: f, expected: path18.join(dir, ".implementation.yaml") });
+        legacy.push({ path: f, expected: path19.join(dir, ".implementation.yaml") });
       }
     }
     return legacy;
@@ -28644,7 +29236,7 @@ function refusedMoveSummary(from, to, methods, refusals, alternatives) {
 }
 var workspaces = /* @__PURE__ */ new Map();
 function workspaceFor(rootDir) {
-  const key = path18.resolve(rootDir);
+  const key = path19.resolve(rootDir);
   let ws = workspaces.get(key);
   if (!ws) {
     ws = new SpecWorkspace(key);
@@ -28771,7 +29363,7 @@ function snapshotInputsIn(dir, kind) {
   for (const file of fs12.readdirSync(dir).sort()) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
     try {
-      keys.push(`${kind}:${snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path18.join(dir, file))))}`);
+      keys.push(`${kind}:${snapshotInputKey(SurfaceSnapshotSchema.parse(readYamlFile(path19.join(dir, file))))}`);
     } catch {
     }
   }
@@ -28779,10 +29371,10 @@ function snapshotInputsIn(dir, kind) {
 }
 function consumedSurfaceInputsAt(rootDir) {
   const keys = [
-    ...snapshotInputsIn(path18.join(rootDir, ".wai", "surfaces"), "surface"),
-    ...snapshotInputsIn(path18.join(rootDir, ".wai", "externals"), "external")
+    ...snapshotInputsIn(path19.join(rootDir, ".wai", "surfaces"), "surface"),
+    ...snapshotInputsIn(path19.join(rootDir, ".wai", "externals"), "external")
   ];
-  const lock = path18.join(rootDir, ".wai", "externals.lock.yaml");
+  const lock = path19.join(rootDir, ".wai", "externals.lock.yaml");
   if (pathExists(lock)) {
     try {
       keys.push(`lock:${canonicalize(readYamlFile(lock))}`);
@@ -28793,7 +29385,7 @@ function consumedSurfaceInputsAt(rootDir) {
 }
 function consumedContractInputs() {
   const root = getProjectRoot();
-  const roots = [root, ...listChainedRoots(root).map((rel2) => path18.join(root, rel2))];
+  const roots = [root, ...listChainedRoots(root).map((rel2) => path19.join(root, rel2))];
   return roots.flatMap(consumedSurfaceInputsAt);
 }
 function readLockState(current2) {
@@ -28838,7 +29430,7 @@ function importNames(alias, names) {
   return projectConfigRepository.importNames(alias, names);
 }
 function computeStateIdAt(root) {
-  const resolved = path18.resolve(root);
+  const resolved = path19.resolve(root);
   return runWithProjectRoot(resolved, () => {
     workspaceFor(resolved).invalidate();
     const system = loadSystemSpec();
@@ -28927,7 +29519,7 @@ function loadConfig() {
 
 // src/core/domain_projector.ts
 function rel(p) {
-  return path19.relative(process.cwd(), p).replace(/\\/g, "/");
+  return path20.relative(process.cwd(), p).replace(/\\/g, "/");
 }
 function deriveSubsystemDomains() {
   const subsystems = loadSubsystemSpecs();
@@ -28968,9 +29560,9 @@ function unregisterDomain(id) {
 }
 
 // src/core/external-producers.ts
-var path20 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 function dirKey2(dir) {
-  const resolved = path20.resolve(dir);
+  const resolved = path21.resolve(dir);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function climb(bound2) {
@@ -28978,7 +29570,7 @@ function climb(bound2) {
   for (; ; ) {
     const parent = runWithProjectRoot(top, () => resolveChainingParent());
     if (!parent) break;
-    top = path20.resolve(parent.parentRoot);
+    top = path21.resolve(parent.parentRoot);
   }
   const reach2 = getRequestParentReach();
   const stoppedAtNarrowedCeiling = !!reach2?.narrowed && reach2.topRoot !== void 0 && dirKey2(top) === dirKey2(reach2.topRoot);
@@ -28988,7 +29580,7 @@ function consumerNode(family, bound2) {
   return family.nodes.find((n) => dirKey2(n.directory) === dirKey2(bound2));
 }
 function resolveDeclared() {
-  const bound2 = path20.resolve(getProjectRoot());
+  const bound2 = path21.resolve(getProjectRoot());
   const { top, whole } = climb(bound2);
   const answer = (root) => runWithProjectRoot(root, () => {
     const family = graph();
@@ -29005,7 +29597,7 @@ function resolveDeclared() {
 
 // src/core/provision.ts
 var fs13 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 function defaultProjectConfig(name, now, id) {
   const declared = id ?? effectiveProjectId({ name });
   return {
@@ -29109,7 +29701,7 @@ function memberDeclarationsAt2(dir) {
 function walkMembers(projectRoot, onMember) {
   const visited = /* @__PURE__ */ new Set();
   const walk2 = (dir) => {
-    const resolved = path21.resolve(dir);
+    const resolved = path22.resolve(dir);
     if (visited.has(resolved)) return;
     visited.add(resolved);
     for (const member of memberDeclarationsAt2(dir)) {
@@ -29160,25 +29752,65 @@ function backfillChainedSubprojectConfigs(projectRoot) {
   });
   return backfilled;
 }
-function createMember(alias, path37, description) {
-  if (!EXTERNAL_ALIAS_RE.test(alias) || typeof path37 !== "string" || path37.trim() === "") {
+var FETCHABLE_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+function scaffoldRequirements(requirements, installed) {
+  const adopted = [];
+  const unadopted = [];
+  const profiles = [];
+  for (const requirement of requirements) {
+    let best = null;
+    for (const pack of installed) {
+      if (pack.name !== requirement.pack || !admits(requirement, pack.version)) continue;
+      if (!best || isNewerVersion(best.version, pack.version)) best = pack;
+    }
+    if (!best) {
+      unadopted.push(requirement);
+      continue;
+    }
+    adopted.push({
+      name: best.name,
+      version: best.version,
+      integrity: best.digest,
+      ...best.origin && FETCHABLE_RE.test(best.origin) ? { source: best.origin } : {}
+    });
+    if (requirement.profile) profiles.push(requirement.profile);
+  }
+  return { adopted, unadopted, ...profiles.length === 1 ? { projectType: profiles[0] } : {} };
+}
+function createMember(alias, path38, description) {
+  if (!EXTERNAL_ALIAS_RE.test(alias) || typeof path38 !== "string" || path38.trim() === "") {
     throw new WaironError(
       `an alias and a path are required to create a member: the alias must fit [a-z0-9-_]+ (got "${alias}") and the path must not be empty.`
     );
   }
-  const relPath = toPosixPath(path37);
+  const relPath = toPosixPath(path38);
   const memberDir = assertContainedProjectPath(getProjectRoot(), relPath);
+  const requirements = requiredPolicies(projectConfigRepository.load() ?? {});
   const parentName = loadSystemSpec()?.name;
   const vision = description ?? `Member ${alias} of ${parentName ? `the ${parentName} project` : "its parent project"}`;
-  runWithProjectRoot(memberDir, () => {
+  const creation = runWithProjectRoot(memberDir, () => {
     ensureDir(aiPathsAt(memberDir).specsDir());
+    if (projectConfigRepository.exists()) {
+      ensureProjectInitialized(alias, alias, vision);
+      return { configCreated: false, adopted: [], unadopted: [] };
+    }
+    const scaffold = scaffoldRequirements(requirements, listInstalledPacks());
+    const name = loadSystemSpec()?.name ?? alias;
+    const config = defaultProjectConfig(name, (/* @__PURE__ */ new Date()).toISOString(), alias);
+    projectConfigRepository.create({
+      ...config,
+      ...scaffold.projectType ? { projectType: scaffold.projectType } : {},
+      ...scaffold.adopted.length > 0 ? { extensions: { packs: scaffold.adopted, useGlobalPacks: false } } : {}
+    });
     ensureProjectInitialized(alias, alias, vision);
+    return { configCreated: true, ...scaffold };
   });
   projectConfigRepository.declareMember(alias, {
     path: relPath,
     ...description !== void 0 ? { description } : {}
   });
   invalidateSpecCache();
+  return creation;
 }
 function moveMember(alias, newPath) {
   const member = graph().nodes.find((n) => n.parent === "" && n.mountAlias === alias);
@@ -29207,7 +29839,7 @@ function moveMember(alias, newPath) {
     if (fs13.existsSync(newDir)) {
       throw new WaironError(`Target directory already exists: ${newDir}`);
     }
-    ensureDir(path21.dirname(newDir));
+    ensureDir(path22.dirname(newDir));
     fs13.renameSync(oldDir, newDir);
   }
   projectConfigRepository.setMemberPath(alias, nextPath);
@@ -29229,9 +29861,9 @@ function toPosixPath(p) {
   return p.replace(/\\/g, "/");
 }
 function isWithinDir2(dir, file) {
-  const d = path21.resolve(dir);
-  const f = path21.resolve(file);
-  return f === d || f.startsWith(d + path21.sep);
+  const d = path22.resolve(dir);
+  const f = path22.resolve(file);
+  return f === d || f.startsWith(d + path22.sep);
 }
 var MOVED_REF_POSITIONS = /* @__PURE__ */ new Set(["component", "interface"]);
 var INTO_MEMBER_POSITIONS = /* @__PURE__ */ new Set([...MOVED_REF_POSITIONS, "type"]);
@@ -29245,13 +29877,13 @@ function externalizeSubsystem(subsystemId, memberPath) {
   }
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
-  const fooDir = path21.join(parentSpecsDir, subsystemId);
+  const fooDir = path22.join(parentSpecsDir, subsystemId);
   if (!fs13.existsSync(fooDir)) {
     throw new WaironError(`subsystem specs directory not found: ${fooDir}`);
   }
   const relPath = toPosixPath(memberPath);
   const memberDir = assertContainedProjectPath(parentRoot, relPath);
-  const memberFooDir = path21.join(aiPathsAt(memberDir).specsDir(), subsystemId);
+  const memberFooDir = path22.join(aiPathsAt(memberDir).specsDir(), subsystemId);
   if (fs13.existsSync(memberFooDir)) {
     throw new WaironError(`target already contains a "${subsystemId}" subsystem: ${memberFooDir}`);
   }
@@ -29275,10 +29907,10 @@ function externalizeSubsystem(subsystemId, memberPath) {
     ensureDir(aiPathsAt(memberDir).specsDir());
     saveSystemSpec(bootstrapSystemSpec(memberName, now));
   });
-  ensureDir(path21.dirname(memberFooDir));
+  ensureDir(path22.dirname(memberFooDir));
   fs13.renameSync(fooDir, memberFooDir);
   rebaseImplementationPaths(memberFooDir, parentRoot, memberDir);
-  patchSubsystemIndex(path21.join(memberFooDir, ".index.yaml"), (s) => {
+  patchSubsystemIndex(path22.join(memberFooDir, ".index.yaml"), (s) => {
     s.parentSystem = memberName;
     delete s.projectPath;
   });
@@ -29376,16 +30008,16 @@ function internalizeMember(alias) {
   }
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
-  const memberDir = assertContainedProjectPath(parentRoot, path21.relative(parentRoot, member.directory) || ".");
+  const memberDir = assertContainedProjectPath(parentRoot, path22.relative(parentRoot, member.directory) || ".");
   const memberSpecsDir = aiPathsAt(memberDir).specsDir();
   const localSub = subsystems[0].id.slice(member.namespace.length + 2);
   const intoMember = crossingReferences(family, "", member.namespace);
   const backOut = crossingReferences(family, member.namespace, "");
   deleteMount(alias);
-  const movedFiles = moveTreeInto(memberSpecsDir, parentSpecsDir, /* @__PURE__ */ new Set([path21.resolve(aiPathsAt(memberDir).specsSystem())]));
+  const movedFiles = moveTreeInto(memberSpecsDir, parentSpecsDir, /* @__PURE__ */ new Set([path22.resolve(aiPathsAt(memberDir).specsSystem())]));
   rebaseImplementationPaths(parentSpecsDir, memberDir, parentRoot, movedFiles);
   const parentSystemName = loadSystemSpec()?.name;
-  patchSubsystemIndex(path21.join(parentSpecsDir, localSub, ".index.yaml"), (s) => {
+  patchSubsystemIndex(path22.join(parentSpecsDir, localSub, ".index.yaml"), (s) => {
     if (parentSystemName) s.parentSystem = parentSystemName;
     delete s.projectPath;
   });
@@ -29393,7 +30025,7 @@ function internalizeMember(alias) {
     ...rewriteRefFields(parentSpecsDir, (ref) => intoMember.get(ref) ?? backOut.get(ref) ?? ref)
   ];
   projectConfigRepository.removeMember(alias);
-  fs13.rmSync(path21.join(memberDir, ".wai"), { recursive: true, force: true });
+  fs13.rmSync(path22.join(memberDir, ".wai"), { recursive: true, force: true });
   invalidateSpecCache();
   for (const spec of rewritten) if (spec.kind !== "system") normalizeReferences(spec.kind, spec.id);
   restateReExports(alias, localSub);
@@ -29477,14 +30109,14 @@ function referencesUnder(dir, matches) {
 }
 function moveTreeInto(src, dst, skip) {
   if (!fs13.existsSync(src)) return [];
-  const files = listFilesRecursive(src, "").filter((f) => !skip.has(path21.resolve(f)));
-  const targets = files.map((f) => path21.join(dst, path21.relative(src, f)));
+  const files = listFilesRecursive(src, "").filter((f) => !skip.has(path22.resolve(f)));
+  const targets = files.map((f) => path22.join(dst, path22.relative(src, f)));
   const taken = targets.filter((t) => fs13.existsSync(t));
   if (taken.length > 0) {
-    throw new WaironError(`cannot internalize: the member's specs would overwrite ${taken.map((t) => path21.relative(dst, t)).join(", ")} in this project.`);
+    throw new WaironError(`cannot internalize: the member's specs would overwrite ${taken.map((t) => path22.relative(dst, t)).join(", ")} in this project.`);
   }
   files.forEach((file, i) => {
-    ensureDir(path21.dirname(targets[i]));
+    ensureDir(path22.dirname(targets[i]));
     fs13.renameSync(file, targets[i]);
   });
   return targets;
@@ -29564,8 +30196,8 @@ function rebaseImplementationPaths(specsDir, fromRoot, toRoot, only) {
     let changed = false;
     const rebase = (holder, key) => {
       const p = holder[key];
-      if (typeof p !== "string" || p === "" || path21.isAbsolute(p)) return;
-      const next = toPosixPath(path21.relative(toRoot, path21.resolve(fromRoot, p)));
+      if (typeof p !== "string" || p === "" || path22.isAbsolute(p)) return;
+      const next = toPosixPath(path22.relative(toRoot, path22.resolve(fromRoot, p)));
       if (next !== p) {
         holder[key] = next;
         changed = true;
@@ -29650,7 +30282,7 @@ function moveRenamedSpecs(componentId, newId, component, movingInterface, moving
   if (movedInterface) saveInterfaceSpec({ ...movedInterface, id: interfaceId, component: newId });
   if (movedImplementation) {
     const oldFile = getImplementationPath(movedImplementation.id);
-    if (path21.resolve(getImplementationPath(implementationId, movedImplementation.contract)) === path21.resolve(oldFile)) {
+    if (path22.resolve(getImplementationPath(implementationId, movedImplementation.contract)) === path22.resolve(oldFile)) {
       fs13.unlinkSync(oldFile);
     }
     saveImplementationSpec({ ...movedImplementation, id: implementationId });
@@ -29668,8 +30300,8 @@ function removeSpecFile2(file, id) {
     return;
   }
   fs13.unlinkSync(file);
-  const specsRoot = path21.resolve(aiPathsAt(getProjectRoot()).specsDir());
-  for (let dir = path21.dirname(path21.resolve(file)); dir !== specsRoot && isWithinDir2(specsRoot, dir); dir = path21.dirname(dir)) {
+  const specsRoot = path22.resolve(aiPathsAt(getProjectRoot()).specsDir());
+  for (let dir = path22.dirname(path22.resolve(file)); dir !== specsRoot && isWithinDir2(specsRoot, dir); dir = path22.dirname(dir)) {
     if (fs13.readdirSync(dir).length > 0) break;
     fs13.rmdirSync(dir);
   }
@@ -29818,7 +30450,7 @@ function normalizeReferences2(kind, id) {
 
 // src/core/detection.ts
 var fs14 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var path23 = __toESM(require("path"));
 var PACKAGE_MARKERS = [
   "package.json",
   "pyproject.toml",
@@ -29891,7 +30523,7 @@ function parseGitmodules(filePath) {
   return entries;
 }
 function detectGitSubmodules(projectRoot) {
-  const gitmodulesPath = path22.join(projectRoot, ".gitmodules");
+  const gitmodulesPath = path23.join(projectRoot, ".gitmodules");
   if (!fs14.existsSync(gitmodulesPath)) return [];
   return parseGitmodules(gitmodulesPath).map((entry) => ({
     suggestedId: pathToId(entry.path),
@@ -29917,10 +30549,10 @@ function walkForGit(projectRoot, currentDir, depth, results) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
-    const fullPath = path22.join(currentDir, entry.name);
-    const relPath = normalizePath(path22.relative(projectRoot, fullPath));
+    const fullPath = path23.join(currentDir, entry.name);
+    const relPath = normalizePath(path23.relative(projectRoot, fullPath));
     if (relPath === "" || relPath === ".") continue;
-    const gitPath = path22.join(fullPath, ".git");
+    const gitPath = path23.join(fullPath, ".git");
     if (fs14.existsSync(gitPath)) {
       results.push({
         suggestedId: pathToId(relPath),
@@ -29950,10 +30582,10 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (SCAN_EXCLUDE_DIRS.has(entry.name)) continue;
-    const fullPath = path22.join(currentDir, entry.name);
-    const relPath = normalizePath(path22.relative(projectRoot, fullPath));
+    const fullPath = path23.join(currentDir, entry.name);
+    const relPath = normalizePath(path23.relative(projectRoot, fullPath));
     if (relPath === "" || relPath === ".") continue;
-    const hasMarker = PACKAGE_MARKERS.some((m) => fs14.existsSync(path22.join(fullPath, m)));
+    const hasMarker = PACKAGE_MARKERS.some((m) => fs14.existsSync(path23.join(fullPath, m)));
     if (hasMarker) {
       results.push({
         suggestedId: pathToId(relPath),
@@ -29967,8 +30599,8 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
   }
 }
 function pathToId(relPath) {
-  const basename10 = path22.basename(relPath);
-  return basename10.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const basename11 = path23.basename(relPath);
+  return basename11.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function pathToName(relPath) {
   const id = pathToId(relPath);
@@ -29981,7 +30613,7 @@ function normalizePath(p) {
 // src/core/variants.ts
 var fs15 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
-var path23 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 var import_zod10 = require("zod");
 var VariantDefSchema = import_zod10.z.object({
   /** Variant id referenced by a component's `variant` (e.g. "publisher", "org/external-config-adapter"). */
@@ -29996,19 +30628,19 @@ var VariantDefSchema = import_zod10.z.object({
   profile: import_zod10.z.string().optional()
 });
 function globalVariantsDir() {
-  return process.env.WAIRON_VARIANTS_DIR ?? path23.join(os3.homedir(), ".wairon", "variants");
+  return process.env.WAIRON_VARIANTS_DIR ?? path24.join(os3.homedir(), ".wairon", "variants");
 }
 function builtinVariantsDir() {
   const candidates = [
-    path23.resolve(__dirname, "..", "templates", "variants"),
+    path24.resolve(__dirname, "..", "templates", "variants"),
     // src/core & dist/cli
-    path23.resolve(__dirname, "templates", "variants")
+    path24.resolve(__dirname, "templates", "variants")
     // dist (library entry)
   ];
   return candidates.find((dir) => fs15.existsSync(dir)) ?? candidates[0];
 }
 function projectVariantsDir() {
-  return path23.join(getProjectRoot(), ".wai", "variants");
+  return path24.join(getProjectRoot(), ".wai", "variants");
 }
 function variantFiles(dir) {
   let entries;
@@ -30017,7 +30649,7 @@ function variantFiles(dir) {
   } catch {
     return [];
   }
-  return entries.filter((e) => e.isFile() && /\.ya?ml$/i.test(e.name)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => path23.join(dir, e.name));
+  return entries.filter((e) => e.isFile() && /\.ya?ml$/i.test(e.name)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => path24.join(dir, e.name));
 }
 function parseVariants(raw) {
   if (raw == null) return [];
@@ -30128,18 +30760,18 @@ function rebasedText(content, fromBase, toBase, rebasedContent) {
 }
 
 // src/core/agent_resolver.ts
-var path25 = __toESM(require("path"));
+var path26 = __toESM(require("path"));
 var fs16 = __toESM(require("fs"));
 
 // src/core/templates.ts
-var path24 = __toESM(require("path"));
+var path25 = __toESM(require("path"));
 function builtinTemplatesDir() {
-  return path24.resolve(__dirname, "..", "templates");
+  return path25.resolve(__dirname, "..", "templates");
 }
 function loadTemplate(id, globalOverride) {
   const dirs = templateSearchDirs(globalOverride);
   for (const dir of dirs) {
-    const filePath = path24.join(dir, `${id}.yaml`);
+    const filePath = path25.join(dir, `${id}.yaml`);
     if (pathExists(filePath)) {
       const raw = readYamlFile(filePath);
       return { ...TemplateSchema.parse(raw), templateName: id };
@@ -30148,7 +30780,7 @@ function loadTemplate(id, globalOverride) {
   throw new TemplateNotFoundError(id);
 }
 function loadAgentOverride(agentId) {
-  const filePath = path24.join(AI_PATHS.root(), "agents", `${agentId}.md`);
+  const filePath = path25.join(AI_PATHS.root(), "agents", `${agentId}.md`);
   return readFileOrNull(filePath);
 }
 function templateSearchDirs(globalOverride) {
@@ -30300,7 +30932,7 @@ function resolveBudget(profile, config, agentId) {
 var projectFilesCache = /* @__PURE__ */ new Map();
 function listFilesRecursiveSafe(dirPath, ext) {
   if (!fs16.existsSync(dirPath)) return [];
-  const nameLower = path25.basename(dirPath).toLowerCase();
+  const nameLower = path26.basename(dirPath).toLowerCase();
   const IGNORED_DIRS = /* @__PURE__ */ new Set([
     "node_modules",
     "target",
@@ -30318,7 +30950,7 @@ function listFilesRecursiveSafe(dirPath, ext) {
   const entries = fs16.readdirSync(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path25.join(dirPath, entry.name);
+    const fullPath = path26.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...listFilesRecursiveSafe(fullPath, ext));
     } else if (entry.isFile() && entry.name.endsWith(ext)) {
@@ -30331,8 +30963,8 @@ function getProjectFiles(projectDir) {
   let files = projectFilesCache.get(projectDir);
   if (!files) {
     files = [];
-    const srcDir = path25.join(projectDir, "src");
-    const legacySrcDir = path25.join(projectDir, "legacy-src");
+    const srcDir = path26.join(projectDir, "src");
+    const legacySrcDir = path26.join(projectDir, "legacy-src");
     let searchDir = projectDir;
     if (pathExists(srcDir)) {
       searchDir = srcDir;
@@ -30347,7 +30979,7 @@ function getProjectFiles(projectDir) {
       files.push(...listFilesRecursiveSafe(searchDir, ext));
     }
     const rootDir = getProjectRoot();
-    files = files.map((f) => path25.relative(rootDir, f).replace(/\\/g, "/"));
+    files = files.map((f) => path26.relative(rootDir, f).replace(/\\/g, "/"));
     projectFilesCache.set(projectDir, files);
   }
   return files;
@@ -30372,8 +31004,8 @@ function inferSourcePathForComponent(comp, subsystems) {
     let bestFile = null;
     let bestScore = -1;
     for (const f of files) {
-      const ext = path25.extname(f);
-      const base = path25.basename(f, ext).toLowerCase();
+      const ext = path26.extname(f);
+      const base = path26.basename(f, ext).toLowerCase();
       if (candidates.has(base)) {
         let score = 0;
         const normalizedPath = f.toLowerCase();
@@ -30428,8 +31060,8 @@ function inferSourcePathForComponent(comp, subsystems) {
     return null;
   }
 }
-function summarize2(text2, max = 140) {
-  const clean = text2.replace(/\s+/g, " ").trim();
+function summarize2(text3, max = 140) {
+  const clean = text3.replace(/\s+/g, " ").trim();
   const period = clean.indexOf(". ");
   const firstSentence = period > 0 ? clean.slice(0, period + 1) : clean;
   if (firstSentence.length <= max) return firstSentence;
@@ -30446,7 +31078,7 @@ function resolveAgentTopology() {
   const members = graph().nodes.filter((n) => n.parent === "" && n.mountAlias !== void 0).map((n) => ({
     id: n.mountAlias,
     name: n.mountAlias,
-    projectPath: path25.relative(getProjectRoot(), n.directory).replace(/\\/g, "/"),
+    projectPath: path26.relative(getProjectRoot(), n.directory).replace(/\\/g, "/"),
     form: n.mountForm,
     createdAt: n.legacyMount?.createdAt ?? system.createdAt,
     updatedAt: n.legacyMount?.updatedAt ?? system.updatedAt
@@ -30481,7 +31113,7 @@ function resolveAgentTopology() {
   });
   for (const sub of subsystems) {
     if (sub.projectPath) {
-      const mountSpecPath = sub.form === "members" ? `${sub.projectPath}/**` : path25.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/");
+      const mountSpecPath = sub.form === "members" ? `${sub.projectPath}/**` : path26.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/");
       agents.push({
         id: `${sub.id}-owner`,
         name: `${sub.name} (member project)`,
@@ -30503,9 +31135,9 @@ function resolveAgentTopology() {
     }
     const subComponents = components.filter((c) => c.subsystem === sub.id);
     const ownedPaths = [];
-    ownedPaths.push(path25.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/"));
+    ownedPaths.push(path26.relative(getProjectRoot(), getSubsystemPath(sub.id)).replace(/\\/g, "/"));
     for (const c of subComponents) {
-      ownedPaths.push(path25.relative(getProjectRoot(), getComponentPath(c.id, sub.id)).replace(/\\/g, "/"));
+      ownedPaths.push(path26.relative(getProjectRoot(), getComponentPath(c.id, sub.id)).replace(/\\/g, "/"));
     }
     if (!config.rules.generateComponentImplementers) {
       for (const comp of subComponents) {
@@ -30581,10 +31213,10 @@ function resolveAgentTopology() {
       }
       const dependencies = comp.dependsOn.map((depId) => `${depId}-implementer`);
       const readPaths = [
-        path25.relative(getProjectRoot(), AI_PATHS.specsSystem()).replace(/\\/g, "/"),
-        path25.relative(getProjectRoot(), getComponentPath(comp.id, comp.subsystem)).replace(/\\/g, "/"),
-        ...compInterfaces.map((i) => path25.relative(getProjectRoot(), getInterfacePath(i.id, comp.id)).replace(/\\/g, "/")),
-        ...compImpls.map((impl) => path25.relative(getProjectRoot(), getImplementationPath(impl.id, impl.contract)).replace(/\\/g, "/"))
+        path26.relative(getProjectRoot(), AI_PATHS.specsSystem()).replace(/\\/g, "/"),
+        path26.relative(getProjectRoot(), getComponentPath(comp.id, comp.subsystem)).replace(/\\/g, "/"),
+        ...compInterfaces.map((i) => path26.relative(getProjectRoot(), getInterfacePath(i.id, comp.id)).replace(/\\/g, "/")),
+        ...compImpls.map((impl) => path26.relative(getProjectRoot(), getImplementationPath(impl.id, impl.contract)).replace(/\\/g, "/"))
       ];
       agents.push({
         id: `${comp.id}-implementer`,
@@ -30690,10 +31322,10 @@ function loadRegistry() {
 }
 
 // src/exporters/generate.ts
-var path29 = __toESM(require("path"));
+var path30 = __toESM(require("path"));
 
 // src/exporters/claude.ts
-var path26 = __toESM(require("path"));
+var path27 = __toESM(require("path"));
 var MODEL_BY_TIER = {
   small: "haiku",
   standard: "sonnet",
@@ -30732,7 +31364,7 @@ var ClaudeExporter = class {
   outputPath(ctx) {
     const { agent, target, projectRoot } = ctx;
     const outputDir = "outputDir" in target ? target.outputDir : ".claude/agents";
-    return path26.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+    return path27.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
   }
   export(ctx) {
     const { agent, renderedInstructions, budget } = ctx;
@@ -30757,7 +31389,7 @@ var ClaudeExporter = class {
 };
 
 // src/exporters/custom.ts
-var path27 = __toESM(require("path"));
+var path28 = __toESM(require("path"));
 var CustomExporter = class {
   constructor() {
     this.targetType = "custom";
@@ -30767,7 +31399,7 @@ var CustomExporter = class {
     if (!("outputDir" in target)) {
       throw new Error("CustomExporter requires target.outputDir");
     }
-    return path27.resolve(projectRoot, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+    return path28.resolve(projectRoot, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
   }
   export(ctx) {
     const { agent, target, renderedInstructions } = ctx;
@@ -30790,7 +31422,7 @@ var CustomExporter = class {
 };
 
 // src/exporters/gemini.ts
-var path28 = __toESM(require("path"));
+var path29 = __toESM(require("path"));
 var GeminiExporter = class {
   constructor() {
     this.targetType = "gemini";
@@ -30798,7 +31430,7 @@ var GeminiExporter = class {
   outputPath(ctx) {
     const { agent, target, projectRoot } = ctx;
     const outputDir = "outputDir" in target ? target.outputDir : ".gemini/agents";
-    return path28.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
+    return path29.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
   }
   export(ctx) {
     const { agent, renderedInstructions } = ctx;
@@ -30895,7 +31527,7 @@ function resolveExpectedOutputPaths(agents, projectConfig, projectRoot = getProj
       const targetConfig = resolveTargetConfig(agentTarget, projectConfig);
       if (!targetConfig) continue;
       const ctx = { agent, projectRoot, target: targetConfig };
-      expected.add(path29.resolve(getExporter(targetConfig).outputPath(ctx)));
+      expected.add(path30.resolve(getExporter(targetConfig).outputPath(ctx)));
     }
   }
   return expected;
@@ -30910,7 +31542,7 @@ function resolveTargetConfig(agentTarget, projectConfig) {
 
 // src/core/treetransfer.ts
 var fs17 = __toESM(require("fs"));
-var path30 = __toESM(require("path"));
+var path31 = __toESM(require("path"));
 var sdkPortal = __toESM(require_dist());
 var STAGING_PREFIX = ".wai-staging-";
 var BACKUP_DIR = ".wai-backups";
@@ -30936,39 +31568,39 @@ function hasAuthoredSpecs(root) {
   if (!pathExists(specsDir)) {
     return false;
   }
-  const systemIndex = path30.resolve(paths.specsSystem());
+  const systemIndex = path31.resolve(paths.specsSystem());
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
-    if (path30.resolve(file) !== systemIndex) {
+    if (path31.resolve(file) !== systemIndex) {
       return true;
     }
   }
   return false;
 }
 function createStagingDir(destDir) {
-  const root = path30.resolve(destDir);
+  const root = path31.resolve(destDir);
   fs17.mkdirSync(root, { recursive: true });
-  const stagingDir = fs17.mkdtempSync(path30.join(root, STAGING_PREFIX));
+  const stagingDir = fs17.mkdtempSync(path31.join(root, STAGING_PREFIX));
   return stagingDir;
 }
 function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
-  const root = path30.resolve(destDir);
-  const backupDir = path30.join(root, BACKUP_DIR, timestampSlug());
+  const root = path31.resolve(destDir);
+  const backupDir = path31.join(root, BACKUP_DIR, timestampSlug());
   let backedUp = false;
   for (const rootRel of roots) {
     const relative12 = rootRel === "." ? "" : rootRel;
-    const stagedSpecDir = path30.join(stagingDir, relative12, ".wai");
+    const stagedSpecDir = path31.join(stagingDir, relative12, ".wai");
     if (!fs17.existsSync(stagedSpecDir)) continue;
-    const liveSpecDir = liveSpecDirFor(path30.join(root, relative12));
+    const liveSpecDir = liveSpecDirFor(path31.join(root, relative12));
     if (backupExisting && liveSpecDir && fs17.existsSync(liveSpecDir)) {
-      const backupTarget = path30.join(backupDir, relative12, path30.basename(liveSpecDir));
-      fs17.mkdirSync(path30.dirname(backupTarget), { recursive: true });
+      const backupTarget = path31.join(backupDir, relative12, path31.basename(liveSpecDir));
+      fs17.mkdirSync(path31.dirname(backupTarget), { recursive: true });
       fs17.renameSync(liveSpecDir, backupTarget);
       backedUp = true;
     } else if (liveSpecDir && fs17.existsSync(liveSpecDir)) {
       fs17.rmSync(liveSpecDir, { recursive: true, force: true });
     }
-    const target = path30.join(root, relative12, ".wai");
-    fs17.mkdirSync(path30.dirname(target), { recursive: true });
+    const target = path31.join(root, relative12, ".wai");
+    fs17.mkdirSync(path31.dirname(target), { recursive: true });
     if (fs17.existsSync(target)) fs17.rmSync(target, { recursive: true, force: true });
     fs17.renameSync(stagedSpecDir, target);
   }
@@ -30993,7 +31625,7 @@ function exportSpecTree(includeDerived, allowPartial) {
   const skipped = inspection.skipped.map(({ mount, projectPath, reason }) => ({ mount, projectPath, reason }));
   const roots = [{ relativePath: ".", waiDir: aiPathsAt(root).root() }];
   for (const rel2 of inspection.roots) {
-    const waiDir = aiPathsAt(path30.resolve(root, rel2)).root();
+    const waiDir = aiPathsAt(path31.resolve(root, rel2)).root();
     if (pathExists(waiDir)) {
       roots.push({ relativePath: rel2, waiDir });
     } else {
@@ -31024,7 +31656,7 @@ function importSpecTree(archive, options) {
   if (!info.compatible) {
     throw new Error("incompatible .waitree archive (format or minimum wairon version)");
   }
-  const destDir = path30.resolve(options.destDir ?? getProjectRoot());
+  const destDir = path31.resolve(options.destDir ?? getProjectRoot());
   const occupied = hasSpecTree(destDir);
   const authored = hasAuthoredSpecs(destDir);
   if (authored && options.replaceExisting !== true) {
@@ -31055,9 +31687,9 @@ function importSpecTree(archive, options) {
   return result;
 }
 function liveSpecDirFor(rootDir) {
-  const modern = path30.join(rootDir, ".wai");
+  const modern = path31.join(rootDir, ".wai");
   if (fs17.existsSync(modern)) return modern;
-  const legacy = path30.join(rootDir, ".wairon");
+  const legacy = path31.join(rootDir, ".wairon");
   if (fs17.existsSync(legacy)) return legacy;
   return null;
 }
@@ -31199,7 +31831,7 @@ function repairForeignStepFields(apply) {
 
 // src/core/approval.ts
 var crypto4 = __toESM(require("crypto"));
-var path31 = __toESM(require("path"));
+var path32 = __toESM(require("path"));
 
 // src/models/lock.ts
 function describeApprover(who) {
@@ -31216,12 +31848,12 @@ function digest(content) {
   return crypto4.createHash("sha256").update(normalized, "utf8").digest("hex");
 }
 function currentSpecDigests(root = getProjectRoot()) {
-  const mountDirs = graph().nodes.filter((n) => n.namespace !== "").map((n) => `${path31.resolve(n.directory).split(path31.sep).join("/")}/`);
+  const mountDirs = graph().nodes.filter((n) => n.namespace !== "").map((n) => `${path32.resolve(n.directory).split(path32.sep).join("/")}/`);
   const out = {};
   for (const [abs, content] of snapshotSpecFiles()) {
-    const normalized = path31.resolve(abs).split(path31.sep).join("/");
+    const normalized = path32.resolve(abs).split(path32.sep).join("/");
     if (mountDirs.some((dir) => normalized.startsWith(dir))) continue;
-    out[path31.relative(root, abs).split(path31.sep).join("/")] = digest(content);
+    out[path32.relative(root, abs).split(path32.sep).join("/")] = digest(content);
   }
   return out;
 }
@@ -31279,7 +31911,7 @@ function currentChildPins(mounts, root = getProjectRoot()) {
   const pins = {};
   for (const mount of mounts) {
     if (!mount.projectPath || mount.id.includes("::")) continue;
-    const child = readLockRecordAt(path31.resolve(root, mount.projectPath));
+    const child = readLockRecordAt(path32.resolve(root, mount.projectPath));
     if (child) pins[mount.id] = pinOf(child.stateId);
   }
   return pins;
@@ -31296,7 +31928,7 @@ function movedChildren(mounts, root = getProjectRoot()) {
   return moved;
 }
 function memberMounts(root = getProjectRoot()) {
-  return graph().nodes.filter((n) => n.parent === "" && n.mountAlias !== void 0).map((n) => ({ id: n.mountAlias, projectPath: path31.relative(root, n.directory).split(path31.sep).join("/") }));
+  return graph().nodes.filter((n) => n.parent === "" && n.mountAlias !== void 0).map((n) => ({ id: n.mountAlias, projectPath: path32.relative(root, n.directory).split(path32.sep).join("/") }));
 }
 function approvalVerdict() {
   const quiet = { text: "", drifted: false };
@@ -31384,7 +32016,7 @@ function localApprover() {
 // src/utils/ai-guide.ts
 var fs18 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var path32 = __toESM(require("path"));
+var path33 = __toESM(require("path"));
 
 // src/core/stamp.ts
 function versionStamp() {
@@ -31444,13 +32076,13 @@ This project uses **wairon**. System specs live under \`.wai/specs/\` (L0 System
 * **Variants**: \`gateway\`, a Portal that authenticates, authorizes, validates or rate-limits before it dispatches. Logic is an Orchestrator, and \`dependencyClass: pure | read\` bounds what it may depend on (unset = a workflow). Specialist and Gateway are retired stereotypes.
 * Use \`owns\` for private member containment (exactly one hop) and \`dependsOn\` for collaborators. Never use generic suffixes like "Manager", "Helper", or "Utils".`;
 function globalGuideFilePath(targetType) {
-  if (targetType === "claude") return path32.join(process.env["CLAUDE_CONFIG_DIR"] || path32.join(os5.homedir(), ".claude"), "CLAUDE.md");
-  if (targetType === "gemini") return path32.join(process.env["GEMINI_CONFIG_DIR"] || path32.join(os5.homedir(), ".gemini"), "GEMINI.md");
+  if (targetType === "claude") return path33.join(process.env["CLAUDE_CONFIG_DIR"] || path33.join(os5.homedir(), ".claude"), "CLAUDE.md");
+  if (targetType === "gemini") return path33.join(process.env["GEMINI_CONFIG_DIR"] || path33.join(os5.homedir(), ".gemini"), "GEMINI.md");
   return null;
 }
 function localGuideFilePath(projectRoot, targetType) {
-  if (targetType === "claude") return path32.join(projectRoot, ".claude", "CLAUDE.md");
-  if (targetType === "gemini" || targetType === "agy") return path32.join(projectRoot, ".gemini", "GEMINI.md");
+  if (targetType === "claude") return path33.join(projectRoot, ".claude", "CLAUDE.md");
+  if (targetType === "gemini" || targetType === "agy") return path33.join(projectRoot, ".gemini", "GEMINI.md");
   return null;
 }
 function injectGuide(filePath, scope) {
@@ -31465,7 +32097,7 @@ ${GUIDE_MARKER_END}
   const existing = fs18.existsSync(filePath) ? fs18.readFileSync(filePath, "utf-8") : "";
   const stripped = stripGuideSection(existing);
   const newContent = stripped.trimEnd() + section;
-  fs18.mkdirSync(path32.dirname(filePath), { recursive: true });
+  fs18.mkdirSync(path33.dirname(filePath), { recursive: true });
   fs18.writeFileSync(filePath, newContent, "utf-8");
 }
 function stripGuideSection(content) {
@@ -31476,7 +32108,7 @@ function stripGuideSection(content) {
 }
 function writeRootGuideDelegator(projectRoot, targetType) {
   if (targetType === "claude") {
-    const filePath = path32.join(projectRoot, "CLAUDE.md");
+    const filePath = path33.join(projectRoot, "CLAUDE.md");
     const content = `@.claude/CLAUDE.md
 
 # Wairon SDD Project
@@ -31491,7 +32123,7 @@ the \`wairon\` CLI is the human developer's tool, not yours.
 `;
     fs18.writeFileSync(filePath, content, "utf-8");
   } else if (targetType === "gemini" || targetType === "agy") {
-    const filePath = path32.join(projectRoot, "GEMINI.md");
+    const filePath = path33.join(projectRoot, "GEMINI.md");
     const content = `# Wairon SDD Project
 ${GUIDE_MARKER_START}
 ${versionStamp()}
@@ -31500,7 +32132,7 @@ ${GUIDE_MARKER_END}
 `;
     fs18.writeFileSync(filePath, content, "utf-8");
   } else if (targetType === "cursor") {
-    const filePath = path32.join(projectRoot, ".cursorrules");
+    const filePath = path33.join(projectRoot, ".cursorrules");
     const content = `# Wairon SDD Project
 
 This project uses the Wairon Spec-Driven Development (SDD) framework.
@@ -31509,8 +32141,8 @@ Refer to the rules in [.cursor/rules/](.cursor/rules/) for full instructions.
 `;
     fs18.writeFileSync(filePath, content, "utf-8");
   } else if (targetType === "copilot") {
-    const filePath = path32.join(projectRoot, ".github", "copilot-instructions.md");
-    fs18.mkdirSync(path32.dirname(filePath), { recursive: true });
+    const filePath = path33.join(projectRoot, ".github", "copilot-instructions.md");
+    fs18.mkdirSync(path33.dirname(filePath), { recursive: true });
     const content = `# Wairon SDD Project
 
 This project uses the Wairon Spec-Driven Development (SDD) framework.
@@ -31519,7 +32151,7 @@ Refer to the prompts in [.github/prompts/](.github/prompts/) for instructions.
 `;
     fs18.writeFileSync(filePath, content, "utf-8");
   } else if (targetType === "codex") {
-    const filePath = path32.join(projectRoot, ".codexrules");
+    const filePath = path33.join(projectRoot, ".codexrules");
     const content = `# Wairon SDD Project
 
 Refer to [.codex/agents/](.codex/agents/) for full instructions.
@@ -31676,14 +32308,14 @@ function syncContextFiles() {
 }
 
 // src/core/status.ts
-var path33 = __toESM(require("path"));
-var asWritten = (text2) => text2;
+var path34 = __toESM(require("path"));
+var asWritten = (text3) => text3;
 function fillDecor(decor) {
   return {
     structure: decor?.structure ?? asWritten,
     emphasis: decor?.emphasis ?? asWritten,
-    layer: decor?.layer ?? ((_kind, text2) => text2),
-    score: decor?.score ?? ((_pct, text2) => text2),
+    layer: decor?.layer ?? ((_kind, text3) => text3),
+    score: decor?.score ?? ((_pct, text3) => text3),
     draft: decor?.draft ?? asWritten,
     present: decor?.present ?? asWritten,
     missing: decor?.missing ?? asWritten
@@ -31765,7 +32397,7 @@ function getStatusReport(options = {}, decor) {
   const sourceExists = (specId, file) => {
     const owner = ownerOf3(specId);
     const dir = owner === "" ? void 0 : family.nodes.find((n) => n.namespace === owner)?.directory;
-    return pathExists(dir ? path33.resolve(dir, file) : fromProjectRoot(file));
+    return pathExists(dir ? path34.resolve(dir, file) : fromProjectRoot(file));
   };
   const holdsShown = (ns) => subsystems.some((s) => ownerOf3(s.id) === ns) || family.nodes.some((n) => n.parent === ns && n.namespace !== ns && holdsShown(n.namespace));
   const renderSubsystem = (sub, label2, indent, isLastSub) => {
@@ -31929,7 +32561,7 @@ var logger = {
 };
 
 // src/core/skills.ts
-var path34 = __toESM(require("path"));
+var path35 = __toESM(require("path"));
 var fs19 = __toESM(require("fs"));
 
 // src/core/instructions.ts
@@ -32085,10 +32717,10 @@ function readFrontmatter(raw, fallbackName) {
   return { name: field("name") || fallbackName, description: field("description") };
 }
 function builtinSkillsDir() {
-  return path34.resolve(__dirname, "..", "templates", "skills");
+  return path35.resolve(__dirname, "..", "templates", "skills");
 }
 function skillTemplatePath(name) {
-  return path34.join(builtinSkillsDir(), `${name}.md`);
+  return path35.join(builtinSkillsDir(), `${name}.md`);
 }
 function activeTargetTypes2() {
   const config = loadProjectConfig();
@@ -32156,7 +32788,7 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod11 = require("zod");
 var import_types4 = require("@modelcontextprotocol/sdk/types.js");
-var path36 = __toESM(require("path"));
+var path37 = __toESM(require("path"));
 var crypto5 = __toESM(require("crypto"));
 
 // src/core/adapters/authoring-core.ts
@@ -32551,7 +33183,7 @@ function moveMethods2(from, to, methods, dryRun) {
 
 // src/mcp/build.ts
 var fs20 = __toESM(require("fs"));
-var path35 = __toESM(require("path"));
+var path36 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
 function captureBuildStamp(entryPath) {
   try {
@@ -32595,21 +33227,21 @@ function readBuildFingerprint(stamp) {
   return printed;
 }
 function fingerprintModuleFor(entryPath) {
-  let dir = path35.dirname(entryPath);
+  let dir = path36.dirname(entryPath);
   for (; ; ) {
-    const manifest = path35.join(dir, "package.json");
+    const manifest = path36.join(dir, "package.json");
     if (fs20.existsSync(manifest)) {
       try {
         const pkg = JSON.parse(fs20.readFileSync(manifest, "utf8"));
-        const inDist = path35.relative(path35.join(dir, "dist"), entryPath);
-        if (pkg.name === "@wairon/cli" && pkg.main && !inDist.startsWith("..") && !path35.isAbsolute(inDist)) {
-          return path35.resolve(dir, pkg.main);
+        const inDist = path36.relative(path36.join(dir, "dist"), entryPath);
+        if (pkg.name === "@wairon/cli" && pkg.main && !inDist.startsWith("..") && !path36.isAbsolute(inDist)) {
+          return path36.resolve(dir, pkg.main);
         }
       } catch {
       }
       return entryPath;
     }
-    const parent = path35.dirname(dir);
+    const parent = path36.dirname(dir);
     if (parent === dir) return entryPath;
     dir = parent;
   }
@@ -32635,7 +33267,7 @@ function statusFamilyContext() {
     const members = listDirectChainedSubprojects(root);
     if (members.length > 0) {
       const described = members.map((m) => {
-        const rel2 = path36.relative(root, m.dir).split(path36.sep).join("/") || ".";
+        const rel2 = path37.relative(root, m.dir).split(path37.sep).join("/") || ".";
         return `${m.alias} (${rel2}${m.form === "mount" ? ", legacy L1 mount" : ""})`;
       });
       lines.push(`Family: member projects declared here \u2014 ${described.join(", ")}.`);
@@ -32660,7 +33292,7 @@ function qualifiedComponentId(id) {
   return chained.length === 1 ? chained[0] : id;
 }
 function publicInterfacesReplacement(subsystem, stored, list) {
-  const identity = (pi) => {
+  const identity2 = (pi) => {
     if (pi.from || pi.typeDef) {
       const item = pi.typeDef ? `type ${pi.typeDef}` : pi.component ?? "*";
       return `${pi.from ? `${pi.from}:` : ""}${item}${pi.interface ? `.${pi.interface}` : ""}${pi.as ? ` as ${pi.as}` : ""}`;
@@ -32668,7 +33300,7 @@ function publicInterfacesReplacement(subsystem, stored, list) {
     return pi.component ? `${pi.component}${pi.interface ? `.${pi.interface}` : ""}` : `${pi.type} ${pi.details}`;
   };
   const restated = /* @__PURE__ */ new Map();
-  for (const pi of list) restated.set(identity(pi), (restated.get(identity(pi)) ?? 0) + 1);
+  for (const pi of list) restated.set(identity2(pi), (restated.get(identity2(pi)) ?? 0) + 1);
   const twice = [...restated].filter(([, n]) => n > 1).map(([key]) => `"${key}"`);
   if (twice.length) {
     return `Refusing to set the public interfaces of subsystem "${subsystem}": the list names ${twice.join(", ")} more than once. An entry is identified by the component and interface it is bound to \u2014 or, not yet bound, by its type and details \u2014 so two entries sharing one are the same entry stated twice. Drop the duplicate. Nothing was written.`;
@@ -32676,24 +33308,24 @@ function publicInterfacesReplacement(subsystem, stored, list) {
   const seen = /* @__PURE__ */ new Map();
   const deletes = [];
   for (const pi of stored) {
-    const key = identity(pi);
+    const key = identity2(pi);
     seen.set(key, (seen.get(key) ?? 0) + 1);
     if (seen.get(key) > (restated.get(key) ?? 0)) {
       deletes.push(pi.from || pi.typeDef ? { from: pi.from, component: pi.component, interface: pi.interface, typeDef: pi.typeDef, as: pi.as, action: "delete" } : pi.component ? { component: pi.component, interface: pi.interface, action: "delete" } : { type: pi.type, details: pi.details, action: "delete" });
     }
   }
   const restatedEntries = list.map((pi) => {
-    const prev = stored.find((s) => identity(s) === identity(pi));
+    const prev = stored.find((s) => identity2(s) === identity2(pi));
     const dropped = prev ? Object.keys(prev).filter((f) => prev[f] !== void 0 && pi[f] === void 0) : [];
     return dropped.length ? { ...pi, unset: dropped } : pi;
   });
   return { publicInterfaces: [...deletes, ...restatedEntries] };
 }
-function text(content) {
+function text2(content) {
   return { content: [{ type: "text", text: content }] };
 }
 function json(value) {
-  return text(JSON.stringify(value, null, 2));
+  return text2(JSON.stringify(value, null, 2));
 }
 function errText(message) {
   return { content: [{ type: "text", text: `Error: ${message.replace(/^(?:\s*Error:\s*)+/, "")}` }], isError: true };
@@ -32869,6 +33501,90 @@ var validationIssueOutput = {
     "In a family run: the key of the project whose gate the finding belongs to ('' for the family root)."
   )
 };
+var memberCreationOutput = {
+  configCreated: import_zod11.z.boolean().describe("Whether this call created the member's configuration; only then were the declaring project's required packs scaffolded."),
+  adopted: import_zod11.z.array(import_zod11.z.object({
+    name: import_zod11.z.string(),
+    version: import_zod11.z.string().optional(),
+    integrity: import_zod11.z.string().optional(),
+    source: import_zod11.z.string().optional(),
+    bundle: import_zod11.z.boolean().optional()
+  })).describe("The selections written into the new member's extensions.packs, each pinned to the highest installed version its requirement admits."),
+  unadopted: import_zod11.z.array(import_zod11.z.object({
+    pack: import_zod11.z.string(),
+    version: import_zod11.z.string(),
+    profile: import_zod11.z.string().optional()
+  })).describe("Requirements no installed version satisfies: nothing was written for them, and the next family run reports each as POLICY_NOT_ADOPTED."),
+  projectType: import_zod11.z.string().optional().describe("The profile written as the new member's projectType, when exactly one adopted requirement names one."),
+  ...staleServerOutput
+};
+function describeMemberPacks(creation) {
+  if (!creation.configCreated) return "";
+  const parts = [];
+  if (creation.adopted.length > 0) {
+    parts.push(` Applied the required pack(s) ${creation.adopted.map((s) => `${s.name}@${s.version}`).join(", ")} to its new configuration (an unattended write: no impact report was shown).`);
+  }
+  if (creation.projectType) parts.push(` Set its projectType to "${creation.projectType}".`);
+  if (creation.unadopted.length > 0) {
+    parts.push(` No installed version satisfies ${creation.unadopted.map((r) => `"${r.pack}" ${r.version}`).join(", ")}: nothing was written for ${creation.unadopted.length === 1 ? "it" : "them"}, and the family run reports POLICY_NOT_ADOPTED until the member selects ${creation.unadopted.length === 1 ? "it" : "them"} (\`wairon pack install <source>\`, then \`wairon pack use <name>@<version> --pin\` at the member's root).`);
+  }
+  return parts.join("");
+}
+var doctrineChangeOutput = import_zod11.z.object({
+  axis: import_zod11.z.enum(["rule", "concept"]),
+  change: import_zod11.z.string().describe("loosened | raised | off | added | depth | inert | redefined | removed | discouraged | licensed | gated \u2014 stated, never judged."),
+  subject: import_zod11.z.string(),
+  profile: import_zod11.z.string().optional(),
+  from: import_zod11.z.string().optional(),
+  to: import_zod11.z.string().optional(),
+  reason: import_zod11.z.string().optional()
+});
+var impactTotalsOutput = import_zod11.z.object({
+  key: import_zod11.z.string(),
+  id: import_zod11.z.string().optional(),
+  directory: import_zod11.z.string(),
+  valid: import_zod11.z.boolean(),
+  errors: import_zod11.z.number(),
+  warnings: import_zod11.z.number(),
+  notices: import_zod11.z.number()
+});
+var packImpactOutput = {
+  pack: import_zod11.z.string().describe("The pack measured."),
+  version: import_zod11.z.string().optional().describe("The version the candidate resolves to; absent for an unversioned pack."),
+  replaces: import_zod11.z.string().optional().describe("The version applied now under the same name, when the selection would replace it."),
+  direction: import_zod11.z.enum(["apply", "remove"]).describe("remove when the pack is already applied exactly as asked: the findings then read as what the pack accounts for now."),
+  doctrine: import_zod11.z.array(doctrineChangeOutput).describe("The pack's changes against wairon's defaults. Nothing in it is a finding."),
+  previousDoctrine: import_zod11.z.array(doctrineChangeOutput).optional().describe("On an update: the replaced version's changes against the same defaults."),
+  governing: import_zod11.z.array(import_zod11.z.string()).describe("The pack's profiles that would govern something in this project."),
+  findings: import_zod11.z.object({
+    introduced: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)),
+    resolved: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)),
+    regraded: import_zod11.z.array(import_zod11.z.object({ finding: import_zod11.z.object(validationIssueOutput), from: import_zod11.z.string() }))
+  }).describe("The owner's-gate findings that differ between the current and the candidate configuration."),
+  before: impactTotalsOutput.describe("The current configuration's totals."),
+  after: impactTotalsOutput.describe("The candidate configuration's totals."),
+  ...staleServerOutput
+};
+function renderPackImpact(impact) {
+  const lines = [];
+  const removal = impact.direction === "remove";
+  lines.push(`Pack impact: ${impact.pack}${impact.version ? ` v${impact.version}` : ""}${impact.replaces ? ` (replaces v${impact.replaces})` : ""} \u2014 ${removal ? "already applied exactly as asked; measured as removed, so the findings are what the pack accounts for now" : "measured as applied"}. Nothing was written.`);
+  lines.push("", "Doctrine against wairon's defaults (stated, never judged):");
+  if (impact.doctrine.length === 0) lines.push("  (no changes)");
+  for (const c of impact.doctrine) {
+    const range = c.from !== void 0 || c.to !== void 0 ? ` (${c.from ?? "-"} -> ${c.to ?? "-"})` : "";
+    lines.push(`  ${c.profile ? `[${c.profile}] ` : ""}${c.axis} ${c.change}: ${c.subject}${range}${c.reason ? ` \u2014 ${c.reason}` : ""}`);
+  }
+  lines.push("", `Governing here: ${impact.governing.length > 0 ? impact.governing.join(", ") : "none of its profiles"}`);
+  const f = impact.findings;
+  lines.push("", `Findings: ${f.introduced.length} introduced, ${f.resolved.length} resolved, ${f.regraded.length} regraded.`);
+  for (const i of f.introduced) lines.push(`  + [${i.severity}] ${i.code}${i.specId ? ` (${i.specId})` : ""}: ${i.message}`);
+  for (const i of f.resolved) lines.push(`  - [${i.severity}] ${i.code}${i.specId ? ` (${i.specId})` : ""}: ${i.message}`);
+  for (const r of f.regraded) lines.push(`  ~ [${r.from} -> ${r.finding.severity}] ${r.finding.code}${r.finding.specId ? ` (${r.finding.specId})` : ""}`);
+  const totals2 = (v) => `${v.errors} error(s), ${v.warnings} warning(s), ${v.notices} notice(s)`;
+  lines.push("", `Before: ${totals2(impact.before)}. After: ${totals2(impact.after)}.`);
+  return lines.join(String.fromCharCode(10));
+}
 var validateTreeOutput = {
   valid: import_zod11.z.boolean().describe("False when the tree holds at least one error; warnings and notices never make it false."),
   errors: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)).describe("Every finding of severity error."),
@@ -33451,22 +34167,53 @@ ${renderChangeReport(report)}`,
     server,
     "sdd_add_member",
     {
-      description: "Create a member of the bound project: scaffold the member project at the path (its project.yaml declaring the alias as its project id, and its L0), each part only when absent, and declare it in the bound project's project.yaml `members` with the description. Nothing is written into the bound project's spec tree: a member is reached only as `alias::name` through its own L0 exports. Idempotent \u2014 the same call again writes nothing; a different member under the alias is refused.",
+      description: "Create a member of the bound project: scaffold the member project at the path (its project.yaml declaring the alias as its project id, and its L0), each part only when absent, and declare it in the bound project's project.yaml `members` with the description. A newly created member configuration also selects the bound project's required packs (composition.requirePolicies), once, each pinned to the highest installed version its range admits; the answer states what was applied and which requirements nothing installed satisfies. Nothing is written into the bound project's spec tree: a member is reached only as `alias::name` through its own L0 exports. Idempotent \u2014 the same call again writes nothing; a different member under the alias is refused.",
       inputSchema: {
         alias: import_zod11.z.string().describe("The member's alias and new project id ([a-z0-9-_]+)"),
         path: import_zod11.z.string().describe("The member's root, relative to the bound project"),
         description: import_zod11.z.string().optional().describe("What the member is to this project; also the vision of a bootstrapped L0")
-      }
+      },
+      outputSchema: memberCreationOutput
     },
     ({ alias, path: memberPath, description }) => {
       try {
-        createMember(alias, memberPath, description);
-        return text(`Added member "${alias}" at ${memberPath} (declared in project.yaml \`members\`). Design it from its own root and export what others consume from its L0; reference it here as ${alias}::<name>.`);
+        const creation = createMember(alias, memberPath, description);
+        return structured(
+          `Added member "${alias}" at ${memberPath} (declared in project.yaml \`members\`).${describeMemberPacks(creation)} Design it from its own root and export what others consume from its L0; reference it here as ${alias}::<name>.`,
+          creation
+        );
       } catch (e) {
         return errText(String(e));
       }
     }
   );
+  if (!options.hostedTools) {
+    reg(
+      server,
+      "sdd_pack_impact",
+      {
+        description: "What selecting (or updating to) an installed pack would change on the bound project, writing nothing \u2014 the pack's doctrine against wairon's defaults (rules loosened, raised, turned off or added; profiles, stereotype fencing, edge licenses, patterns, guarantees and language tables added, redefined or removed), which of its profiles would govern, and the findings that change here. A pack the project already applies exactly as asked is measured as removed, so the findings read as what it accounts for now. Nothing in it is a finding: packs exist to adjust wairon's checks, and a loosening is stated like any other change. Apply a pack with `wairon pack use`.",
+        inputSchema: {
+          pack: import_zod11.z.string().describe("The pack name"),
+          version: import_zod11.z.string().optional().describe("An exact version; omitted, the latest installed")
+        },
+        outputSchema: packImpactOutput
+      },
+      ({ pack, version }) => {
+        try {
+          const config = loadProjectConfig();
+          if (!config) throw new ProjectNotInitializedError();
+          const stored = (config.extensions?.packs ?? []).find((e) => typeof e !== "string" && e.name === pack);
+          const exact = stored !== void 0 && typeof stored !== "string" && (stored.version ?? "") === (version ?? "");
+          const candidate = exact ? { entry: stored, remove: true } : { entry: { name: pack, ...version ? { version } : {} } };
+          const impact = measurePackImpact(candidate);
+          return structured(renderPackImpact(impact), impact);
+        } catch (e) {
+          return errMessage(e);
+        }
+      }
+    );
+  }
   reg(
     server,
     "sdd_move_member",
@@ -33480,7 +34227,7 @@ ${renderChangeReport(report)}`,
     ({ alias, newPath }) => {
       try {
         moveMember(alias, newPath);
-        return text(`Moved member "${alias}" to: ${newPath}`);
+        return text2(`Moved member "${alias}" to: ${newPath}`);
       } catch (e) {
         return errText(String(e));
       }
@@ -33499,7 +34246,7 @@ ${renderChangeReport(report)}`,
     ({ subsystem, path: memberPath }) => {
       try {
         externalizeSubsystem(subsystem, memberPath);
-        return text(`Externalized subsystem "${subsystem}" into the member project at ${memberPath}. Move its source code there, run \`wairon doctor --fix\` for the exports either side now needs, and re-validate.`);
+        return text2(`Externalized subsystem "${subsystem}" into the member project at ${memberPath}. Move its source code there, run \`wairon doctor --fix\` for the exports either side now needs, and re-validate.`);
       } catch (e) {
         return errText(String(e));
       }
@@ -33517,7 +34264,7 @@ ${renderChangeReport(report)}`,
     ({ alias }) => {
       try {
         internalizeMember(alias);
-        return text(`Internalized member "${alias}" into this project (its .wai project removed).`);
+        return text2(`Internalized member "${alias}" into this project (its .wai project removed).`);
       } catch (e) {
         return errText(String(e));
       }
@@ -34044,7 +34791,7 @@ ${renderChangeReport(report)}`,
     ({ kind, id, methods }) => {
       try {
         let result = null;
-        let partial = null;
+        let partial2 = null;
         switch (kind) {
           case "system":
             result = loadSystemSpec();
@@ -34081,7 +34828,7 @@ ${renderChangeReport(report)}`,
             );
           }
           const kept = declared.filter((m) => methods.includes(String(m?.name)));
-          partial = {
+          partial2 = {
             shown: kept.map((m) => String(m?.name)),
             omitted: names.length - kept.length,
             warning: `PARTIAL: ${names.length - kept.length} of this spec's ${names.length} methods are not in this answer. Never re-author from it \u2014 sdd_define_interface and sdd_write_narrative REPLACE the method list, so every method missing here would be removed from the spec.`
@@ -34091,14 +34838,14 @@ ${renderChangeReport(report)}`,
         const guidance = kind === "component" ? resolveComponentVariantGuidance(result) : null;
         const folded = {
           ...result,
-          ...partial ? { partialResult: partial } : {},
+          ...partial2 ? { partialResult: partial2 } : {},
           ...guidance ? { variantGuidance: guidance } : {}
         };
         return structured(JSON.stringify(folded, null, 2), {
           kind,
           id,
           spec: result,
-          ...partial ? { partialResult: partial } : {},
+          ...partial2 ? { partialResult: partial2 } : {},
           ...guidance ? { variantGuidance: guidance } : {}
         });
       } catch (e) {
@@ -34169,7 +34916,7 @@ ${testsBlock}` : ""}`, deletion);
         });
         const family = statusFamilyContext();
         const verdict = approvalVerdict();
-        return text(`${family}${report.text}${verdict.text}`);
+        return text2(`${family}${report.text}${verdict.text}`);
       } catch (e) {
         return errText(String(e));
       }
@@ -34299,6 +35046,13 @@ function advertiseHostedTools(server, options) {
         content: import_zod11.z.string().describe("The declarative pack YAML content")
       }
     }, hostedStub);
+    reg(server, "sdd_host_pack_impact", {
+      description: "Hosted project ops: measure, writing nothing, what installing a DECLARATIVE pack (content given) or adopting the server-global pack of that name (content omitted) would change on the BOUND project \u2014 the pack's doctrine against wairon's defaults (rules loosened, raised, turned off or added; profiles and concepts added, redefined or removed), which of its profiles would govern, and the findings that change. Show it to your human before sdd_host_pack_install, which applies without it. Nothing in it is a finding: packs exist to adjust wairon's checks. Requires project:read over the project.",
+      inputSchema: {
+        name: import_zod11.z.string().describe("Pack name (letters, digits, dot, underscore, hyphen); the server-global pack to adopt when content is omitted"),
+        content: import_zod11.z.string().optional().describe("The declarative pack YAML an install would upload; omitted, the server-global pack an adoption would vendor")
+      }
+    }, hostedStub);
     reg(server, "sdd_host_policy_evaluate", {
       description: "Hosted project ops: evaluate the BOUND project's packs and profile selection against the instance pack policy \u2014 compliance without side effects (requires project:write over it).",
       inputSchema: {}
@@ -34365,6 +35119,7 @@ function loadProjectConfig3() {
   ComplexityRuleConfigSchema,
   ComponentSpecSchema,
   ComponentTypeSchema,
+  CompositionConfigSchema,
   ConfigValidationError,
   ConformanceRuleConfigSchema,
   ConformanceTierSchema,
@@ -34419,6 +35174,7 @@ function loadProjectConfig3() {
   PROJECT_ID_RE,
   PROJECT_KINDS,
   PUBLIC_NAME_RE,
+  PackRequirementSchema,
   PackSelectionSchema,
   ParallelBranchSchema,
   PathsConfigSchema,
@@ -34474,6 +35230,7 @@ function loadProjectConfig3() {
   WaironError,
   activeTargetTypes,
   addDomain,
+  admits,
   aiDir,
   aiDirAt,
   aiPathsAt,
@@ -34596,6 +35353,7 @@ function loadProjectConfig3() {
   loadComponentSpecs,
   loadExtensionPacks,
   loadExtensions,
+  loadExtensionsFor,
   loadImplementationSpec,
   loadImplementationSpecs,
   loadInterfaceSpec,
@@ -34635,7 +35393,9 @@ function loadProjectConfig3() {
   packDirEntry,
   packEntryLabel,
   packEntryRef,
+  packManifest,
   packStoreDir,
+  parseDeclarativePack,
   parseDeclaredCall,
   parseYaml,
   passesIntentFloor,
@@ -34648,6 +35408,7 @@ function loadProjectConfig3() {
   projectIdentity,
   provisionProject,
   qualifiedTypeId,
+  rangeProblem,
   readFileOrNull,
   readJsonFile,
   readLockRecord,
@@ -34664,6 +35425,7 @@ function loadProjectConfig3() {
   renameMethod,
   renderDiagram,
   repairForeignStepFields,
+  requiredPolicies,
   resolveAgentTopology,
   resolveBudget,
   resolveChainingParent,
@@ -34708,6 +35470,7 @@ function loadProjectConfig3() {
   upsertPackSelection,
   validateFamily,
   validateProject,
+  withPack,
   writeFile,
   writeFileIfChanged,
   writeJsonFile,