@event4u/agent-config 12.1.0 → 13.0.0

package/dist/mcp/server.mjs

@@ -1841,17 +1841,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path75) {
-      const ctrl = callVisitor(key, node, visitor, path75);
+    function visit_(key, node, visitor, path77) {
+      const ctrl = callVisitor(key, node, visitor, path77);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path75, ctrl);
-        return visit_(key, ctrl, visitor, path75);
+        replaceNode(key, path77, ctrl);
+        return visit_(key, ctrl, visitor, path77);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path75 = Object.freeze(path75.concat(node));
+          path77 = Object.freeze(path77.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path75);
+            const ci = visit_(i, node.items[i], visitor, path77);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -1862,13 +1862,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path75 = Object.freeze(path75.concat(node));
-          const ck = visit_("key", node.key, visitor, path75);
+          path77 = Object.freeze(path77.concat(node));
+          const ck = visit_("key", node.key, visitor, path77);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path75);
+          const cv = visit_("value", node.value, visitor, path77);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -1889,17 +1889,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path75) {
-      const ctrl = await callVisitor(key, node, visitor, path75);
+    async function visitAsync_(key, node, visitor, path77) {
+      const ctrl = await callVisitor(key, node, visitor, path77);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path75, ctrl);
-        return visitAsync_(key, ctrl, visitor, path75);
+        replaceNode(key, path77, ctrl);
+        return visitAsync_(key, ctrl, visitor, path77);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path75 = Object.freeze(path75.concat(node));
+          path77 = Object.freeze(path77.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path75);
+            const ci = await visitAsync_(i, node.items[i], visitor, path77);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -1910,13 +1910,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path75 = Object.freeze(path75.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path75);
+          path77 = Object.freeze(path77.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path77);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path75);
+          const cv = await visitAsync_("value", node.value, visitor, path77);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -1943,23 +1943,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path75) {
+    function callVisitor(key, node, visitor, path77) {
       if (typeof visitor === "function")
-        return visitor(key, node, path75);
+        return visitor(key, node, path77);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path75);
+        return visitor.Map?.(key, node, path77);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path75);
+        return visitor.Seq?.(key, node, path77);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path75);
+        return visitor.Pair?.(key, node, path77);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path75);
+        return visitor.Scalar?.(key, node, path77);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path75);
+        return visitor.Alias?.(key, node, path77);
       return void 0;
     }
