@event4u/agent-config 16.5.0 → 17.0.0

package/dist/cli-delegate/{chunk-6YQC2HLF.js → chunk-JHMMWNJ2.js}

@@ -1,7 +1,9 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
-  atomicAppendLine
-} from "./chunk-MDPPKQCQ.js";
+  atomicAppendLine,
+  readConsequenceClass,
+  stubLawIds
+} from "./chunk-GOMILC3O.js";
 
 // src/install/txlog.ts
 import { createGzip } from "node:zlib";
@@ -95,8 +97,8 @@ function tryParseEntry(line) {
 
 // src/scripts/_lib/thin_rules.ts
 import { createHash } from "node:crypto";
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/scripts/_lib/rule_law_section.ts
@@ -157,23 +159,6 @@ function lawText(body) {
   return sections.map((s) => s.text).join("\n\n");
 }
 
-// src/scripts/_lib/rule_consequence_class.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-var CLASS_CONFIG_REL = "src/config/rule-consequence-class.json";
-function readConsequenceClass(repoRoot) {
-  const raw = JSON.parse(fs.readFileSync(path.join(repoRoot, CLASS_CONFIG_REL), "utf-8"));
-  return {
-    criterion_ref: raw.criterion_ref ?? "",
-    members: raw.members ?? {},
-    no_stub: raw.no_stub ?? {},
-    excluded: raw.excluded ?? {}
-  };
-}
-function stubLawIds(cfg) {
-  return new Set(Object.keys(cfg.members).filter((id) => cfg.no_stub[id] === void 0));
-}
-
 // src/scripts/_lib/rule_injection.ts
 var PATH_TRIGGER_KINDS = ["path_prefix", "file_pattern"];
 function tierEntries(router, tier) {
@@ -208,22 +193,22 @@ function triggerlessRuleIds(router) {
 
 // src/scripts/_lib/thin_rules.ts
 var _HERE = fileURLToPath(import.meta.url);
-var REPO_ROOT = path2.resolve(path2.dirname(_HERE), "..", "..", "..");
-var RULES_SOURCE = path2.join(REPO_ROOT, "dist/agent-src", "rules");
-var ROUTER = path2.join(REPO_ROOT, "dist", "router.json");
+var REPO_ROOT = path.resolve(path.dirname(_HERE), "..", "..", "..");
+var RULES_SOURCE = path.join(REPO_ROOT, "dist/agent-src", "rules");
+var ROUTER = path.join(REPO_ROOT, "dist", "router.json");
 function _globSortedMd(dir) {
   let names;
   try {
-    names = fs2.readdirSync(dir);
+    names = fs.readdirSync(dir);
   } catch {
     return [];
   }
-  const out = names.filter((n) => n.endsWith(".md")).map((n) => path2.join(dir, n));
+  const out = names.filter((n) => n.endsWith(".md")).map((n) => path.join(dir, n));
   out.sort();
   return out;
 }
 function kernel_ids(routerPath = ROUTER) {
-  const data = JSON.parse(fs2.readFileSync(routerPath, "utf-8"));
+  const data = JSON.parse(fs.readFileSync(routerPath, "utf-8"));
   const kernel = data.kernel;
   if (Array.isArray(kernel)) {
     return new Set(kernel.map((x) => String(x)));
@@ -231,7 +216,7 @@ function kernel_ids(routerPath = ROUTER) {
   return /* @__PURE__ */ new Set();
 }
 function _router(routerPath = ROUTER) {
-  return JSON.parse(fs2.readFileSync(routerPath, "utf-8"));
+  return JSON.parse(fs.readFileSync(routerPath, "utf-8"));
 }
 function path_only_ids(routerPath = ROUTER) {
   return pathOnlyRuleIds(_router(routerPath));
@@ -240,7 +225,7 @@ function no_trigger_ids(routerPath = ROUTER) {
   return new Set(triggerlessRuleIds(_router(routerPath)));
 }
 function rule_workspaces_map(routerPath = ROUTER) {
-  const data = JSON.parse(fs2.readFileSync(routerPath, "utf-8"));
+  const data = JSON.parse(fs.readFileSync(routerPath, "utf-8"));
   const map = /* @__PURE__ */ new Map();
   for (const tier of ["tier_1", "tier_2"]) {
     const entries = data[tier];
@@ -312,7 +297,7 @@ var THIN_BODY_POINTER_RE = (() => {
 })();
 var BODY_LINK_PREFIX = "../../dist/agent-src/rules/";
 function absoluteBodyLinkPrefix(packageRoot) {
-  return `${path2.join(path2.resolve(packageRoot), "dist", "agent-src", "rules")}${path2.sep}`;
+  return `${path.join(path.resolve(packageRoot), "dist", "agent-src", "rules")}${path.sep}`;
 }
 function thin_entry(rule_id, text, bodyLinkPrefix = BODY_LINK_PREFIX) {
   const [fm] = split_frontmatter(text);
@@ -359,7 +344,7 @@ ${STUB_LAW_CLOSE}
 `;
 }
 function build_thin(rules_dir = RULES_SOURCE, scope = null, announce = null, consequenceClass = null, roots = null) {
-  const routerPath = roots?.routerPath ?? (roots?.packageRoot === void 0 ? ROUTER : path2.join(roots.packageRoot, "dist", "router.json"));
+  const routerPath = roots?.routerPath ?? (roots?.packageRoot === void 0 ? ROUTER : path.join(roots.packageRoot, "dist", "router.json"));
   const classRoot = roots?.packageRoot ?? REPO_ROOT;
   const bodyLinkPrefix = roots?.bodyLinkPrefix ?? BODY_LINK_PREFIX;
   const kernel = kernel_ids(routerPath);
@@ -370,39 +355,65 @@ function build_thin(rules_dir = RULES_SOURCE, scope = null, announce = null, con
   const wsMap = scope !== null ? rule_workspaces_map(routerPath) : /* @__PURE__ */ new Map();
   const out = /* @__PURE__ */ new Map();
   for (const p of _globSortedMd(rules_dir)) {
-    const text = fs2.readFileSync(p, "utf-8");
-    const stem = path2.basename(p).replace(/\.md$/, "");
+    const text = fs.readFileSync(p, "utf-8");
+    const stem = path.basename(p).replace(/\.md$/, "");
     if (!id_in_scope(stem, scope, kernel, wsMap, fm_workspaces(text))) {
       continue;
     }
     const noStub = cls.no_stub[stem] !== void 0;
     const full = kernel.has(stem) || noTrigger.has(stem) || pathOnly.has(stem) || noStub;
     if (announce !== null && noTrigger.has(stem) && !kernel.has(stem)) {
-      announce(`D3: trigger-less auto rule ${path2.basename(p)} \u2014 kept full-bodied, never thinned`);
+      announce(`D3: trigger-less auto rule ${path.basename(p)} \u2014 kept full-bodied, never thinned`);
     }
     if (announce !== null && pathOnly.has(stem) && !kernel.has(stem) && !noTrigger.has(stem)) {
       announce(
-        `E2: path-only auto rule ${path2.basename(p)} \u2014 kept full-bodied; its only triggers are path-shaped and the delivery concern is not bound on pre_tool_use`
+        `E2: path-only auto rule ${path.basename(p)} \u2014 kept full-bodied; its only triggers are path-shaped and the delivery concern is not bound on pre_tool_use`
       );
     }
     if (full) {
-      out.set(path2.basename(p), text);
+      out.set(path.basename(p), text);
       continue;
     }
     if (lawInStub.has(stem)) {
       if (announce !== null) {
         announce(
-          `LAW: high-consequence rule ${path2.basename(p)} \u2014 stub carries its own law section, byte-copied`
+          `LAW: high-consequence rule ${path.basename(p)} \u2014 stub carries its own law section, byte-copied`
         );
       }
-      out.set(path2.basename(p), thin_entry_with_law(stem, text, bodyLinkPrefix));
+      out.set(path.basename(p), thin_entry_with_law(stem, text, bodyLinkPrefix));
       continue;
     }
-    out.set(path2.basename(p), thin_entry(stem, text, bodyLinkPrefix));
+    out.set(path.basename(p), thin_entry(stem, text, bodyLinkPrefix));
   }
   return out;
 }
 
+// src/scripts/_lib/model_tier.ts
+import fs2 from "node:fs";
+var TIER_TO_CLAUDE_MODEL = {
+  frontier: "fable",
+  high: "opus",
+  medium: "sonnet",
+  lite: "haiku"
+};
+var MODEL_TIER_RE = /^model_tier:\s*"?([a-z]+)"?\s*$/m;
+function read_model_tier(skill_md) {
+  if (!fs2.existsSync(skill_md)) return null;
+  const text = fs2.readFileSync(skill_md).toString("utf-8");
+  if (!text.startsWith("---\n")) return null;
+  const end = text.indexOf("\n---\n", 4);
+  if (end === -1) return null;
+  const m = MODEL_TIER_RE.exec(text.slice(4, end));
+  return m ? m[1] : null;
+}
+function render_native_model_md(text, tier) {
+  const model = TIER_TO_CLAUDE_MODEL[tier];
+  if (model === void 0) {
+    throw new Error(`'${tier}'`);
+  }
+  return text.replace(MODEL_TIER_RE, `model: ${model}`);
+}
+
 export {
   appendTxLog,
   readRecentEntries,
@@ -411,5 +422,8 @@ export {
   split_frontmatter,
   THIN_ENTRY_MARKER,
   absoluteBodyLinkPrefix,
-  build_thin
+  build_thin,
+  TIER_TO_CLAUDE_MODEL,
+  read_model_tier,
+  render_native_model_md
 };

package/dist/cli-delegate/{chunk-WQWXGIWB.js → chunk-M6CRG5O6.js}

@@ -31,6 +31,36 @@ import * as fs2 from "node:fs";
 import * as os from "node:os";
 import * as path2 from "node:path";
 
+// src/scripts/_lib/egress_prefixes.ts
+var CREDENTIAL_PREFIXES = [
+  "github_pat_",
+  "sk-proj-",
+  "sk_live_",
+  "sk_test_",
+  "sk-ant-",
+  "nvapi-",
+  "ya29.",
+  "pplx-",
+  "xoxb-",
+  "xoxp-",
+  "xoxa-",
+  "xoxr-",
+  "xoxs-",
+  "AKIA",
+  "AIza",
+  "ghp_",
+  "gho_",
+  "ghu_",
+  "ghs_",
+  "ghr_",
+  "xai-",
+  "gsk_",
+  "sk-",
+  "hf_",
+  "r8_"
+];
+var API_KEY_ASSIGNMENT_KEYWORD = "api[_-]?key";
+
 // src/scripts/ai_council/cli_call_budget.ts
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -289,6 +319,125 @@ function parseSeatFields(name, raw) {
     }
   };
 }
+var UNPAID_BILLING_CLASSES = ["free-quota", "self-hosted"];
+
+// src/scripts/ai_council/free_route.ts
+var BILLING_PROOF_KINDS = ["keyless", "free-tier"];
+var UNPROVEN_PROBE = () => ({ weights: "unknown", outbound: null });
+var _ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+function isRealDate(s) {
+  if (typeof s !== "string" || !_ISO_DATE.test(s)) return false;
+  const [y, m, d] = s.split("-").map(Number);
+  const probe = new Date(Date.UTC(y, m - 1, d));
+  return probe.getUTCFullYear() === y && probe.getUTCMonth() + 1 === m && probe.getUTCDate() === d;
+}
+function isLoopbackUrl(raw) {
+  let host;
+  try {
+    host = new URL(raw).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (host === "localhost" || host === "[::1]" || host === "::1") return true;
+  return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host);
+}
+function isRandomRouter(model) {
+  return /^(?:.*\/)?(?:auto|random|free|router)(?::.*)?$/i.test(model.trim());
+}
+function _parseProof(name, raw, keyless) {
+  if (raw === void 0 || raw === null) return null;
+  const where = `members.${name}.billing_proof`;
+  if (typeof raw !== "object" || Array.isArray(raw)) return { error: `${where} must be a mapping with kind, url and checked.` };
+  const p = raw;
+  if (!BILLING_PROOF_KINDS.includes(p["kind"])) {
+    return { error: `${where}.kind must be one of ${BILLING_PROOF_KINDS.join(", ")}.` };
+  }
+  if (typeof p["url"] !== "string" || !/^https:\/\/\S+$/.test(p["url"])) {
+    return { error: `${where}.url must be the https URL documenting the free terms.` };
+  }
+  if (!isRealDate(p["checked"])) {
+    return { error: `${where}.checked must be a quoted 'YYYY-MM-DD' date \u2014 an undated proof proves nothing.` };
+  }
+  if (p["kind"] === "keyless" && !keyless) {
+    return { error: `${where}.kind is 'keyless' but the member carries an api_key_ref.` };
+  }
+  return { kind: p["kind"], url: p["url"], checked: p["checked"] };
+}
+function parseRouteFields(name, raw, knownProvider) {
+  const base = raw["base_url"];
+  if (base === void 0 || base === null) {
+    return raw["billing_proof"] === void 0 ? { route: null } : { error: `members.${name}.billing_proof needs base_url.` };
+  }
+  if (knownProvider) {
+    return { error: `members.${name}: base_url names a route, so the member needs its own name, not a provider's.` };
+  }
+  let url;
+  try {
+    url = new URL(String(base));
+  } catch {
+    return { error: `members.${name}.base_url is not a URL (got ${JSON.stringify(base)}).` };
+  }
+  const loopback = isLoopbackUrl(url.href);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+    return { error: `members.${name}.base_url must use https unless it is a loopback address.` };
+  }
+  const model = raw["model"];
+  if (typeof model === "string" && isRandomRouter(model)) {
+    return { error: `members.${name}.model ${JSON.stringify(model)} is a random/auto router; its identity is unknown before the call.` };
+  }
+  const ref = raw["api_key_ref"];
+  const keyless = ref === void 0 || ref === null || ref === "";
+  const proof = _parseProof(name, raw["billing_proof"], keyless);
+  if (proof !== null && "error" in proof) return proof;
+  return {
+    route: {
+      base_url: String(base).replace(/\/+$/, ""),
+      keyless,
+      proof,
+      loopback,
+      declared_ceiling: classifyContentClass(raw["content_ceiling"])
+    }
+  };
+}
+function _provenLocal(route, probe) {
+  return route.loopback && probe.weights === "local" && probe.outbound === false;
+}
+function routeBilling(route, probe = UNPROVEN_PROBE(route, "")) {
+  if (_provenLocal(route, probe)) return "self-hosted";
+  return route.proof === null ? "per-token" : "free-quota";
+}
+function routeCeiling(route, probe = UNPROVEN_PROBE(route, "")) {
+  return _provenLocal(route, probe) ? route.declared_ceiling : "public-artifact";
+}
+function resolveRouteTransport(opts) {
+  const result = (opts.probe ?? UNPROVEN_PROBE)(opts.route, opts.model);
+  const billing = routeBilling(opts.route, result);
+  const absent = (reason, absentReason) => ({
+    available: false,
+    transport: null,
+    billing,
+    authSource: null,
+    makesProviderCall: false,
+    reason,
+    absentReason
+  });
+  const verdict = admitsContent(routeCeiling(opts.route, result), opts.contentClass ?? DEFAULT_CONTENT_CLASS);
+  if (!verdict.admitted) {
+    return absent(`${opts.name}: ${verdict.reason ?? "content ceiling refused the payload"}`, "policy_content_ceiling");
+  }
+  if (!opts.route.keyless && opts.keyPresent !== true) {
+    return absent(`${opts.name}: the route's api_key_ref does not resolve`, "no_auth");
+  }
+  return {
+    available: true,
+    transport: "api",
+    billing,
+    authSource: opts.route.keyless ? null : "env-key",
+    makesProviderCall: true,
+    reason: null,
+    absentReason: null
+  };
+}
 
 // src/scripts/ai_council/quorum.ts
 var SOLO_FLOOR_MIN_PRESENT = 2;
@@ -485,15 +634,7 @@ var _FALLBACK_DEPS = {
   sortedListRepr: _sortedListRepr,
   error: (msg) => new CouncilConfigError(msg)
 };
-var _RAW_KEY_PREFIXES = [
-  "sk-",
-  "sk-ant-",
-  "ya29.",
-  "AIza",
-  "xai-",
-  "pplx-",
-  "gsk_"
-];
+var _RAW_KEY_PREFIXES = CREDENTIAL_PREFIXES;
 var CouncilConfigError = class extends Error {
   constructor(message) {
     super(message);
@@ -1428,9 +1569,11 @@ function _build_cost_budget(d) {
   return cb;
 }
 function _build_member(name, cfg, default_mode = "auto", ignored = []) {
-  if (!_VALID_PROVIDERS.has(name)) {
+  const routeParsed = parseRouteFields(name, cfg, _VALID_PROVIDERS.has(name));
+  if ("error" in routeParsed) throw new CouncilConfigError(routeParsed.error);
+  if (!_VALID_PROVIDERS.has(name) && routeParsed.route === null) {
     throw new CouncilConfigError(
-      `members.${name}: unknown provider; valid: ${_sortedListRepr(_VALID_PROVIDERS)}.`
+      `members.${name}: unknown provider (or a route without base_url); valid: ${_sortedListRepr(_VALID_PROVIDERS)}.`
     );
   }
   const member_enabled = Boolean(_pyTruthy(_get(cfg, "enabled", false)));
@@ -1567,7 +1710,9 @@ function _build_member(name, cfg, default_mode = "auto", ignored = []) {
     tier,
     prompt_cache_ttl,
     verified_at,
-    ...seat.fields
+    ...seat.fields,
+    route: routeParsed.route,
+    ...routeParsed.route === null ? {} : { content_ceiling: "public-artifact" }
   };
 }
 var DEFAULT_CLI_CALLS_PER_DAY2 = DEFAULT_CLI_CALLS_PER_DAY;
@@ -1754,6 +1899,13 @@ function _pyTruthy(value) {
 }
 
 export {
+  DEFAULT_CONTENT_CLASS,
+  DEFAULT_SEAT_CEILING,
+  admitsContent,
+  parseRouteFields,
+  resolveRouteTransport,
+  policyExclusionReason,
+  UNPAID_BILLING_CLASSES,
   CLI_CALLS_ATTRIBUTION_SUFFIX,
   CLI_CONSUMER_COUNCIL,
   CLI_CONSUMER_TEAM,
@@ -1768,9 +1920,7 @@ export {
   resetAttribution,
   quotaSummaryLine,
   OPENAI_CLI_VENDOR_DEFAULT,
-  DEFAULT_SEAT_CEILING,
-  admitsContent,
-  policyExclusionReason,
+  API_KEY_ASSIGNMENT_KEYWORD,
   _RAW_KEY_PREFIXES,
   COUNCIL_CONFIG_ENV,
   resolve_config_path,

package/dist/cli-delegate/{chunk-PHD7OOLE.js → chunk-MQ2UDEGV.js}

@@ -1,4 +1,9 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  collect_ages,
+  render_age_section,
+  strip_age_section
+} from "./chunk-DSY6LLCQ.js";
 import {
   headerFragment
 } from "./chunk-ULET4BYS.js";
@@ -12,7 +17,7 @@ import {
   evaluateDashboardOnDisk,
   parseModeToken,
   reportCheckVerdict
-} from "./chunk-7XGD2OEU.js";
+} from "./chunk-UXWHY6CQ.js";
 import {
   reportGuardedBaselines
 } from "./chunk-YDQSHTD7.js";
@@ -899,7 +904,13 @@ function main(argv) {
     }
   }
   const roadmaps = collect(roadmap_root), guarded = reportGuardedBaselines(roadmaps, repo_root);
-  const new_text = render(roadmaps, collect_bundles(repo_root), roadmap_root) + guarded.section;
+  const ages = collect_ages(repo_root, roadmaps.map((r) => r.path));
+  const age_rows = roadmaps.map((r) => ({
+    rel: r.rel,
+    frontmatter: FRONTMATTER_RE.exec(fs.readFileSync(r.path, "utf-8"))?.[1] ?? "",
+    age: ages.get(_relPosix(repo_root, r.path))
+  }));
+  const new_text = render(roadmaps, collect_bundles(repo_root), roadmap_root) + render_age_section(age_rows, /* @__PURE__ */ new Date()) + guarded.section;
   const complete = unarchived_complete(roadmaps);
   const pending = pending_iron_law_3(roadmaps);
   const gated = merge_gated_pending(roadmaps);
@@ -918,7 +929,7 @@ function main(argv) {
   if (args.check) {
     const rel = _relPosix(repo_root, target);
     const r = reportCheckVerdict({
-      verdict: evaluateDashboardOnDisk({ mode: args.mode, target, repo_root, rendered: new_text, rel }),
+      verdict: evaluateDashboardOnDisk({ mode: args.mode, target, repo_root, rendered: new_text, rel, normalize: strip_age_section }),
       complete,
       pending,
       dashboardOnly: args.dashboard_only,

package/dist/cli-delegate/chunk-NTM7G2V4.js

@@ -0,0 +1,220 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/skill_catalogue.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var PROJECT_CATALOGUE_ROOTS = ["src/skills", ".claude/skills"];
+var HOST_CATALOGUE_ROOT = ".claude/skills";
+var DEFAULT_CATALOGUE_ROOTS = [
+  ...PROJECT_CATALOGUE_ROOTS,
+  `~/${HOST_CATALOGUE_ROOT}`
+];
+var PACKAGE_FALLBACK_CATALOGUE_ROOT = path.join("dist", "agent-src", "skills");
+function resolveSkillCatalogueRoots(workspaceRoot, home, opts = {}) {
+  const userHome = home ?? process.env["HOME"] ?? os.homedir();
+  const candidates = [
+    ...PROJECT_CATALOGUE_ROOTS.map((c) => path.join(workspaceRoot, c)),
+    path.join(userHome, HOST_CATALOGUE_ROOT)
+  ];
+  const roots = [];
+  const seen = /* @__PURE__ */ new Set();
+  const readable = (abs) => {
+    try {
+      if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) return false;
+      return fs.readdirSync(abs).length > 0;
+    } catch {
+      return false;
+    }
+  };
+  for (const abs of candidates) {
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    if (readable(abs)) roots.push(abs);
+  }
+  if (roots.length === 0 && opts.packageFallback) {
+    const abs = path.join(opts.packageFallback, PACKAGE_FALLBACK_CATALOGUE_ROOT);
+    if (!seen.has(abs) && readable(abs)) roots.push(abs);
+  }
+  return roots;
+}
+var OBSERVATION_LOG = path.join(
+  "agents",
+  "evidence",
+  "metrics",
+  "skill-catalogue.jsonl"
+);
+function frontmatterOf(content) {
+  if (!content.startsWith("---")) return "";
+  const end = content.indexOf("\n---", 3);
+  if (end === -1) return "";
+  return content.slice(3, end);
+}
+function topLevelKeys(frontmatter) {
+  const keys = [];
+  for (const line of frontmatter.split("\n")) {
+    const match = /^([A-Za-z_][A-Za-z0-9_-]*):/.exec(line);
+    if (match) keys.push(match[1]);
+  }
+  return keys;
+}
+function descriptionOf(frontmatter) {
+  const lines = frontmatter.split("\n");
+  for (let i = 0; i < lines.length; i += 1) {
+    const match = /^description:\s*(.*)$/.exec(lines[i]);
+    if (!match) continue;
+    const rest = match[1].trim();
+    if (/^[|>][-+]?\d*$/.test(rest)) {
+      const body = [];
+      for (let j = i + 1; j < lines.length; j += 1) {
+        const line = lines[j];
+        if (line.trim() === "") {
+          body.push("");
+          continue;
+        }
+        if (!/^\s/.test(line)) break;
+        body.push(line.trim());
+      }
+      return body.join(" ").trim();
+    }
+    return rest.replace(/^["']|["']$/g, "");
+  }
+  return "";
+}
+function readProjectedCatalogue(root) {
+  const names = fs.readdirSync(root).filter((n) => fs.existsSync(path.join(root, n, "SKILL.md"))).sort();
+  return names.map((name, index) => {
+    const content = fs.readFileSync(path.join(root, name, "SKILL.md"), "utf-8");
+    const frontmatter = frontmatterOf(content);
+    const description = descriptionOf(frontmatter);
+    return {
+      name,
+      position: index + 1,
+      hasDescription: description.length > 0,
+      descriptionLength: description.length,
+      description,
+      frontmatterKeys: topLevelKeys(frontmatter)
+    };
+  });
+}
+function truncationModeOf(record) {
+  return record.truncation_mode ?? "per-entry";
+}
+function markdownFilesUnder(root) {
+  if (!fs.existsSync(root)) return [];
+  const out = [];
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (fs.statSync(full).isDirectory()) walk(full);
+      else if (entry.name.endsWith(".md")) out.push(full);
+    }
+  };
+  walk(root);
+  return out;
+}
+function measureCatalogueVolume(host, root) {
+  const skillsRoot = path.join(root, "skills");
+  const skills = fs.existsSync(skillsRoot) ? readProjectedCatalogue(skillsRoot) : [];
+  const commandEntries = markdownFilesUnder(path.join(root, "commands")).length;
+  return {
+    host,
+    root,
+    skillEntries: skills.length,
+    commandEntries,
+    artefacts: skills.length + commandEntries,
+    descriptionBytes: skills.reduce((sum, e) => sum + Buffer.byteLength(e.description), 0)
+  };
+}
+function _supersedes(candidate, incumbent) {
+  if (candidate.observed_at !== incumbent.observed_at) {
+    return candidate.observed_at > incumbent.observed_at;
+  }
+  return (candidate.dropped_count ?? 0) > (incumbent.dropped_count ?? 0);
+}
+function knownHostLimits(records) {
+  const out = /* @__PURE__ */ new Map();
+  const chosen = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (truncationModeOf(record) !== "budget-strip-and-drop") continue;
+    if (typeof record.dropped_count !== "number") continue;
+    if (record.dropped_count <= 0) continue;
+    const previous = chosen.get(record.host);
+    if (previous !== void 0 && !_supersedes(record, previous)) continue;
+    chosen.set(record.host, record);
+    out.set(record.host, {
+      host: record.host,
+      droppedEntries: record.dropped_count,
+      projectedVolume: record.entries_total,
+      projectedSkills: record.projected_skill_count ?? null,
+      observedAt: record.observed_at
+    });
+  }
+  return out;
+}
+function catalogueLimitWarning(volume, limit) {
+  if (limit === void 0) return null;
+  if (limit.projectedSkills === null) return null;
+  if (volume.skillEntries < limit.projectedSkills) return null;
+  return `${volume.host}: deploying ${volume.skillEntries} skills. This host reported dropping ${limit.droppedEntries} entries from the model-visible list when last measured (${limit.observedAt}, at ${limit.projectedSkills} skills) \u2014 that much never reaches the model. Explain: \`agent-config exec capture_skill_catalogue --limits\``;
+}
+function migrationEligibility(host, resolvedMode, currentSkillCount, limits) {
+  if (resolvedMode === "scoped") return { eligible: false, reason: "already-scoped" };
+  const limit = limits.get(host);
+  if (limit === void 0) return { eligible: false, reason: "no-observation-for-host" };
+  if (limit.projectedSkills === null) return { eligible: false, reason: "observation-not-comparable" };
+  if (limit.droppedEntries <= 0) return { eligible: false, reason: "no-truncation-observed" };
+  if (currentSkillCount < limit.projectedSkills) {
+    return { eligible: false, reason: "below-observed-skill-volume" };
+  }
+  return {
+    eligible: true,
+    reason: "eligible",
+    droppedEntries: limit.droppedEntries,
+    observedAt: limit.observedAt
+  };
+}
+function migrationPromptLines(host, eligibility, settingsPath) {
+  return [
+    `${host}: ${eligibility.droppedEntries} catalogue entries never reach the model.`,
+    `Measured on this machine (${eligibility.observedAt}). This install is on \`legacy-all\`,`,
+    "which ships everything and lets the host drop what does not fit \u2014 silently.",
+    "",
+    "Scoping the projection to your active packs is the alternative. Nothing here",
+    "changes it for you: `projection.mode` is yours to set, by hand or in the GUI.",
+    "",
+    `  edit  ${settingsPath}`,
+    "        projection:",
+    "          mode: scoped",
+    "",
+    "  or    agent-config config      (Settings \u2192 projection)",
+    "",
+    "Keeping `legacy-all` is a legitimate choice \u2014 this is a notification, not a gate."
+  ];
+}
+function readObservationLog(logPath) {
+  if (!fs.existsSync(logPath)) return [];
+  const out = [];
+  for (const line of fs.readFileSync(logPath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+
+export {
+  DEFAULT_CATALOGUE_ROOTS,
+  resolveSkillCatalogueRoots,
+  OBSERVATION_LOG,
+  measureCatalogueVolume,
+  knownHostLimits,
+  catalogueLimitWarning,
+  migrationEligibility,
+  migrationPromptLines,
+  readObservationLog
+};