@event4u/agent-config 16.5.0 → 17.0.0

package/dist/cli-delegate/{chunk-DMSZHXZS.js → chunk-7DRWULEQ.js}

@@ -111,6 +111,20 @@ var SCOPED_ACTIVE_WORKSPACES = /* @__PURE__ */ new Set([
   "engineering",
   "agent-config-maintainer"
 ]);
+var MAINTAINER_WORKSPACE = "agent-config-maintainer";
+function consumerRuleWorkspaces(packageRoot) {
+  const ids = /* @__PURE__ */ new Set();
+  let records;
+  try {
+    records = load_packs_registry(packageRoot);
+  } catch {
+    return [];
+  }
+  for (const rec of records) {
+    for (const ws of rec.workspaces) if (ws !== MAINTAINER_WORKSPACE) ids.add(ws);
+  }
+  return [...ids].sort();
+}
 function isPlainObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -176,7 +190,10 @@ function compute_active_pack_ids(packs, runtime_active_packs) {
   }
   return active;
 }
-function is_pruned_under_scoped(md_path, active_ids) {
+function is_pruned_under_scoped(md_path, active_ids, kept = /* @__PURE__ */ new Set()) {
+  if (path2.basename(md_path) === "SKILL.md" && kept.has(path2.basename(path2.dirname(md_path)))) {
+    return false;
+  }
   const packs = frontmatter_packs(md_path);
   if (packs.size === 0) return false;
   for (const id of packs) {
@@ -184,6 +201,46 @@ function is_pruned_under_scoped(md_path, active_ids) {
   }
   return true;
 }
+function declared_skills(md_path) {
+  let text;
+  try {
+    text = fs2.readFileSync(md_path, "utf-8");
+  } catch {
+    return [];
+  }
+  if (!text.startsWith("---")) return [];
+  const end = text.indexOf("\n---", 3);
+  const fm = yamlSafeLoad(end !== -1 ? text.slice(3, end) : text.slice(3));
+  if (!isPlainObject(fm)) return [];
+  const out = [];
+  for (const key of ["skills", "requires_skills"]) {
+    const v = fm[key];
+    if (Array.isArray(v)) out.push(...v.filter((s) => typeof s === "string"));
+  }
+  return out;
+}
+function declared_skill_closure(artefacts, active_ids) {
+  const all = [...artefacts];
+  const skill_md = /* @__PURE__ */ new Map();
+  for (const p of all) {
+    if (path2.basename(p) === "SKILL.md") skill_md.set(path2.basename(path2.dirname(p)), p);
+  }
+  const kept = /* @__PURE__ */ new Set();
+  let frontier = all.filter((p) => !is_pruned_under_scoped(p, active_ids));
+  while (frontier.length > 0) {
+    const next = [];
+    for (const p of frontier) {
+      for (const name of declared_skills(p)) {
+        if (kept.has(name)) continue;
+        kept.add(name);
+        const target = skill_md.get(name);
+        if (target !== void 0 && is_pruned_under_scoped(target, active_ids)) next.push(target);
+      }
+    }
+    frontier = next;
+  }
+  return kept;
+}
 var RULE_PACKS_AUTO = "auto";
 function resolve_rule_pack_scope(raw, package_root, runtime_active_packs = []) {
   const is_auto = raw === RULE_PACKS_AUTO || Array.isArray(raw) && raw.length === 1 && raw[0] === RULE_PACKS_AUTO;
@@ -253,6 +310,11 @@ function prune_modules_by(deploy_results, is_pruned) {
   }
   return [pruned, adjusted];
 }
+function prune_scoped_modules(deploy_results, active_ids) {
+  const artefacts = Object.values(deploy_results).flatMap(([, , , paths]) => paths).filter((p) => path2.basename(p) === "SKILL.md" || p.split(path2.sep).includes("commands") && path2.extname(p) === ".md");
+  const kept = declared_skill_closure(artefacts, active_ids);
+  return prune_modules_by(deploy_results, (p) => is_pruned_under_scoped(p, active_ids, kept));
+}
 function prune_lab_modules(deploy_results, lab_ids) {
   return prune_modules_by(deploy_results, (p) => is_lab_artefact(p, lab_ids));
 }
@@ -324,9 +386,10 @@ function _list(value) {
   return null;
 }
 function ruleScopeFromSettings(settings, packageRoot) {
+  const derivedWorkspaces = packageRoot === void 0 ? null : consumerRuleWorkspaces(packageRoot);
   const proj = settings["projection"];
   if (typeof proj !== "object" || proj === null || Array.isArray(proj)) {
-    return LEGACY_ALL;
+    return { ...LEGACY_ALL, workspaces: derivedWorkspaces };
   }
   const p = proj;
   const packs = packageRoot === void 0 ? _list(p["rule_packs"]) : resolve_rule_pack_scope(
@@ -335,7 +398,18 @@ function ruleScopeFromSettings(settings, packageRoot) {
     _list(_runtimeActivePacks(settings)) ?? []
   );
   return {
-    workspaces: _list(p["rule_workspaces"]),
+    // DERIVED since ADR-293 step 4.6, not read. `projection.rule_workspaces`
+    // carried this list as a settings default — the nine consumer workspace
+    // ids, re-typed into the template and needing a re-type whenever a pack
+    // arrived with a new one. What it encoded is a RULE: maintainer-only
+    // rules never project to a consumer. `consumerRuleWorkspaces` derives
+    // exactly that from the pack vocabulary, and the derived set equals the
+    // old default (asserted in `consumer_rule_workspaces.test.ts`).
+    // Without a package root there is no vocabulary to read, so the axis is
+    // INACTIVE rather than empty — the same degradation `rule_packs` makes
+    // above, and the same reason: a package that cannot read its own pack
+    // list must ship more than it should, never less.
+    workspaces: derivedWorkspaces,
     packs,
     roles: _list(p["rule_roles"])
   };
@@ -348,8 +422,8 @@ function ruleFileArrives(sourcePath, scope) {
   if (!sourcePath.endsWith(".md")) {
     return true;
   }
-  const basename2 = path3.basename(sourcePath);
-  if (COMPAT_ALWAYS_EXCLUDED.includes(basename2)) {
+  const basename3 = path3.basename(sourcePath);
+  if (COMPAT_ALWAYS_EXCLUDED.includes(basename3)) {
     return false;
   }
   return rule_in_scope(sourcePath, scope.workspaces, scope.packs, scope.roles ?? null);
@@ -385,8 +459,7 @@ export {
   load_lab_pack_ids,
   load_packs_registry,
   compute_active_pack_ids,
-  is_pruned_under_scoped,
-  prune_modules_by,
+  prune_scoped_modules,
   prune_lab_modules,
   parseFrontmatter,
   LEGACY_ALL,

package/dist/cli-delegate/chunk-7NXCZSDL.js

@@ -0,0 +1,54 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  _classify
+} from "./chunk-IDAOTDPE.js";
+
+// src/scripts/_lib/retrieval_sanitize.ts
+var MAX_FIELD_CHARS = 8192;
+var _INVISIBLE_FILLERS = /* @__PURE__ */ new Set([
+  12644,
+  // HANGUL FILLER
+  4447,
+  // HANGUL CHOSEONG FILLER
+  4448
+  // HANGUL JUNGSEONG FILLER
+]);
+function _isStrippableControl(cp) {
+  if (cp === 9 || cp === 10) return false;
+  if (cp <= 31) return true;
+  if (cp === 127) return true;
+  if (cp >= 128 && cp <= 159) return true;
+  return false;
+}
+function sanitize_text(s) {
+  let out = "";
+  for (const ch of s) {
+    const cp = ch.codePointAt(0);
+    if (cp === void 0) continue;
+    if (_classify(cp) !== null) continue;
+    if (_isStrippableControl(cp)) continue;
+    if (_INVISIBLE_FILLERS.has(cp)) continue;
+    out += ch;
+  }
+  return out.length > MAX_FIELD_CHARS ? out.slice(0, MAX_FIELD_CHARS) : out;
+}
+function sanitize_entry(entry) {
+  const out = {};
+  for (const [k, v] of Object.entries(entry)) {
+    out[k] = _sanitize_value(v);
+  }
+  return out;
+}
+function _sanitize_value(v) {
+  if (typeof v === "string") return sanitize_text(v);
+  if (Array.isArray(v)) return v.map((x) => typeof x === "string" ? sanitize_text(x) : _sanitize_value(x));
+  if (v && typeof v === "object" && v.constructor === Object) {
+    return sanitize_entry(v);
+  }
+  return v;
+}
+
+export {
+  sanitize_text,
+  sanitize_entry
+};

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

@@ -0,0 +1,328 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/shared/skillRanking.ts
+var TOKEN_RE = /[\p{L}][\p{L}\p{N}]+/gu;
+var ENGLISH_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "of",
+  "for",
+  "with",
+  "to",
+  "in",
+  "on",
+  "at",
+  "by",
+  "from",
+  "as",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "use",
+  "when",
+  "even",
+  "via",
+  "via:",
+  "into",
+  "onto",
+  "use:",
+  "skill",
+  "skills",
+  "task",
+  "tasks",
+  "code",
+  "file",
+  "files",
+  "doing",
+  "make",
+  "do",
+  "go",
+  "get",
+  "set",
+  "not",
+  "no",
+  "yes",
+  "any",
+  "some",
+  "all",
+  "one",
+  "two",
+  "new",
+  "old",
+  "user",
+  "users",
+  "our",
+  "your",
+  "their",
+  "they",
+  "we",
+  "you",
+  "i",
+  "me"
+]);
+var GERMAN_STOPWORDS = /* @__PURE__ */ new Set([
+  "der",
+  "die",
+  "das",
+  "den",
+  "dem",
+  "ein",
+  "eine",
+  "einen",
+  "einem",
+  "einer",
+  "eines",
+  "und",
+  "oder",
+  "aber",
+  "sondern",
+  "denn",
+  "also",
+  "f\xFCr",
+  "von",
+  "vom",
+  "zum",
+  "zur",
+  "auf",
+  "aus",
+  "bei",
+  "beim",
+  "nach",
+  "\xFCber",
+  "unter",
+  "durch",
+  "ohne",
+  "gegen",
+  "zwischen",
+  "vor",
+  "ist",
+  "sind",
+  "waren",
+  "bist",
+  "sein",
+  "seine",
+  "seiner",
+  "wird",
+  "werden",
+  "wurde",
+  "wurden",
+  "worden",
+  "hat",
+  "habe",
+  "haben",
+  "hatte",
+  "hatten",
+  "kann",
+  "kannst",
+  "k\xF6nnen",
+  "k\xF6nnte",
+  "soll",
+  "sollte",
+  "sollen",
+  "muss",
+  "m\xFCssen",
+  "darf",
+  "d\xFCrfen",
+  "will",
+  "wollen",
+  "m\xF6chte",
+  "wie",
+  "was",
+  "wer",
+  "wen",
+  "wem",
+  "wann",
+  "warum",
+  "wieso",
+  "weshalb",
+  "wenn",
+  "dass",
+  "weil",
+  "damit",
+  "ob",
+  "dies",
+  "diese",
+  "dieser",
+  "dieses",
+  "diesem",
+  "diesen",
+  "nicht",
+  "kein",
+  "keine",
+  "keinen",
+  "keiner",
+  "nichts",
+  "alle",
+  "allen",
+  "alles",
+  "auch",
+  "noch",
+  "nur",
+  "schon",
+  "sehr",
+  "mehr",
+  "hier",
+  "dort",
+  "jetzt",
+  "dann",
+  "immer",
+  "wieder",
+  "ich",
+  "mir",
+  "mich",
+  "dich",
+  "sie",
+  "ihr",
+  "ihre",
+  "ihren",
+  "wir",
+  "uns",
+  "euch",
+  "ihm",
+  "ihn",
+  "mein",
+  "meine",
+  "dein",
+  "bitte",
+  "mal",
+  "etwas",
+  "eigentlich",
+  "einfach",
+  // The counterparts of the English block's generic verbs. `mach` survives
+  // the three-code-point floor, so it is listed; `tu` does not and is not.
+  "mach",
+  "machen",
+  "macht",
+  "nutze",
+  "nutzen",
+  "verwende",
+  "verwenden",
+  "bekomme",
+  "bekommen",
+  "setze",
+  "setzen"
+]);
+var STOPWORDS = /* @__PURE__ */ new Set([
+  ...ENGLISH_STOPWORDS,
+  ...GERMAN_STOPWORDS
+]);
+function pyLen(s) {
+  let n = 0;
+  for (const _ of s) n++;
+  return n;
+}
+function roundHalfToEven(x) {
+  if (!Number.isFinite(x)) return x;
+  const floor = Math.floor(x);
+  const frac = x - floor;
+  if (frac < 0.5) return floor;
+  if (frac > 0.5) return floor + 1;
+  return floor % 2 === 0 ? floor : floor + 1;
+}
+function tokenize(text) {
+  const out = /* @__PURE__ */ new Set();
+  const matches = text.toLowerCase().match(TOKEN_RE) ?? [];
+  for (const t of matches) {
+    if (!STOPWORDS.has(t) && pyLen(t) > 2) out.add(t);
+  }
+  return out;
+}
+var INDEXED_TRIGGER_KEYS = ["keyword", "phrase"];
+function triggerTextFromFlatLines(lines) {
+  const out = [];
+  for (const line of lines) {
+    const m = /^([a-zA-Z_][\w-]*)\s*:\s*(.*)$/.exec(String(line).trim());
+    if (!m) continue;
+    if (!INDEXED_TRIGGER_KEYS.includes(m[1])) continue;
+    const value = m[2].trim().replace(/^["']|["']$/g, "");
+    if (value) out.push(value);
+  }
+  return out;
+}
+var DEFAULT_SUGGEST_LIMIT = 8;
+function skillTerms(skill, opts = {}) {
+  const parts = [skill.name, skill.description];
+  if (opts.includeTriggers && skill.triggerText) parts.push(...skill.triggerText);
+  if (opts.includeWhenToUse && skill.whenToUseText) parts.push(skill.whenToUseText);
+  if (opts.includeHeadings && skill.headingText) parts.push(...skill.headingText);
+  return tokenize(parts.join(" "));
+}
+function widensTermSource(opts) {
+  return Boolean(opts.includeTriggers || opts.includeWhenToUse || opts.includeHeadings);
+}
+function buildTermStats(skills, termSets) {
+  const df = /* @__PURE__ */ new Map();
+  for (const terms of termSets) {
+    for (const t of terms) df.set(t, (df.get(t) ?? 0) + 1);
+  }
+  return { df, skills: skills.length };
+}
+function idf(term, stats) {
+  return Math.log(1 + stats.skills / (1 + (stats.df.get(term) ?? 0)));
+}
+function rawSkillScore(taskTerms, skill, terms, opts = {}, stats) {
+  if (opts.idfWeighting && !stats) {
+    throw new Error(
+      "scoreSkill: idfWeighting is set but no TermStats was passed \u2014 scoring unweighted here would publish a baseline number under the idf label. Build stats with buildTermStats."
+    );
+  }
+  if (taskTerms.size === 0) return 0;
+  let overlap;
+  if (opts.idfWeighting && stats) {
+    let hit = 0;
+    let total = 0;
+    for (const t of taskTerms) {
+      const w = idf(t, stats);
+      total += w;
+      if (terms.has(t)) hit += w;
+    }
+    overlap = total > 0 ? hit / total : 0;
+  } else {
+    let inter = 0;
+    for (const t of taskTerms) if (terms.has(t)) inter++;
+    overlap = inter / Math.max(taskTerms.size, 1);
+  }
+  let personaHit = 0;
+  const taskLower = [...taskTerms].join(" ");
+  for (const persona of skill.personas ?? []) {
+    const slug = String(persona).toLowerCase();
+    if (taskLower.includes(slug) || slug.split("-").some((part) => taskTerms.has(part))) {
+      personaHit = 1;
+      break;
+    }
+  }
+  return overlap * 70 + personaHit * 30;
+}
+function compareRanked(aName, aScore, bName, bScore, opts, raw) {
+  if (bScore !== aScore) return bScore - aScore;
+  if (opts.tieBreakUnrounded) {
+    const d = (raw.get(bName) ?? 0) - (raw.get(aName) ?? 0);
+    if (d !== 0) return d;
+  }
+  return aName < bName ? -1 : aName > bName ? 1 : 0;
+}
+
+export {
+  roundHalfToEven,
+  tokenize,
+  triggerTextFromFlatLines,
+  DEFAULT_SUGGEST_LIMIT,
+  skillTerms,
+  widensTermSource,
+  buildTermStats,
+  rawSkillScore,
+  compareRanked
+};

package/dist/cli-delegate/{chunk-WOKWX5PL.js → chunk-BKALSTBZ.js}

@@ -2,7 +2,7 @@ import { createRequire as __acCreateRequire } from 'node:module'; const require
 import {
   LEGACY_ALL,
   ruleFileArrives
-} from "./chunk-DMSZHXZS.js";
+} from "./chunk-7DRWULEQ.js";
 
 // src/install/wizard-plan.ts
 import { homedir } from "node:os";
@@ -41,7 +41,7 @@ var CLAUDE_SKILL_BUNDLE = [
   // subdirs route as `/<cluster>:<sub>`. Council session 2026-05-28
   // converged on Option B (native slash-only) — see
   // agents/runtime/council/responses/claude-code-distribution.json
-  // and scripts/install.py:_CLAUDE_SKILL_BUNDLE for the Python mirror.
+  // and `_CLAUDE_SKILL_BUNDLE` in the retired Python installer for the Python mirror.
   ["dist/agent-src/commands", "commands"],
   ["dist/agent-src/personas", "personas"]
 ];
@@ -117,9 +117,24 @@ function expandWizardSources(inputs) {
   }
   return out;
 }
+function dryRunTargetLines(global, tools, projectTarget) {
+  if (!global) return `  target:      ${projectTarget}
+`;
+  let out = "  target:      user-scope host paths (no project target)\n";
+  for (const tool of tools) {
+    const anchor = USER_SCOPE_PATHS[tool];
+    if (anchor === void 0) continue;
+    out += `      ${tool} \u2192 ${anchor.startsWith("~/") ? join(homedir(), anchor.slice(2)) : anchor}
+`;
+  }
+  out += "  phases:      project payload sync \u2014 skipped (global installs write user-scope paths only)\n";
+  out += "               host projection + managed hooks \u2014 would run\n";
+  return out;
+}
 
 export {
   RULE_SOURCE_REL,
   GLOBAL_DEPLOY_SOURCES,
-  expandWizardSources
+  expandWizardSources,
+  dryRunTargetLines
 };

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

@@ -0,0 +1,103 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/confusables.ts
+var MIN_LETTERS = 3;
+var _LATIN = new RegExp("\\p{Script=Latin}", "u");
+var _CYRILLIC = new RegExp("\\p{Script=Cyrillic}", "u");
+var _GREEK = new RegExp("\\p{Script=Greek}", "u");
+var _LETTER = new RegExp("\\p{L}", "u");
+var TOKEN_RE = /[\p{L}\p{M}\p{Nd}]+/gu;
+var CONFUSABLE_FOREIGN = /* @__PURE__ */ new Set([
+  // Cyrillic lowercase ↔ Latin
+  1072,
+  1077,
+  1086,
+  1088,
+  1089,
+  1091,
+  1093,
+  1109,
+  1110,
+  1112,
+  1211,
+  1281,
+  1307,
+  1399,
+  // Cyrillic uppercase ↔ Latin
+  1040,
+  1042,
+  1045,
+  1050,
+  1052,
+  1053,
+  1054,
+  1056,
+  1057,
+  1058,
+  1059,
+  1061,
+  1029,
+  1030,
+  1032,
+  // Greek lowercase ↔ Latin
+  945,
+  949,
+  959,
+  957,
+  961,
+  965,
+  967,
+  954,
+  // Greek uppercase ↔ Latin (only those with a real Latin twin)
+  913,
+  914,
+  917,
+  918,
+  919,
+  921,
+  922,
+  924,
+  925,
+  927,
+  929,
+  932,
+  933,
+  935,
+  914
+]);
+function _script_of(ch) {
+  if (_LATIN.test(ch)) return "latin";
+  if (_CYRILLIC.test(ch)) return "cyrillic";
+  if (_GREEK.test(ch)) return "greek";
+  return "other";
+}
+function classifyToken(token) {
+  let latin = 0;
+  let cyrillic = 0;
+  let greek = 0;
+  let letters = 0;
+  for (const ch of token) {
+    if (!_LETTER.test(ch)) continue;
+    letters += 1;
+    const script = _script_of(ch);
+    if (script === "latin") {
+      latin += 1;
+    } else if (script === "cyrillic" || script === "greek") {
+      if (CONFUSABLE_FOREIGN.has(ch.codePointAt(0))) {
+        if (script === "cyrillic") cyrillic += 1;
+        else greek += 1;
+      }
+    }
+  }
+  if (letters < MIN_LETTERS) return null;
+  const foreign = cyrillic + greek;
+  if (latin === 0 || foreign === 0) return null;
+  if (latin <= foreign) return null;
+  const which = cyrillic > 0 && greek > 0 ? "cyrillic+greek" : cyrillic > 0 ? "cyrillic" : "greek";
+  return `latin+${which} (${latin} latin / ${foreign} foreign-confusable)`;
+}
+
+export {
+  TOKEN_RE,
+  classifyToken
+};