-    function replaceNode(key, path75, node) {
-      const parent = path75[path75.length - 1];
+    function replaceNode(key, path77, node) {
+      const parent = path77[path77.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -2569,10 +2569,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path75, value) {
+    function collectionFromPath(schema, path77, value) {
       let v = value;
-      for (let i = path75.length - 1; i >= 0; --i) {
-        const k = path75[i];
+      for (let i = path77.length - 1; i >= 0; --i) {
+        const k = path77[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -2591,7 +2591,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path75) => path75 == null || typeof path75 === "object" && !!path75[Symbol.iterator]().next().done;
+    var isEmptyPath = (path77) => path77 == null || typeof path77 === "object" && !!path77[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -2621,11 +2621,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path75, value) {
-        if (isEmptyPath(path75))
+      addIn(path77, value) {
+        if (isEmptyPath(path77))
           this.add(value);
         else {
-          const [key, ...rest] = path75;
+          const [key, ...rest] = path77;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -2639,8 +2639,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path75) {
-        const [key, ...rest] = path75;
+      deleteIn(path77) {
+        const [key, ...rest] = path77;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -2654,8 +2654,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path75, keepScalar) {
-        const [key, ...rest] = path75;
+      getIn(path77, keepScalar) {
+        const [key, ...rest] = path77;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -2673,8 +2673,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path75) {
-        const [key, ...rest] = path75;
+      hasIn(path77) {
+        const [key, ...rest] = path77;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -2684,8 +2684,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path75, value) {
-        const [key, ...rest] = path75;
+      setIn(path77, value) {
+        const [key, ...rest] = path77;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -5200,9 +5200,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path75, value) {
+      addIn(path77, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path75, value);
+          this.contents.addIn(path77, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -5277,14 +5277,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path75) {
-        if (Collection.isEmptyPath(path75)) {
+      deleteIn(path77) {
+        if (Collection.isEmptyPath(path77)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path75) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path77) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -5299,10 +5299,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path75, keepScalar) {
-        if (Collection.isEmptyPath(path75))
+      getIn(path77, keepScalar) {
+        if (Collection.isEmptyPath(path77))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path75, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path77, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -5313,10 +5313,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path75) {
-        if (Collection.isEmptyPath(path75))
+      hasIn(path77) {
+        if (Collection.isEmptyPath(path77))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path75) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path77) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -5333,13 +5333,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path75, value) {
-        if (Collection.isEmptyPath(path75)) {
+      setIn(path77, value) {
+        if (Collection.isEmptyPath(path77)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path75), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path77), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path75, value);
+          this.contents.setIn(path77, value);
         }
       }
       /**
@@ -7299,9 +7299,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path75) => {
+    visit.itemAtPath = (cst, path77) => {
       let item = cst;
-      for (const [field, index] of path75) {
+      for (const [field, index] of path77) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -7310,23 +7310,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path75) => {
-      const parent = visit.itemAtPath(cst, path75.slice(0, -1));
-      const field = path75[path75.length - 1][0];
+    visit.parentCollection = (cst, path77) => {
+      const parent = visit.itemAtPath(cst, path77.slice(0, -1));
+      const field = path77[path77.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path75, item, visitor) {
-      let ctrl = visitor(item, path75);
+    function _visit(path77, item, visitor) {
+      let ctrl = visitor(item, path77);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path75.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path77.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -7337,10 +7337,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path75);
+            ctrl = ctrl(item, path77);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path75) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path77) : ctrl;
     }
     exports.visit = visit;
   }
@@ -8642,14 +8642,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs78 = this.flowScalar(this.type);
+              const fs80 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs78, sep: [] });
+                map.items.push({ start, key: fs80, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs78);
+                this.stack.push(fs80);
               } else {
-                Object.assign(it, { key: fs78, sep: [] });
+                Object.assign(it, { key: fs80, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -8777,13 +8777,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs78 = this.flowScalar(this.type);
+              const fs80 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs78, sep: [] });
+                fc.items.push({ start: [], key: fs80, sep: [] });
               else if (it.sep)
-                this.stack.push(fs78);
+                this.stack.push(fs80);
               else
-                Object.assign(it, { key: fs78, sep: [] });
+                Object.assign(it, { key: fs80, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -19547,7 +19547,7 @@ var init_update_roadmap_progress = __esm({
     BLOCKER_HEADING_RE = /^###[ \t]+blocker:[ \t]*(.+?)[ \t]*$/gim;
     NEXT_H2_RE = /^##[ \t]+\S/m;
     LEGACY_BLOCKED_UNTIL_RE = /^>[ \t]*Blocked until:?[ \t]*(.+)$/im;
-    BLOCKER_FIELD_RE = /^-[ \t]*\*\*(Status|Owner|Blocks|Resolved when|What to do|Recommendation|If you do nothing|Question):\*\*/i;
+    BLOCKER_FIELD_RE = /^-[ \t]*\*\*[^*]+:\*\*/;
     ArgparseExit = class extends Error {
       code;
       constructor(code) {
@@ -19793,6 +19793,21 @@ function _regen_dashboard(root, dry_run) {
     _run(["git", "add", "--", "agents/roadmaps-progress.md"], root);
   }
 }
+function _regen_archive_index(root, dry_run) {
+  if (dry_run) {
+    return;
+  }
+  const script = path22.join(root, "src", "scripts", "build_archive_index.ts");
+  if (!_isFile8(script)) {
+    return;
+  }
+  _runTwin(root, script);
+  for (const rel of ["agents/roadmaps/archive/INDEX.md", "agents/roadmaps/archive/index.json"]) {
+    if (_isFile8(path22.join(root, rel))) {
+      _run(["git", "add", "--", rel], root);
+    }
+  }
+}
 function _runTwin(root, script) {
   const binName = process9.platform === "win32" ? "tsx.cmd" : "tsx";
   let dir = path22.dirname(_HERE6);
@@ -19865,6 +19880,7 @@ function main10(argv) {
     return 0;
   }
   _regen_dashboard(root, ns.dry_run);
+  _regen_archive_index(root, ns.dry_run);
   const verb = ns.dry_run ? "Would archive" : "Archived";
   for (const rec of archived) {
     process9.stdout.write(
@@ -21712,8 +21728,8 @@ function lockfile_path(env) {
   }
   return write_target("installed.lock", { env: env ?? null });
 }
-function read_lockfile(path75) {
-  const target = path75 ?? lockfile_path();
+function read_lockfile(path77) {
+  const target = path77 ?? lockfile_path();
   let text;
   try {
     text = fs31.readFileSync(target, { encoding: "utf-8" });
@@ -21923,18 +21939,18 @@ function manifest_path(project_root, env) {
   }
   return fsPath.join(project_root, DEFAULT_MANIFEST_RELATIVE);
 }
-function read_manifest(path75) {
+function read_manifest(path77) {
   let text;
   try {
-    text = require_read_text(path75);
+    text = require_read_text(path77);
   } catch {
     return null;
   }
   const data = _parse_manual(text);
   return _normalise_v2_shape(data);
 }
-function require_read_text(path75) {
-  return fs33.readFileSync(path75, { encoding: "utf-8" });
+function require_read_text(path77) {
+  return fs33.readFileSync(path77, { encoding: "utf-8" });
 }
 function _normalise_v2_shape(data) {
   if (data["tools"] === void 0 || data["tools"] === null) {
@@ -22115,9 +22131,9 @@ function stable_sort(items, key) {
     return a.index - b.index;
   }).map((entry) => entry.item);
 }
-function write_manifest(path75, version, tools, options = {}) {
+function write_manifest(path77, version, tools, options = {}) {
   const rendered = _render(version, tools, { deploy_roots: options.deploy_roots ?? null });
-  return write_atomic(path75, rendered);
+  return write_atomic(path77, rendered);
 }
 function upsert_tool(existing, options) {
   const {
@@ -27307,23 +27323,23 @@ ${user_prompt}`;
           // documented "disable all tools" value.
           //
           // It also repairs a live failure, which is how the grant was found
-          // rather than reasoned about. The spawn inherits the caller's cwd
-          // (`_runSubprocess` sets none, deliberately — the worker-role marker
-          // below depends on the vendor CLI loading this repo's hook chain),
-          // so invoking the council from inside a repository made the child
-          // load that project's own instructions AND every tool definition.
-          // In this package that overflowed the model's context window
-          // outright: `is_error: true`, `"the request is ~214331 tokens
+          // rather than reasoned about. AT THE TIME (2026-08-12) the spawn
+          // inherited the caller's cwd, so invoking the council from inside a
+          // repository made the child load that project's own instructions AND
+          // every tool definition. In this package that overflowed the context
+          // window outright: `is_error: true`, `"the request is ~214331 tokens
           // (limit 200000) … the rest is system prompt, tool definitions"`,
-          // exit 1, empty stderr — so the member reported as unavailable with
-          // no diagnosable cause. Measured 2026-08-12: identical call from
-          // `/tmp` exit 0, from the worktree exit 1, and adding this one flag
-          // returns the worktree call to exit 0.
+          // exit 1, empty stderr — the member reported unavailable with no
+          // diagnosable cause. Identical call from `/tmp` exit 0, from the
+          // worktree exit 1, and this one flag returns the worktree to exit 0.
           //
-          // Dropping the tools rather than neutralising the cwd is the
-          // narrower fix of the two: it leaves the worker-role hook chain
-          // intact and removes only the capability the role never had a use
-          // for. The context saving is a consequence, not the justification.
+          // TENSE CORRECTED 2026-08-16. This block read "`_runSubprocess` sets
+          // none, deliberately" and "dropping the tools RATHER THAN
+          // neutralising the cwd" — both false since `_runSubprocess` set
+          // `cwd: os.tmpdir()` for a DIFFERENT contamination (a member
+          // answering this repo's `end-review-nudge`). Two repairs, one
+          // cause, neither aware of the other, so a reader here concluded
+          // the cwd is inherited. Both are live; this flag bounds what a member may DO.
           "--tools",
           "",
           "--append-system-prompt",
@@ -27413,7 +27429,7 @@ ${user_prompt}`;
         if (measuredOn === void 0) return null;
         return {
           code: "model_unsupported_on_transport",
-          detail: `openai member pins model \`${this.model}\`, which the codex CLI (subscription transport) refused when measured on ${measuredOn}: "The '${this.model}' model is not supported when using Codex with a ChatGPT account." The CLI publishes no list of models it DOES accept, so there is no supported set to offer here \u2014 the one configuration measured to work is no pin at all. Fix: remove the \`model:\` line from the openai member (or set it to \`codex-default\`) to use the CLI's own default. A pinned model is only reachable on the API transport (\`api_key_ref:\` without \`mode: cli\`).`
+          detail: `openai member pins model \`${this.model}\`, which the codex CLI (subscription transport) refused when measured on ${measuredOn}: "The '${this.model}' model is not supported when using Codex with a ChatGPT account." The CLI publishes no list of models it DOES accept, so there is no supported set to offer here \u2014 the one configuration measured to work is no pin at all. Fix: set \`model: codex-default\` on the openai member. Do NOT delete the \`model:\` line \u2014 an enabled member with no model fails config load, so that takes EVERY provider to NOT CONFIGURED. A pin is reachable only on the API transport.`
         };
       }
       /**
@@ -27528,7 +27544,7 @@ ${user_prompt}`;
               // needs and neither of which the error code carries.
               detail: failure.slice(0, 400),
               ...unsupported ? {
-                hint: "the codex subscription transport serves no explicitly pinned model measured so far \u2014 remove the `model:` line from the openai member to use the CLI default"
+                hint: "the codex subscription transport serves no explicitly pinned model measured so far \u2014 set `model: codex-default` on the openai member; deleting the line fails config load"
               } : {}
             }
           });
@@ -30583,8 +30599,8 @@ function ruleFileArrives(sourcePath, scope) {
   if (!sourcePath.endsWith(".md")) {
     return true;
   }
-  const basename21 = path52.basename(sourcePath);
-  if (COMPAT_ALWAYS_EXCLUDED.includes(basename21)) {
+  const basename22 = path52.basename(sourcePath);
+  if (COMPAT_ALWAYS_EXCLUDED.includes(basename22)) {
     return false;
   }
   return rule_in_scope(sourcePath, scope.workspaces, scope.packs, scope.roles ?? null);
@@ -33444,9 +33460,9 @@ function detectToolPresence(root) {
     agentsMd: existsSync25(join49(root, "AGENTS.md"))
   };
 }
-function isDir3(path75) {
+function isDir3(path77) {
   try {
-    return statSync32(path75).isDirectory();
+    return statSync32(path77).isDirectory();
   } catch {
     return false;
   }
@@ -42805,8 +42821,8 @@ function aggregate_scores(findings, scores) {
     by_id.get(s.finding_id).push(s);
   }
   const out = /* @__PURE__ */ new Map();
-  for (const [fid, fs78] of by_id) {
-    if (fs78.length === 0) {
+  for (const [fid, fs80] of by_id) {
+    if (fs80.length === 0) {
       out.set(
         fid,
         new ConsensusMetadata({
@@ -42822,13 +42838,13 @@ function aggregate_scores(findings, scores) {
       );
       continue;
     }
-    const mean2 = fs78.reduce((acc, s) => acc + s.score, 0) / fs78.length;
-    const agree_rate = fs78.filter((s) => s.agree).length / fs78.length;
+    const mean2 = fs80.reduce((acc, s) => acc + s.score, 0) / fs80.length;
+    const agree_rate = fs80.filter((s) => s.agree).length / fs80.length;
     const strength = mean2 / 10 * agree_rate;
-    const dissent = fs78.filter((s) => !s.agree).length;
-    const concur = fs78.filter((s) => s.agree).length;
-    const scorers = fs78.map((s) => s.scorer);
-    const dissent_reasons = fs78.filter((s) => !s.agree).map((s) => [s.scorer, s.reason]);
+    const dissent = fs80.filter((s) => !s.agree).length;
+    const concur = fs80.filter((s) => s.agree).length;
+    const scorers = fs80.map((s) => s.scorer);
+    const dissent_reasons = fs80.filter((s) => !s.agree).map((s) => [s.scorer, s.reason]);
     const mean_rounded = pyRound(mean2, 2);
     out.set(
       fid,
@@ -49192,7 +49208,7 @@ function run_enveloped(spec) {
   if (cmd === void 0) {
     throw new Error("envelope argv must not be empty");
   }
-  return new Promise((resolve43) => {
+  return new Promise((resolve44) => {
     execFile(
       cmd,
       args,
@@ -49215,7 +49231,7 @@ function run_enveloped(spec) {
         }
         const [out, outTrunc] = _truncate(String(stdout ?? ""), spec.max_output_bytes);
         const [err, errTrunc] = _truncate(String(stderr ?? ""), spec.max_output_bytes);
-        resolve43({
+        resolve44({
           exit_code: timedOut ? null : exitCode,
           timed_out: timedOut,
           stdout: out,
@@ -49235,9 +49251,977 @@ var init_safety_envelope = __esm({
   }
 });
 
-// src/scripts/mcp_server/__main__.ts
+// src/scripts/_lib/skill_catalogue.ts
+var skill_catalogue_exports = {};
+__export(skill_catalogue_exports, {
+  DEFAULT_CATALOGUE_ROOTS: () => DEFAULT_CATALOGUE_ROOTS,
+  OBSERVATION_LOG: () => OBSERVATION_LOG,
+  analyzeSelector: () => analyzeSelector,
+  buildHostEventRecord: () => buildHostEventRecord,
+  buildNoTruncationRecord: () => buildNoTruncationRecord,
+  buildObservationRecord: () => buildObservationRecord,
+  catalogueLimitWarning: () => catalogueLimitWarning,
+  classifyHostProjection: () => classifyHostProjection,
+  formatPerHostVerdicts: () => formatPerHostVerdicts,
+  formatProjectionModes: () => formatProjectionModes,
+  formatReport: () => formatReport,
+  headlineRecordPerHost: () => headlineRecordPerHost,
+  knownHostLimits: () => knownHostLimits,
+  measureCatalogueVolume: () => measureCatalogueVolume,
+  migrationEligibility: () => migrationEligibility,
+  migrationPromptLines: () => migrationPromptLines,
+  observationSourceOf: () => observationSourceOf,
+  parseHostBudgetEvent: () => parseHostBudgetEvent,
+  readObservationLog: () => readObservationLog,
+  readProjectedCatalogue: () => readProjectedCatalogue,
+  resolveSkillsRoot: () => resolveSkillsRoot,
+  truncationModeOf: () => truncationModeOf
+});
+import * as fs77 from "node:fs";
+import * as path73 from "node:path";
+function resolveSkillsRoot(workspaceRoot) {
+  for (const candidate of DEFAULT_CATALOGUE_ROOTS) {
+    const abs = path73.join(workspaceRoot, candidate);
+    try {
+      if (fs77.existsSync(abs) && fs77.statSync(abs).isDirectory()) return abs;
+    } catch {
+    }
+  }
+  return null;
+}
+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 = fs77.readdirSync(root).filter((n) => fs77.existsSync(path73.join(root, n, "SKILL.md"))).sort();
+  return names.map((name, index) => {
+    const content = fs77.readFileSync(path73.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 rangesAreDisjoint(a, b) {
+  if (a.length === 0 || b.length === 0) return false;
+  const maxA = Math.max(...a);
+  const minA = Math.min(...a);
+  const maxB = Math.max(...b);
+  const minB = Math.min(...b);
+  return maxA < minB || maxB < minA;
+}
+function analyzeSelector(projected, observedBare, observedDescribed) {
+  const known = new Map(projected.map((e) => [e.name, e]));
+  const bare = observedBare.filter((n) => known.has(n));
+  const describedInput = observedDescribed ?? projected.map((e) => e.name).filter((n) => !bare.includes(n));
+  const described = describedInput.filter((n) => known.has(n));
+  const unknownObserved = [
+    .../* @__PURE__ */ new Set([
+      ...observedBare.filter((n) => !known.has(n)),
+      ...(observedDescribed ?? []).filter((n) => !known.has(n))
+    ])
+  ].sort();
+  const base = {
+    entriesTotal: projected.length,
+    observedBare: [...bare].sort(),
+    observedDescribed: [...described].sort(),
+    unknownObserved
+  };
+  if (bare.length === 0 || described.length === 0) {
+    return {
+      ...base,
+      candidates: [],
+      verdict: "insufficient-observation"
+    };
+  }
+  const bareEntries = bare.map((n) => known.get(n));
+  const describedEntries = described.map((n) => known.get(n));
+  const candidates = [];
+  const bareWithDesc = bareEntries.filter((e) => e.hasDescription).length;
+  const describedWithoutDesc = describedEntries.filter((e) => !e.hasDescription).length;
+  candidates.push({
+    id: "declares-description",
+    describes: "the projected SKILL.md declares a `description:`",
+    separates: bareWithDesc === 0 && describedWithoutDesc === 0,
+    detail: `${bareWithDesc}/${bareEntries.length} bare entries declare one; ${describedWithoutDesc}/${describedEntries.length} described entries do not`
+  });
+  const barePositions = bareEntries.map((e) => e.position);
+  const describedPositions = describedEntries.map((e) => e.position);
+  const positional = Math.max(...describedPositions) < Math.min(...barePositions);
+  candidates.push({
+    id: "positional-head",
+    describes: "every described entry sorts before every bare entry (a head-N budget)",
+    separates: positional,
+    detail: positional ? `described top out at #${Math.max(...describedPositions)}, bare start at #${Math.min(...barePositions)}` : `described reach #${Math.max(...describedPositions)} while bare start at #${Math.min(...barePositions)} \u2014 the ranges overlap, so no head-N cut explains this`
+  });
+  const lengthSeparates = rangesAreDisjoint(
+    bareEntries.map((e) => e.descriptionLength),
+    describedEntries.map((e) => e.descriptionLength)
+  );
+  candidates.push({
+    id: "description-length",
+    describes: "description length ranges do not overlap between the groups",
+    separates: lengthSeparates,
+    detail: lengthSeparates ? "a length threshold separates the two groups" : "length ranges overlap"
+  });
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const entry of projected) for (const key of entry.frontmatterKeys) allKeys.add(key);
+  for (const key of [...allKeys].sort()) {
+    const bareHas = bareEntries.filter((e) => e.frontmatterKeys.includes(key)).length;
+    const describedHas = describedEntries.filter(
+      (e) => e.frontmatterKeys.includes(key)
+    ).length;
+    const separates = bareHas === 0 && describedHas === describedEntries.length || describedHas === 0 && bareHas === bareEntries.length;
+    if (!separates) continue;
+    candidates.push({
+      id: `frontmatter:${key}`,
+      describes: `presence of the \`${key}:\` frontmatter key`,
+      separates: true,
+      detail: `bare ${bareHas}/${bareEntries.length}, described ${describedHas}/${describedEntries.length}`
+    });
+  }
+  return {
+    ...base,
+    candidates,
+    verdict: candidates.some((c) => c.separates) ? "selector-found" : "no-selector"
+  };
+}
+function truncationModeOf(record) {
+  return record.truncation_mode ?? "per-entry";
+}
+function observationSourceOf(record) {
+  return record.observation_source ?? "self-report";
+}
+function buildObservationRecord(report2, host, observedAt) {
+  return {
+    schema: 1,
+    observed_at: observedAt,
+    host,
+    entries_total: report2.entriesTotal,
+    bare_count: report2.observedBare.length,
+    described_count: report2.observedDescribed.length,
+    bare_names: report2.observedBare,
+    verdict: report2.verdict,
+    separating_candidates: report2.candidates.filter((c) => c.separates).map((c) => c.id),
+    truncation_mode: "per-entry",
+    observation_source: "self-report"
+  };
+}
+function parseHostBudgetEvent(stream) {
+  for (const line of stream.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const item = parsed.item;
+    if (item === void 0 || item === null || item.type !== "error") continue;
+    const message = typeof item.message === "string" ? item.message : "";
+    if (!/skills context budget/i.test(message)) continue;
+    const dropped = /(\d+)\s+additional skills were not included/i.exec(message);
+    if (!dropped) {
+      return null;
+    }
+    return {
+      droppedCount: Number.parseInt(dropped[1], 10),
+      descriptionsStripped: /descriptions were removed/i.test(message)
+    };
+  }
+  return null;
+}
+function buildHostEventRecord(host, observedAt, entriesOffered, event, projectedSkillCount, projectionMode) {
+  return {
+    schema: 1,
+    observed_at: observedAt,
+    host,
+    // OUR projection, not the host's denominator. Measured 2026-08-15 they
+    // are not the same number and there is no way to read the host's:
+    // `~/.codex` projects 297 skills + 200 commands = 497 by this tool's
+    // count, while the host reported dropping 393 — and a controlled +60
+    // commands moved that by ZERO. Whatever codex counts, it is not this.
+    // So `entries_total - dropped_count` is NOT a delivered count, and
+    // nothing here computes one: a subtraction across two different
+    // denominators produces a confident number describing neither.
+    entries_total: entriesOffered,
+    bare_count: 0,
+    described_count: 0,
+    bare_names: [],
+    // There is nothing to separate: the host did not choose per entry, it
+    // stripped all of them. `no-selector` would read as "we looked and
+    // found none", which is not what happened.
+    verdict: "insufficient-observation",
+    separating_candidates: [],
+    truncation_mode: "budget-strip-and-drop",
+    observation_source: "host-event",
+    dropped_count: event.droppedCount,
+    ...projectedSkillCount === void 0 ? {} : { projected_skill_count: projectedSkillCount },
+    ...projectionMode === void 0 ? {} : { projection_mode: projectionMode }
+  };
+}
+function buildNoTruncationRecord(host, observedAt, entriesOffered, projectedSkillCount, projectionMode) {
+  return {
+    schema: 1,
+    observed_at: observedAt,
+    host,
+    entries_total: entriesOffered,
+    // BOTH counts stay 0, and neither is a claim that nothing arrived
+    // described. The host published no per-entry breakdown at all — it
+    // published nothing, which is what `truncation_mode: 'none'` records.
+    // Writing `described_count: entriesOffered` would look like a
+    // measurement and be an inference; 0 here means "not counted", exactly
+    // as it does on the strip-and-drop record beside it.
+    bare_count: 0,
+    described_count: 0,
+    bare_names: [],
+    // Nothing arrived bare, so no property separated bare from described —
+    // which is what `no-selector` states. Unlike the strip-and-drop case,
+    // here the label is literally true rather than merely available.
+    verdict: "no-selector",
+    separating_candidates: [],
+    truncation_mode: "none",
+    observation_source: "host-event",
+    dropped_count: 0,
+    ...projectedSkillCount === void 0 ? {} : { projected_skill_count: projectedSkillCount },
+    ...projectionMode === void 0 ? {} : { projection_mode: projectionMode }
+  };
+}
+function markdownFilesUnder(root) {
+  if (!fs77.existsSync(root)) return [];
+  const out = [];
+  const walk = (dir) => {
+    for (const entry of fs77.readdirSync(dir, { withFileTypes: true })) {
+      const full = path73.join(dir, entry.name);
+      if (fs77.statSync(full).isDirectory()) walk(full);
+      else if (entry.name.endsWith(".md")) out.push(full);
+    }
+  };
+  walk(root);
+  return out;
+}
+function measureCatalogueVolume(host, root) {
+  const skillsRoot = path73.join(root, "skills");
+  const skills = fs77.existsSync(skillsRoot) ? readProjectedCatalogue(skillsRoot) : [];
+  const commandEntries = markdownFilesUnder(path73.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 classifyHostProjection(volume, counts) {
+  const ambiguous = counts.scoped === counts.legacyAll;
+  let matches = "indeterminate";
+  if (!ambiguous) {
+    if (volume.skillEntries === counts.scoped) matches = "scoped";
+    else if (volume.skillEntries === counts.legacyAll) matches = "legacy-all";
+  }
+  return {
+    host: volume.host,
+    root: volume.root,
+    installedSkills: volume.skillEntries,
+    matches
+  };
+}
+function formatProjectionModes(counts, rows) {
+  const lines = [
+    "projected SKILL counts by projection mode (package side, one walk):",
+    `  scoped:      ${counts.scoped}`,
+    `  legacy-all:  ${counts.legacyAll}`,
+    `  pruned under scoped: ${counts.prunedUnderScoped}`,
+    `  active packs under scoped: ${counts.activePacks.length}`,
+    ""
+  ];
+  if (rows.length === 0) {
+    lines.push(
+      "No host root measured. Pass --host-root <dir> (repeatable) to read what",
+      "each host currently holds against the two numbers above."
+    );
+    return lines.join("\n");
+  }
+  lines.push("installed host roots:");
+  for (const row of [...rows].sort((a, b) => a.host.localeCompare(b.host))) {
+    lines.push(`  ${row.host}: ${row.installedSkills} skills \u2014 consistent with ${row.matches}`);
+  }
+  lines.push(
+    "",
+    "This is the PROJECTION half only, and it is a measurement: no default was",
+    "read, changed, or recommended here. `indeterminate` means the root carries",
+    "neither count \u2014 another suite, a plugin, or a stale install all produce it.",
+    "No host limit is extrapolated from another host, and no delivered or",
+    "survivor count is computed anywhere."
+  );
+  return lines.join("\n");
+}
+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 headlineRecordPerHost(records) {
+  const out = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const previous = out.get(record.host);
+    if (previous === void 0 || _supersedes(record, previous)) {
+      out.set(record.host, record);
+    }
+  }
+  return out;
+}
+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 (!fs77.existsSync(logPath)) return [];
+  const out = [];
+  for (const line of fs77.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;
+}
+function formatPerHostVerdicts(records) {
+  if (records.length === 0) return "no observations recorded yet.";
+  const byHost = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const bucket = byHost.get(record.host) ?? [];
+    bucket.push(record);
+    byHost.set(record.host, bucket);
+  }
+  const headline = headlineRecordPerHost(records);
+  const lines = [];
+  for (const host of [...byHost.keys()].sort()) {
+    const bucket = byHost.get(host);
+    const latest = headline.get(host);
+    const mode = truncationModeOf(latest);
+    lines.push(
+      `${host}: ${bucket.length} observation(s) \xB7 mode ${mode} \xB7 source ${observationSourceOf(latest)} \xB7 latest ${latest.observed_at}`
+    );
+    lines.push(
+      mode === "budget-strip-and-drop" ? `   offered ${latest.entries_total}, dropped ${latest.dropped_count ?? "unknown"} \u2014 no per-entry selector exists on this host; the quantity is the budget.` : `   verdict ${latest.verdict} \xB7 ${latest.bare_count} bare of ${latest.entries_total}`
+    );
+  }
+  const modes = new Set([...headline.values()].map((r) => truncationModeOf(r)));
+  lines.push("");
+  lines.push(
+    modes.size > 1 ? `hosts: ${byHost.size} \xB7 truncation modes DIFFER (${[...modes].sort().join(", ")}) \u2014 a pooled verdict across them would describe neither host.` : `hosts: ${byHost.size} \xB7 all observed hosts truncate the same way (${[...modes][0] ?? "none"}).`
+  );
+  return lines.join("\n");
+}
+function formatReport(report2) {
+  const lines = [];
+  lines.push(`catalogue root: ${report2.catalogueRoot}`);
+  lines.push(`entries: ${report2.entriesTotal}`);
+  lines.push(
+    `observed: ${report2.observedBare.length} bare \xB7 ${report2.observedDescribed.length} described (self-reported)`
+  );
+  if (report2.unknownObserved.length > 0) {
+    lines.push(
+      `\u26A0\uFE0F  ${report2.unknownObserved.length} observed name(s) absent from the projection: ${report2.unknownObserved.join(", ")}`
+    );
+  }
+  if (report2.verdict === "insufficient-observation") {
+    lines.push("");
+    lines.push(
+      "verdict: insufficient-observation \u2014 an observation needs at least one bare AND one described entry to separate anything."
+    );
+    return lines.join("\n");
+  }
+  lines.push("");
+  lines.push("selector candidates:");
+  for (const candidate of report2.candidates) {
+    lines.push(`  ${candidate.separates ? "\u2705" : "\u274C"} ${candidate.id} \u2014 ${candidate.describes}`);
+    lines.push(`     ${candidate.detail}`);
+  }
+  lines.push("");
+  lines.push(
+    report2.verdict === "selector-found" ? "verdict: selector-found \u2014 a delivery fix can act on the separating property above." : "verdict: no-selector \u2014 no measured property separates the groups; the selector is host-internal on this evidence. Publish the null rather than guessing a fix."
+  );
+  return lines.join("\n");
+}
+var DEFAULT_CATALOGUE_ROOTS, OBSERVATION_LOG;
+var init_skill_catalogue = __esm({
+  "src/scripts/_lib/skill_catalogue.ts"() {
+    "use strict";
+    DEFAULT_CATALOGUE_ROOTS = [".claude/skills", "src/skills"];
+    OBSERVATION_LOG = path73.join(
+      "agents",
+      "evidence",
+      "metrics",
+      "skill-catalogue.jsonl"
+    );
+  }
+});
+
+// src/scripts/skill_tools/score_skill_relevance.ts
+var score_skill_relevance_exports = {};
+__export(score_skill_relevance_exports, {
+  DEFAULT_SKILLS_DIR: () => DEFAULT_SKILLS_DIR,
+  ROOT: () => ROOT3,
+  _SAMPLE: () => _SAMPLE,
+  _parse_frontmatter: () => _parse_frontmatter2,
+  _tokenize: () => _tokenize,
+  main: () => main35,
+  parse_args: () => parse_args7,
+  rank: () => rank
+});
+import * as fs78 from "node:fs";
 import * as path74 from "node:path";
-import { fileURLToPath as fileURLToPath47 } from "node:url";
+import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL35 } from "node:url";
+function pyLen(s) {
+  let n = 0;
+  for (const _ of s) {
+    n++;
+  }
+  return n;
+}
+function _tokenize(text) {
+  const out = /* @__PURE__ */ new Set();
+  const matches = text.toLowerCase().match(TOKEN_RE3) ?? [];
+  for (const t of matches) {
+    if (!STOPWORDS.has(t) && pyLen(t) > 2) {
+      out.add(t);
+    }
+  }
+  return out;
+}
+function _parse_frontmatter2(filePath) {
+  const text = fs78.readFileSync(filePath, "utf-8");
+  if (!text.startsWith("---")) {
+    return {};
+  }
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) {
+    return {};
+  }
+  const block = text.slice(3, end);
+  const out = {};
+  let currentListKey = null;
+  for (const raw of _splitlines13(block)) {
+    const line = _rstrip3(raw);
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    if (currentListKey !== null && line.startsWith("  - ")) {
+      const existing = out[currentListKey];
+      const list = Array.isArray(existing) ? existing : [];
+      if (!Array.isArray(existing)) {
+        out[currentListKey] = list;
+      }
+      list.push(line.slice(4).trim());
+      continue;
+    }
+    currentListKey = null;
+    const m = /^([a-zA-Z_][\w-]*)[ \t\r\f\v]*:[ \t\r\f\v]*(.*)$/u.exec(line);
+    if (!m) {
+      continue;
+    }
+    const key = m[1];
+    let val = m[2].trim();
+    if (val === "") {
+      currentListKey = key;
+      continue;
+    }
+    if (val.startsWith('"') && val.endsWith('"')) {
+      val = val.slice(1, -1);
+    }
+    out[key] = val;
+  }
+  return out;
+}
+function _splitlines13(s) {
+  if (s === "") {
+    return [];
+  }
+  return s.split(/\r\n|\r|\n/u);
+}
+function _rstrip3(s) {
+  return s.replace(/\s+$/u, "");
+}
+function _load_skills(skillsDir) {
+  const skills = [];
+  for (const skillMd of _globSkillMd(skillsDir)) {
+    const fm = _parse_frontmatter2(skillMd);
+    const rawName = fm["name"];
+    const name = _truthyStr(rawName) ? String(rawName) : path74.basename(path74.dirname(skillMd));
+    const rawDesc = fm["description"];
+    const desc = _truthyStr(rawDesc) ? String(rawDesc) : "";
+    let personas = fm["personas"] ?? [];
+    if (typeof personas === "string") {
+      personas = [personas];
+    }
+    const personaList = [...personas];
+    skills.push({
+      name,
+      description: desc,
+      personas: personaList,
+      terms: _tokenize(name + " " + desc)
+    });
+  }
+  return skills;
+}
+function _truthyStr(v) {
+  if (typeof v === "string") {
+    return v !== "";
+  }
+  return false;
+}
+function _globSkillMd(root) {
+  let names;
+  try {
+    names = fs78.readdirSync(root);
+  } catch {
+    return [];
+  }
+  const dirs = [];
+  for (const name of names) {
+    const dir = path74.join(root, name);
+    const skillMd = path74.join(dir, "SKILL.md");
+    try {
+      if (fs78.statSync(dir).isDirectory() && fs78.statSync(skillMd).isFile()) {
+        dirs.push(name);
+      }
+    } catch {
+    }
+  }
+  dirs.sort();
+  return dirs.map((name) => path74.join(root, name, "SKILL.md"));
+}
+function _score3(taskTerms, skill) {
+  if (taskTerms.size === 0) {
+    return 0;
+  }
+  const skillTerms = skill.terms;
+  let inter = 0;
+  for (const t of taskTerms) {
+    if (skillTerms.has(t)) {
+      inter++;
+    }
+  }
+  const 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();
+    const parts = slug.split("-");
+    if (taskLower.includes(slug) || parts.some((part) => taskTerms.has(part))) {
+      personaHit = 1;
+      break;
+    }
+  }
+  return pyRound(overlap * 70 + personaHit * 30, 0);
+}
+function rank(task, skillsDir) {
+  const taskTerms = _tokenize(task);
+  const skills = _load_skills(skillsDir);
+  const rows = [];
+  for (const s of skills) {
+    const score = _score3(taskTerms, s);
+    if (score > 0) {
+      rows.push([s.name, score, [...s.personas]]);
+    }
+  }
+  rows.sort((a, b) => {
+    if (b[1] !== a[1]) {
+      return b[1] - a[1];
+    }
+    if (a[0] < b[0]) {
+      return -1;
+    }
+    if (a[0] > b[0]) {
+      return 1;
+    }
+    return 0;
+  });
+  return rows;
+}
+function _ljust4(s, w) {
+  const len = pyLen(s);
+  return len >= w ? s : s + " ".repeat(w - len);
+}
+function _rjust3(n) {
+  const s = String(n);
+  return s.length >= 3 ? s : " ".repeat(3 - s.length) + s;
+}
+function _print_human(rowsIn, top) {
+  let rows = rowsIn;
+  if (top) {
+    rows = rows.slice(0, top);
+  }
+  if (rows.length === 0) {
+    return ["(no relevant skills found)"];
+  }
+  const width = Math.max(...rows.map((r) => pyLen(r[0])));
+  const lines = [];
+  for (const [name, score, personas] of rows) {
+    const personaStr = personas.length > 0 ? personas.join(", ") : "\u2014";
+    lines.push(`  ${_rjust3(score)}  ${_ljust4(name, width)}  ${personaStr}`);
+  }
+  return lines;
+}
+function _pyJsonStr3(s) {
+  let out = '"';
+  for (const ch of s) {
+    const code = ch.codePointAt(0);
+    if (ch === '"') {
+      out += '\\"';
+    } else if (ch === "\\") {
+      out += "\\\\";
+    } else if (ch === "\n") {
+      out += "\\n";
+    } else if (ch === "\r") {
+      out += "\\r";
+    } else if (ch === "	") {
+      out += "\\t";
+    } else if (ch === "\b") {
+      out += "\\b";
+    } else if (ch === "\f") {
+      out += "\\f";
+    } else if (code < 32) {
+      out += `\\u${code.toString(16).padStart(4, "0")}`;
+    } else if (code < 127) {
+      out += ch;
+    } else if (code <= 65535) {
+      out += `\\u${code.toString(16).padStart(4, "0")}`;
+    } else {
+      const c = code - 65536;
+      const hi = 55296 + (c >> 10);
+      const lo = 56320 + (c & 1023);
+      out += `\\u${hi.toString(16).padStart(4, "0")}\\u${lo.toString(16).padStart(4, "0")}`;
+    }
+  }
+  return out + '"';
+}
+function pyJsonDumpsIndent2(obj, level = 0) {
+  if (obj === null) {
+    return "null";
+  }
+  if (typeof obj === "number") {
+    return String(obj);
+  }
+  if (typeof obj === "string") {
+    return _pyJsonStr3(obj);
+  }
+  if (obj === true) {
+    return "true";
+  }
+  if (obj === false) {
+    return "false";
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return "[]";
+    }
+    const pad2 = " ".repeat(2 * (level + 1));
+    const closePad2 = " ".repeat(2 * level);
+    return `[
+${obj.map((v) => pad2 + pyJsonDumpsIndent2(v, level + 1)).join(",\n")}
+${closePad2}]`;
+  }
+  const keys = Object.keys(obj);
+  if (keys.length === 0) {
+    return "{}";
+  }
+  const pad = " ".repeat(2 * (level + 1));
+  const closePad = " ".repeat(2 * level);
+  const parts = keys.map(
+    (k) => `${pad}${_pyJsonStr3(k)}: ${pyJsonDumpsIndent2(obj[k], level + 1)}`
+  );
+  return `{
+${parts.join(",\n")}
+${closePad}}`;
+}
+function _argError10(message) {
+  process.stderr.write(`${PROG5}: error: ${message}
+`);
+  process.exit(2);
+}
+function _parseInt2(raw) {
+  if (!/^[+-]?\d+$/u.test(raw.trim())) {
+    _argError10(`argument --top: invalid int value: '${raw}'`);
+  }
+  return parseInt(raw, 10);
+}
+function parse_args7(argv) {
+  const args = {
+    task: "",
+    skills_dir: DEFAULT_SKILLS_DIR,
+    top: 0,
+    json: false,
+    sample: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json") {
+      args.json = true;
+    } else if (a === "--sample") {
+      args.sample = true;
+    } else if (a === "--task") {
+      const v = argv[++i];
+      if (v === void 0) {
+        _argError10("argument --task: expected one argument");
+      }
+      args.task = v;
+    } else if (a.startsWith("--task=")) {
+      args.task = a.slice("--task=".length);
+    } else if (a === "--skills-dir") {
+      const v = argv[++i];
+      if (v === void 0) {
+        _argError10("argument --skills-dir: expected one argument");
+      }
+      args.skills_dir = v;
+    } else if (a.startsWith("--skills-dir=")) {
+      args.skills_dir = a.slice("--skills-dir=".length);
+    } else if (a === "--top") {
+      const v = argv[++i];
+      if (v === void 0) {
+        _argError10("argument --top: expected one argument");
+      }
+      args.top = _parseInt2(v);
+    } else if (a.startsWith("--top=")) {
+      args.top = _parseInt2(a.slice("--top=".length));
+    } else {
+      _argError10(`unrecognized arguments: ${a}`);
+    }
+  }
+  return args;
+}
+function main35(argv = null) {
+  const args = parse_args7(argv ?? process.argv.slice(2));
+  const task = args.sample ? _SAMPLE.task : args.task;
+  if (!task) {
+    _argError10("--task is required (or pass --sample)");
+  }
+  const rows = rank(task, args.skills_dir);
+  if (args.json) {
+    const sliced = args.top ? rows.slice(0, args.top) : rows;
+    const payload = sliced.map(([n, s, p]) => ({ name: n, score: s, personas: p }));
+    process.stdout.write(pyJsonDumpsIndent2({ task, ranked: payload }));
+    process.stdout.write("\n");
+  } else {
+    const lines = _print_human(rows, args.top || null);
+    process.stdout.write(lines.join("\n") + "\n");
+  }
+  return 0;
+}
+function _isCliEntry32() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL35(path74.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs78.realpathSync(fileURLToPath46(import.meta.url));
+    const argv = fs78.realpathSync(path74.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+var _HERE23, ROOT3, DEFAULT_SKILLS_DIR, TOKEN_RE3, STOPWORDS, PROG5, _SAMPLE, _isMain5;
+var init_score_skill_relevance = __esm({
+  "src/scripts/skill_tools/score_skill_relevance.ts"() {
+    "use strict";
+    init_value_ladder();
+    _HERE23 = fileURLToPath46(import.meta.url);
+    ROOT3 = path74.resolve(path74.dirname(_HERE23), "..", "..", "..");
+    DEFAULT_SKILLS_DIR = path74.join(ROOT3, ".agent-src.uncondensed", "skills");
+    TOKEN_RE3 = /[a-z][a-z0-9]+/g;
+    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"
+    ]);
+    PROG5 = "score_skill_relevance.py";
+    _SAMPLE = {
+      task: "build a livewire component for the user dashboard with reactive state"
+    };
+    _isMain5 = _isCliEntry32();
+    if (_isMain5) {
+      process.exitCode = main35();
+    }
+  }
+});
+
+// src/scripts/mcp_server/__main__.ts
+import * as path76 from "node:path";
+import { fileURLToPath as fileURLToPath48 } from "node:url";
 
 // src/scripts/mcp_server/index.ts
 var __version__ = "0.1.0";
@@ -49284,9 +50268,9 @@ init_prompts();
 init_resources();
 
 // src/scripts/mcp_server/tools.ts
-import * as fs77 from "node:fs";
-import * as path73 from "node:path";
-import { fileURLToPath as fileURLToPath46 } from "node:url";
+import * as fs79 from "node:fs";
+import * as path75 from "node:path";
+import { fileURLToPath as fileURLToPath47 } from "node:url";
 
 // src/scripts/chat_history.ts
 init_memory_lookup();
@@ -51519,9 +52503,9 @@ function _strip8(s) {
 }
 function _resolvePath2(p) {
   try {
-    return fs77.realpathSync(p);
+    return fs79.realpathSync(p);
   } catch {
-    return path73.resolve(p);
+    return path75.resolve(p);
   }
 }
 function _resolveConsumerRoot(override) {
@@ -51531,14 +52515,14 @@ function _resolveConsumerRoot(override) {
   return _resolvePath2(process.cwd());
 }
 function _relativeUnder(target, root) {
-  const rel = path73.relative(root, target);
+  const rel = path75.relative(root, target);
   if (rel === "") {
     return "";
   }
-  if (rel.startsWith("..") || path73.isAbsolute(rel)) {
+  if (rel.startsWith("..") || path75.isAbsolute(rel)) {
     return null;
   }
-  return rel.split(path73.sep).join("/");
+  return rel.split(path75.sep).join("/");
 }
 function _reprStrList(values) {
   return `[${values.map((v) => `'${v}'`).join(", ")}]`;
@@ -51547,11 +52531,11 @@ function _validateInTreePath(raw, consumerRoot) {
   const root = _resolvePath2(consumerRoot);
   let target;
   if (raw === null || raw === void 0 || raw === "") {
-    target = path73.join(root, "agents", "runtime", ".agent-chat-history");
-  } else if (path73.isAbsolute(raw)) {
+    target = path75.join(root, "agents", "runtime", ".agent-chat-history");
+  } else if (path75.isAbsolute(raw)) {
     target = _resolvePath2(raw);
   } else {
-    target = _resolvePath2(path73.join(root, raw));
+    target = _resolvePath2(path75.join(root, raw));
   }
   const rel = _relativeUnder(target, root);
   if (rel === null) {
@@ -51589,11 +52573,11 @@ async function _lintSkillsHandler(args, consumerRoot) {
       if (typeof raw !== "string") {
         throw new Error("'paths' entries must be strings");
       }
-      const resolved = path73.isAbsolute(raw) ? _resolvePath2(raw) : _resolvePath2(path73.join(root, raw));
+      const resolved = path75.isAbsolute(raw) ? _resolvePath2(raw) : _resolvePath2(path75.join(root, raw));
       if (_relativeUnder(resolved, root) === null) {
         throw new Error(`path escapes consumer_root: ${resolved}`);
       }
-      if (fs77.existsSync(resolved)) {
+      if (fs79.existsSync(resolved)) {
         paths.push(resolved);
       }
     }
@@ -51630,7 +52614,7 @@ async function _chatHistoryAppendHandler(args, consumerRoot) {
     if (typeof minSchema !== "number" || !Number.isInteger(minSchema) || typeof minSchema === "boolean") {
       throw new Error("'min_schema_version' must be an integer");
     }
-    const existingHeader = fs77.existsSync(target) ? _chReadHeader(target) : null;
+    const existingHeader = fs79.existsSync(target) ? _chReadHeader(target) : null;
     const observed = existingHeader !== null && typeof existingHeader === "object" ? _pyInt7(existingHeader.v ?? 0) : SCHEMA_VERSION3;
     if (observed < minSchema) {
       throw new Error(`chat-history schema ${observed} below required ${minSchema}`);
@@ -51645,8 +52629,8 @@ async function _chatHistoryAppendHandler(args, consumerRoot) {
       session: session === void 0 ? null : session
     };
   }
-  if (!fs77.existsSync(target) || _chReadHeader(target) === null) {
-    fs77.mkdirSync(path73.dirname(target), { recursive: true });
+  if (!fs79.existsSync(target) || _chReadHeader(target) === null) {
+    fs79.mkdirSync(path75.dirname(target), { recursive: true });
     _chInit(target);
   }
   _chAppend(entry, target, session ?? null);
@@ -51690,7 +52674,7 @@ async function _chatHistoryReadHandler(args, consumerRoot) {
   if (detail !== "full" && detail !== "index") {
     throw new Error("'detail' must be 'index' or 'full'");
   }
-  if (!fs77.existsSync(target)) {
+  if (!fs79.existsSync(target)) {
     return { path: target, entries: [], count: 0 };
   }
   if (around !== void 0 && around !== null) {
@@ -51792,8 +52776,8 @@ async function _memoryStatusHandler(_args, consumerRoot) {
   }
   return result;
 }
-var _PACKAGE_ROOT3 = path73.resolve(
-  path73.dirname(fileURLToPath46(import.meta.url)),
+var _PACKAGE_ROOT3 = path75.resolve(
+  path75.dirname(fileURLToPath47(import.meta.url)),
   "..",
   "..",
   ".."
@@ -51837,10 +52821,10 @@ async function _memorySignalHandler(args, consumerRoot) {
 async function _roadmapProgressHandler(args, consumerRoot) {
   const dryRun = _pyTruthy6(args.dry_run ?? false);
   const root = _resolvePath2(consumerRoot);
-  const roadmapRoot = path73.join(root, "agents", "roadmaps");
-  const target = path73.join(root, "agents", "roadmaps-progress.md");
+  const roadmapRoot = path75.join(root, "agents", "roadmaps");
+  const target = path75.join(root, "agents", "roadmaps-progress.md");
   const urp = await Promise.resolve().then(() => (init_update_roadmap_progress(), update_roadmap_progress_exports));
-  if (!fs77.existsSync(roadmapRoot)) {
+  if (!fs79.existsSync(roadmapRoot)) {
     return {
       written: false,
       path: target,
@@ -51855,7 +52839,7 @@ async function _roadmapProgressHandler(args, consumerRoot) {
   const stepsDone = roadmaps.reduce((s, r) => s + r.done, 0);
   const stepsTotal = roadmaps.reduce((s, r) => s + r.total_active, 0);
   if (!dryRun) {
-    fs77.writeFileSync(target, content, "utf-8");
+    fs79.writeFileSync(target, content, "utf-8");
   }
   return {
     written: !dryRun,
@@ -51876,11 +52860,11 @@ async function _roadmapArchiveHandler(_args, consumerRoot) {
   let dashboardRegenerated = false;
   if (archived.length > 0) {
     const urp = await Promise.resolve().then(() => (init_update_roadmap_progress(), update_roadmap_progress_exports));
-    const roadmapRoot = path73.join(root, "agents", "roadmaps");
-    if (fs77.existsSync(roadmapRoot)) {
+    const roadmapRoot = path75.join(root, "agents", "roadmaps");
+    if (fs79.existsSync(roadmapRoot)) {
       const roadmaps = urp.collect(roadmapRoot);
-      fs77.writeFileSync(
-        path73.join(root, "agents", "roadmaps-progress.md"),
+      fs79.writeFileSync(
+        path75.join(root, "agents", "roadmaps-progress.md"),
         urp.render(roadmaps, urp.collect_bundles(root)),
         "utf-8"
       );
@@ -51896,9 +52880,9 @@ async function _roadmapArchiveHandler(_args, consumerRoot) {
 async function _capabilitiesIndexHandler(args, consumerRoot) {
   const check = _pyTruthy6(args.check ?? false);
   const cap = await Promise.resolve().then(() => (init_generate_capabilities_index(), generate_capabilities_index_exports));
-  const out = path73.join(_PACKAGE_ROOT3, "CAPABILITIES.yaml");
+  const out = path75.join(_PACKAGE_ROOT3, "CAPABILITIES.yaml");
   const content = cap.build();
-  const onDisk = fs77.existsSync(out) ? fs77.readFileSync(out, "utf-8") : "";
+  const onDisk = fs79.existsSync(out) ? fs79.readFileSync(out, "utf-8") : "";
   const drift = onDisk !== content;
   if (check) {
     return { check: true, written: false, drift, path: out };
@@ -51909,7 +52893,7 @@ async function _capabilitiesIndexHandler(args, consumerRoot) {
       `CAPABILITIES.yaml path escapes consumer_root: ${out} not under ${root}`
     );
   }
-  fs77.writeFileSync(out, content, "utf-8");
+  fs79.writeFileSync(out, content, "utf-8");
   return { check: false, written: true, drift, path: out };
 }
 async function _runDoctorLeg(consumerRoot) {
@@ -52009,11 +52993,11 @@ async function _councilEstimateHandler(args, consumerRoot) {
     throw new Error("'depth' must be 'shallow' or 'deep' when provided");
   }
   const root = _resolvePath2(consumerRoot);
-  const target = path73.isAbsolute(inputRaw) ? _resolvePath2(inputRaw) : _resolvePath2(path73.join(root, inputRaw));
+  const target = path75.isAbsolute(inputRaw) ? _resolvePath2(inputRaw) : _resolvePath2(path75.join(root, inputRaw));
   if (_relativeUnder(target, root) === null) {
     throw new Error(`path escapes consumer_root: ${target}`);
   }
-  if (!fs77.existsSync(target)) {
+  if (!fs79.existsSync(target)) {
     throw new Error(`input_path not found: ${target}`);
   }
   const cli = await Promise.resolve().then(() => (init_council_cli(), council_cli_exports));
@@ -52075,18 +53059,18 @@ async function _runTestsHandler(args, consumerRoot) {
     if (typeof relPathRaw !== "string" || !_strip8(relPathRaw)) {
       throw new Error("'path' must be a non-empty string when provided");
     }
-    const resolved = path73.isAbsolute(relPathRaw) ? _resolvePath2(relPathRaw) : _resolvePath2(path73.join(root, relPathRaw));
+    const resolved = path75.isAbsolute(relPathRaw) ? _resolvePath2(relPathRaw) : _resolvePath2(path75.join(root, relPathRaw));
     const rel = _relativeUnder(resolved, root);
     if (rel === null) {
       throw new Error(`path escapes consumer_root: ${resolved}`);
     }
-    if (!fs77.existsSync(resolved)) {
+    if (!fs79.existsSync(resolved)) {
       throw new Error(`path not found: ${resolved}`);
     }
     relArg = rel;
   }
-  const vitestEntry = path73.join(root, "node_modules", "vitest", "vitest.mjs");
-  if (!fs77.existsSync(vitestEntry)) {
+  const vitestEntry = path75.join(root, "node_modules", "vitest", "vitest.mjs");
+  if (!fs79.existsSync(vitestEntry)) {
     throw new Error(
       "run_tests pilot supports vitest projects only \u2014 node_modules/vitest/vitest.mjs not found under consumer_root"
     );
@@ -52191,7 +53175,55 @@ async function _readResourceBodyHandler(args, consumerRoot) {
     body: resource.body
   };
 }
+async function _suggestSkillForTaskHandler(args, consumerRoot) {
+  const task = typeof args["task"] === "string" ? args["task"] : "";
+  if (task.trim() === "") {
+    return { status: "error", error: "task must be a non-empty string", suggestions: [] };
+  }
+  const limitRaw = args["limit"];
+  const limit = typeof limitRaw === "number" && Number.isFinite(limitRaw) ? Math.floor(limitRaw) : 5;
+  const catalogue = await Promise.resolve().then(() => (init_skill_catalogue(), skill_catalogue_exports));
+  const skillsDir = catalogue.resolveSkillsRoot(consumerRoot);
+  if (skillsDir === null) {
+    return {
+      status: "no_catalogue",
+      searched: [...catalogue.DEFAULT_CATALOGUE_ROOTS],
+      consumer_root: consumerRoot,
+      suggestions: []
+    };
+  }
+  const { rank: rank2 } = await Promise.resolve().then(() => (init_score_skill_relevance(), score_skill_relevance_exports));
+  const rows = rank2(task, skillsDir).slice(0, Math.max(1, limit));
+  return {
+    status: "ok",
+    skills_root: skillsDir,
+    suggestions: rows.map(([name, score, personas]) => ({ skill: name, score, personas }))
+  };
+}
 var ALLOWLIST = {
+  suggest_skill_for_task: {
+    name: "suggest_skill_for_task",
+    side_effect: "ro",
+    description: "Match a free-form task description to the most relevant skills, ranked by a deterministic keyword scorer over SKILL.md frontmatter. Use when a skill you need is not in the catalogue the host delivered \u2014 a measured host dropped 402 entries from its model-visible list \u2014 so asking by name is impossible while asking by task is not. Read-only: no shell, no writes, and no skill bodies are returned, only names, scores and declared personas.",
+    input_schema: {
+      type: "object",
+      required: ["task"],
+      properties: {
+        task: {
+          type: "string",
+          description: "Free-form description of the task to match skills against."
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          default: 5,
+          description: "Maximum number of skills to return. Defaults to 5."
+        }
+      },
+      additionalProperties: false
+    },
+    handler: _suggestSkillForTaskHandler
+  },
   lint_skills: {
     name: "lint_skills",
     side_effect: "ro",
@@ -52692,8 +53724,8 @@ function _strCmp3(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 function _pathlibCompare3(a, b) {
-  const pa = a.split(path73.sep);
-  const pb = b.split(path73.sep);
+  const pa = a.split(path75.sep);
+  const pb = b.split(path75.sep);
   const n = Math.min(pa.length, pb.length);
   for (let i = 0; i < n; i++) {
     const c = _strCmp3(pa[i], pb[i]);
@@ -52912,18 +53944,18 @@ async function _serveOverSdk(server) {
   const transport = new StdioServerTransport();
   await sdkServer.connect(transport);
 }
-function main35() {
+function main36() {
   void run_stdio();
 }
 
 // src/scripts/mcp_server/__main__.ts
-var _selfPath = fileURLToPath47(import.meta.url);
-var _invokedDirectly2 = globalThis.__AC_MCP_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path74.resolve(process.argv[1]) === path74.resolve(_selfPath);
+var _selfPath = fileURLToPath48(import.meta.url);
+var _invokedDirectly2 = globalThis.__AC_MCP_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path76.resolve(process.argv[1]) === path76.resolve(_selfPath);
 if (_invokedDirectly2) {
-  main35();
+  main36();
 }
 export {
-  main35 as main
+  main36 as main
 };
 /*! Bundled license information: