@event4u/agent-config 16.4.0 → 17.0.0

package/src/scripts/lint_ticked_unmet_criteria.ts

@@ -9,13 +9,60 @@
  *
  * The criterion's text is the bullet line plus its indented continuation lines,
  * up to a blank line, a less-indented line or the next checkbox. Fenced code is
- * skipped, so a quoted example is not a finding. The match is the literal
- * `NOT met` — upper-case on purpose, because that is how an author marks the
- * unmet half, and a lower-case "not met" inside an explanation is prose.
+ * skipped and inline code spans are masked, so a quoted example is not a
+ * finding — a roadmap that writes ABOUT this lint quotes the phrase it hunts,
+ * and reporting the quoter is the detector reading its own name. The match is
+ * the literal `NOT met` — upper-case on purpose, because that is how an author
+ * marks the unmet half, and a lower-case "not met" inside an explanation is
+ * prose.
+ *
+ * HTML comments are masked for the same reason, one step further out: the
+ * premise above is "a contradiction a READER OF THE CHECKBOX never sees", and
+ * a comment is invisible on the rendered page, so it cannot be the text that
+ * misleads that reader. The hit this removes said "One clause of the GOAL is
+ * NOT met" — a statement about a different proposition, parked in a comment
+ * beside a criterion it does not describe.
+ *
+ * Two archived criteria preserve a dated audit of what WAS missing before the
+ * same block records its closure, which is not the glyph lying about what IS.
+ * They are exempt — through {@link HISTORICAL}, a FROZEN list in this file
+ * pinning each one by path, criterion id AND the SHA-256 of the criterion block
+ * itself. Editing an exempt block changes its digest, the entry stops matching,
+ * and the criterion is reported again.
+ *
+ * It is a frozen list rather than a marker an author types, and that is a
+ * REFUSAL honoured rather than a design preference. The first version of this
+ * exemption keyed on a `MET YYYY-MM-DD` / `CLOSED YYYY-MM-DD` marker anywhere
+ * in the block. The ratification review refused it, 1 seat of 2, and named the
+ * defect exactly: the marker is "an author-controlled suppression" — the same
+ * author whose change is under review types their own pass token, the regex
+ * accepted impossible dates, and wiring a dormant lint into CI with a bypass
+ * attached narrows the control it is supposed to add. Its own alternative is
+ * what ships here: grandfather the legitimate cases through a checked-in
+ * baseline keyed by path, criterion and content hash, and let a new or
+ * modified exception fail.
+ *
+ * An entry that matches NO criterion in the scanned tree is itself an error,
+ * so the list cannot rot into a set of dead permissions nobody reviews. That
+ * check runs only on the repository's own tree: a `--root` fixture has no
+ * archived roadmaps and would red every self-test case.
+ *
+ * What the masks still cost, stated rather than discovered later, and pinned
+ * by tests: an author who writes the unmet half inside backticks, or inside an
+ * HTML comment, escapes this lint. The bare phrase with no masking still
+ * fails, which is the case the lint exists for.
+ *
+ * On the DISPOSITION of the three archived hits the detector refinement was
+ * decided on: AI council, 2026-10-13, ONE seat of two (the second returned
+ * `os_error: ENOBUFS` and answered nothing — a one-seat reading, not
+ * convergence). Refine the detector rather than edit the archived prose,
+ * because the roadmap step's "no criterion text is reworded to clear the lint"
+ * carries no exception for a case change.
  *
  * Usage:
  *   ./scripts-run src/scripts/lint_ticked_unmet_criteria
  *   ./scripts-run src/scripts/lint_ticked_unmet_criteria --root <repo>
+ *   ./scripts-run src/scripts/lint_ticked_unmet_criteria --self-test
  *
  * Scans every `*.md` under the roadmap tree, archive included: an archived
  * roadmap is exactly where a contradictory tick outlives the session that
@@ -23,10 +70,13 @@
  *
  * Exit codes: 0 no hit · 1 at least one hit · 2 usage error.
  */
+import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { runGateCli, runSelfTest } from './_lib/gate_self_test.js';
 import { reportScanned } from './_lib/scan_scope.js';
 
 interface Hit {
@@ -44,7 +94,97 @@ function _indent(line: string): number {
     return (/^[ \t]*/.exec(line)?.[0] ?? '').length;
 }
 
-function scanText(text: string, file: string): Hit[] {
+/**
+ * Blanks the contents of every inline code span, keeping the delimiters and
+ * every newline so offsets and line structure survive.
+ *
+ * A run of N backticks opens a span that closes at the next run of exactly N.
+ * An unterminated run is literal text in markdown and masks nothing here, so a
+ * stray backtick cannot blind the scanner for the rest of a criterion.
+ */
+function maskHtmlComments(text: string): string {
+    return text.replace(/<!--[\s\S]*?-->/gu, (m) => m.replace(/[^\n]/gu, ' '));
+}
+
+/** One grandfathered criterion, pinned by content so an edit un-grandfathers it. */
+interface Historical {
+    file: string;
+    criterion: string;
+    /** SHA-256 of the criterion block, exactly as {@link scanText} joins it. */
+    sha256: string;
+    why: string;
+}
+
+/**
+ * The frozen exemption list. Add nothing here without a review that reads the
+ * block — this is the baseline the ratification review asked for in place of a
+ * marker, and a list that grows on an author's own say-so is the marker again.
+ */
+const HISTORICAL: readonly Historical[] = [
+    {
+        file: 'agents/roadmaps/archive/road-to-governed-harness-evolution.md',
+        criterion: 'AC-1',
+        sha256: '7746f218f52621c771b05696fdf56b240c6afc435618923e703dcf98d34c9d25',
+        why: 'Reads "MET 2026-08-31, and it was NOT met when this audit started" — a dated closure whose own sentence puts the unmet state in the past.',
+    },
+    {
+        file: 'agents/roadmaps/archive/road-to-governed-harness-evolution.md',
+        criterion: 'AC-5',
+        sha256: 'f78a74e4a7a3e30b81f33cc59a53c0e01f147d6ed3d7d7bcbbfc47a76e13c2fd',
+        why: 'Reads "CLOSED 2026-08-31 … The audit below is preserved"; the phrase sits 29 lines down inside that preserved audit.',
+    },
+];
+
+function blockDigest(text: string): string {
+    return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+function maskInlineCode(text: string): string {
+    let out = '';
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] !== '`') {
+            out += text[i];
+            i += 1;
+            continue;
+        }
+        let n = 0;
+        while (text[i + n] === '`') {
+            n += 1;
+        }
+        let j = i + n;
+        let close = -1;
+        while (j < text.length) {
+            if (text[j] === '`') {
+                let m = 0;
+                while (text[j + m] === '`') {
+                    m += 1;
+                }
+                if (m === n) {
+                    close = j;
+                    break;
+                }
+                j += m;
+            } else {
+                j += 1;
+            }
+        }
+        if (close === -1) {
+            out += text.slice(i, i + n);
+            i += n;
+            continue;
+        }
+        out += text.slice(i, i + n);
+        out += text
+            .slice(i + n, close)
+            .replace(/[^\n]/gu, ' ');
+        out += text.slice(close, close + n);
+        i = close + n;
+    }
+    return out;
+}
+
+function scanText(text: string, file: string, historical: Hit[] = []): Hit[] {
     const lines = text.split('\n');
     const hits: Hit[] = [];
     let inFence = false;
@@ -70,8 +210,15 @@ function scanText(text: string, file: string): Hit[] {
             }
             block.push(next);
         }
-        if (block.join('\n').includes(UNMET)) {
-            hits.push({ file, line: i + 1, criterion: m[2] as string });
+        const raw = block.join('\n');
+        const visible = maskHtmlComments(maskInlineCode(raw));
+        if (visible.includes(UNMET)) {
+            const criterion = m[2] as string;
+            const digest = blockDigest(raw);
+            const exempt = HISTORICAL.some(
+                (h) => h.file === file && h.criterion === criterion && h.sha256 === digest,
+            );
+            (exempt ? historical : hits).push({ file, line: i + 1, criterion });
         }
     }
     return hits;
@@ -96,22 +243,97 @@ function _walk(dir: string): string[] {
     return out;
 }
 
-function scanTree(root: string): { hits: Hit[]; scanned: number } {
+function scanTree(root: string): { hits: Hit[]; historical: Hit[]; scanned: number } {
     const files = _walk(path.join(root, 'agents', 'roadmaps'));
     const hits: Hit[] = [];
+    const historical: Hit[] = [];
     for (const abs of files) {
         const rel = path.relative(root, abs).split(path.sep).join('/');
-        hits.push(...scanText(fs.readFileSync(abs, 'utf8'), rel));
+        hits.push(...scanText(fs.readFileSync(abs, 'utf8'), rel, historical));
     }
-    return { hits, scanned: files.length };
+    return { hits, historical, scanned: files.length };
 }
 
 const _DEFAULT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 
+/**
+ * Four fixtures over a temporary roadmap tree, driven through the real CLI.
+ *
+ * Three of them are the three masks the detector grew, each paired with the
+ * bare case it must still reject — a suite that only proved the masks would
+ * certify a scanner that had stopped matching anything at all.
+ */
+function selfTest(): number {
+    const repoRoot = _DEFAULT_ROOT;
+    const rel = 'src/scripts/lint_ticked_unmet_criteria.ts';
+
+    const over = (body: string): (() => number) => (): number => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ticked-unmet-self-'));
+        try {
+            const roadmaps = path.join(dir, 'agents', 'roadmaps');
+            fs.mkdirSync(roadmaps, { recursive: true });
+            fs.writeFileSync(path.join(roadmaps, 'road-to-fixture.md'), body);
+            return runGateCli(repoRoot, rel, ['--root', dir], repoRoot);
+        } finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    };
+
+    return runSelfTest({
+        gate: 'lint_ticked_unmet_criteria',
+        minCases: 6,
+        minRejectCases: 4,
+        cases: [
+            {
+                name: 'a bare NOT met under a tick is rejected',
+                expect: 'reject',
+                run: over('- [x] AC-1 — One half lands. The other half is NOT met.\n'),
+            },
+            {
+                name: 'the same phrase inside backticks is accepted',
+                expect: 'accept',
+                run: over('- [x] AC-1 — The lint reports a criterion saying `NOT met`.\n'),
+            },
+            {
+                name: 'an unterminated backtick does not mask, so the bare phrase is rejected',
+                expect: 'reject',
+                run: over('- [x] AC-1 — an opening ` and then NOT met in the clear.\n'),
+            },
+            {
+                name: 'the same phrase inside an HTML comment is accepted',
+                expect: 'accept',
+                run: over('- [x] AC-1 — The gate ships.\n      <!-- the Goal clause is NOT met -->\n'),
+            },
+            {
+                name: 'a dated closure marker does NOT exempt — the exemption is a frozen digest list',
+                expect: 'reject',
+                run: over('- [x] AC-1 — Both halves land.\n      **CLOSED 2026-08-31.** First conjunct — NOT met.\n'),
+            },
+            {
+                name: 'a MET marker does not exempt either',
+                expect: 'reject',
+                run: over('- [x] AC-1 — Both halves land.\n      **MET 2026-08-31.** First conjunct — NOT met.\n'),
+            },
+            {
+                name: 'a roadmap tree with no criterion at all is accepted',
+                expect: 'accept',
+                run: over('# Road to nothing\n\nNo criteria here.\n'),
+            },
+        ],
+    });
+}
+
 function main(argv: string[] = process.argv.slice(2)): number {
     let root = _DEFAULT_ROOT;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
+        if (arg === '--self-test') {
+            if (process.env['GATE_SELF_TEST_CHILD'] === '1') {
+                process.stderr.write('lint_ticked_unmet_criteria: --self-test does not recurse\n');
+                return 2;
+            }
+            return selfTest();
+        }
         if (arg === '--root') {
             const v = argv[i + 1];
             if (v === undefined) {
@@ -125,7 +347,7 @@ function main(argv: string[] = process.argv.slice(2)): number {
             return 2;
         }
     }
-    const { hits, scanned } = scanTree(root);
+    const { hits, historical, scanned } = scanTree(root);
     reportScanned({
         gate: 'lint_ticked_unmet_criteria',
         scanned,
@@ -133,18 +355,75 @@ function main(argv: string[] = process.argv.slice(2)): number {
         roots: ['agents/roadmaps'],
         allowEmpty: 'EMPTY_VALID: a checkout with no roadmap has no criterion to tick',
     });
-    if (hits.length === 0) {
-        process.stdout.write(`✅  lint_ticked_unmet_criteria: ${String(scanned)} roadmap file(s), no criterion ticked over "${UNMET}".\n`);
-        return 0;
+    // Named, not merely counted: an exemption nobody can enumerate is a
+    // suppression surface however narrow its key is.
+    for (const h of historical) {
+        process.stdout.write(`   exempt (grandfathered): ${h.file}:${String(h.line)} · ${h.criterion}\n`);
     }
-    process.stderr.write(
-        `❌  lint_ticked_unmet_criteria: ${String(hits.length)} criterion/criteria ticked [x] over their own "${UNMET}":\n`,
-    );
-    for (const h of hits) {
-        process.stderr.write(`  ${h.file}:${String(h.line)} · ${h.criterion}\n`);
+    // A frozen list has one failure mode a marker does not: an entry that
+    // matches nothing is a dead permission nobody re-reads. Checked on the
+    // repository's own tree only — a `--root` fixture carries none of these
+    // files and would red every self-test case.
+    //
+    // Reported ALONGSIDE the hits rather than instead of them: an entry goes
+    // stale exactly when its block was edited, and an edited block is usually
+    // also a new hit. Returning early here would print the bookkeeping failure
+    // and hide the criterion it was covering.
+    const key = (h: { file: string; criterion: string }): string => `${h.file}\u0000${h.criterion}`;
+    const matched = new Set(historical.map(key));
+    const stale = root === _DEFAULT_ROOT ? HISTORICAL.filter((h) => !matched.has(key(h))) : [];
+
+    // Uniqueness, checked rather than assumed. The stale scan above collapses
+    // entries into a Set keyed by file and criterion, so two entries for one
+    // criterion — the second with a wrong digest, say — would both read as
+    // matched the moment either one did. Not a bypass today, because a
+    // criterion is exempt only on its own digest; it is a way the list could
+    // stop meaning what it reads as, which is the property the list exists for.
+    const seen = new Set<string>();
+    const duplicates = HISTORICAL.filter((h) => {
+        const k = key(h);
+        if (seen.has(k)) return true;
+        seen.add(k);
+        return false;
+    });
+    if (duplicates.length > 0) {
+        process.stderr.write(
+            `❌  lint_ticked_unmet_criteria: ${String(duplicates.length)} duplicate grandfathered key(s). ` +
+                'One criterion carries at most one entry — two entries for one key make the second unreadable:\n',
+        );
+        for (const h of duplicates) {
+            process.stderr.write(`  ${h.file} · ${h.criterion}\n`);
+        }
+        return 1;
     }
-    process.stderr.write('\n    The unmet half is a deferral: use `[~]` and carry it, or meet it.\n');
-    return 1;
+
+    if (hits.length > 0) {
+        process.stderr.write(
+            `❌  lint_ticked_unmet_criteria: ${String(hits.length)} criterion/criteria ticked [x] over their own "${UNMET}":\n`,
+        );
+        for (const h of hits) {
+            process.stderr.write(`  ${h.file}:${String(h.line)} · ${h.criterion}\n`);
+        }
+        process.stderr.write('\n    The unmet half is a deferral: use `[~]` and carry it, or meet it.\n');
+    }
+    if (stale.length > 0) {
+        process.stderr.write(
+            `❌  lint_ticked_unmet_criteria: ${String(stale.length)} grandfathered entry/entries matched nothing. ` +
+                'The block was edited, moved or deleted, so the exemption no longer describes it — ' +
+                'remove the entry, or re-read the block and re-pin its digest:\n',
+        );
+        for (const h of stale) {
+            process.stderr.write(`  ${h.file} · ${h.criterion} · ${h.sha256}\n`);
+        }
+    }
+    if (hits.length > 0 || stale.length > 0) {
+        return 1;
+    }
+    process.stdout.write(
+        `✅  lint_ticked_unmet_criteria: ${String(scanned)} roadmap file(s), ` +
+            `no criterion ticked over "${UNMET}" (${String(historical.length)} grandfathered by digest).\n`,
+    );
+    return 0;
 }
 
 if (process.argv[1] !== undefined) {
@@ -161,5 +440,5 @@ if (process.argv[1] !== undefined) {
     }
 }
 
-export { scanText, scanTree, main };
+export { HISTORICAL, maskHtmlComments, maskInlineCode, scanText, scanTree, main };
 export type { Hit };

package/src/scripts/mcp_registry_submit.sh

@@ -191,8 +191,8 @@ EOF
 echo ""
 echo "✅  PR opened: $PR_URL"
 echo ""
-echo "Next step: update docs/distribution/registry-submissions.md row 1"
-echo "  → status: pending → submitted"
+echo "Next step: add a new attempt row (1c, 1d, ...) to docs/distribution/registry-submissions.md"
+echo "  → status: submitted, upstream kind: github-pr, last read: today"
 echo "  → PR link: $PR_URL"
 
 exit 0

package/src/scripts/mcp_server/consumer_tool_catalog.json

@@ -747,7 +747,7 @@
     },
     {
       "name": "suggest_skill_for_task",
-      "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 — a measured host dropped 402 entries from its model-visible list — 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.",
+      "description": "Rank skills against a free-form task by deterministic keyword scoring over SKILL.md frontmatter. Use when the skill you need is absent from the host's catalogue — one measured host dropped 402 entries from its model-visible list — so asking by name is impossible and asking by task is not. Each row gives a name, score, personas and the skill's own description, its routing criteria including any clause pointing elsewhere. Choose by reading the rows, then open at most two bodies with read_skill. Read-only: no shell, no writes, no bodies.",
       "side_effect": "ro",
       "implemented_on": [
         "stdio"
@@ -760,13 +760,13 @@
         "properties": {
           "task": {
             "type": "string",
-            "description": "Free-form description of the task to match skills against."
+            "description": "The task to match skills against."
           },
           "limit": {
             "type": "integer",
             "minimum": 1,
-            "default": 5,
-            "description": "Maximum number of skills to return. Defaults to 5."
+            "default": 8,
+            "description": "Maximum skills to return; the default is a pre-registered recall depth, not a round number."
           }
         },
         "additionalProperties": false

package/src/scripts/mcp_server/suggest_skill.ts

@@ -12,6 +12,12 @@
  * of the skill-catalogue resolver on the server side.
  */
 
+import { DEFAULT_SUGGEST_LIMIT } from '../../shared/skillRanking.js';
+// TYPE-only, so the `tools.ts` <-> this cycle is erased at runtime: the
+// allowlist spreads the entry below in, and the entry names the shape the
+// allowlist declares. A value import either way would be a real cycle.
+import type { BuiltinTool } from './tools.js';
+
 /**
  * `suggest_skill_for_task` — the recovery path for a truncated catalogue.
  *
@@ -42,7 +48,9 @@ export async function suggestSkillForTask(
     // caller for cosmetic reasons.
     const limitRaw = args['limit'];
     const limit =
-        typeof limitRaw === 'number' && Number.isFinite(limitRaw) ? Math.floor(limitRaw) : 5;
+        typeof limitRaw === 'number' && Number.isFinite(limitRaw)
+            ? Math.floor(limitRaw)
+            : DEFAULT_SUGGEST_LIMIT;
 
     const catalogue = await import('../_lib/skill_catalogue.js');
     // EVERY readable root — see `resolveSkillCatalogueRoots` on why not the first.
@@ -59,14 +67,91 @@ export async function suggestSkillForTask(
         };
     }
 
-    const { rank } = await import('../skill_tools/score_skill_relevance.js');
-    const rows = rank(task, roots).slice(0, Math.max(1, limit));
+    const { rankDetailed } = await import('../skill_tools/score_skill_relevance.js');
+    const { rows, descriptions } = rankDetailed(task, roots);
     return {
         status: 'ok',
         // `skills_root` kept verbatim (a consumer may read it); `skills_roots` is
         // the additive truth about what was actually ranked.
         skills_root: roots[0] as string,
         skills_roots: roots,
-        suggestions: rows.map(([name, score, personas]) => ({ skill: name, score, personas })),
+        // `description` rides with the row because a NAME is not a choosing
+        // criterion. A caller handed five names either guesses or opens five
+        // bodies; handed five descriptions it reads the one text each skill
+        // wrote as its routing criteria — including the handoff clauses that
+        // say when NOT to use it, which only act on a reader. Each is capped at
+        // 200 characters by `skill.schema.json`, so the envelope grows by a
+        // bounded amount per row and no body is returned at any depth.
+        suggestions: rows
+            .slice(0, Math.max(1, limit))
+            .map(([name, score, personas]) => ({
+                skill: name,
+                score,
+                personas,
+                description: descriptions.get(name) ?? '',
+            })),
     };
 }
+
+/**
+ * The allowlist ENTRY, declared here rather than in `tools.ts`.
+ *
+ * Same argument the handler was extracted on, applied to its metadata. `tools.ts`
+ * sits far past the 1,500-line ceiling `check_source_size_budget` enforces as a
+ * shrink-only ratchet, so every line there costs one unit of excess and the gate
+ * names re-pinning the baseline a defect rather than a fix. Describing this tool
+ * properly — what a row now carries, and why the default depth is 8 — cost six
+ * lines there and reddened the ratchet; moving the whole entry across returns
+ * thirty-seven and puts the prose in the file that already owns the behaviour it
+ * describes.
+ *
+ * The prose below is DEDUPLICATED rather than shortened, and the distinction is
+ * worth keeping because the obvious edit is to put the words back. `mcp_schemas`
+ * is a 5%-relative ratchet against a committed baseline, and this entry read 17
+ * tokens past it. Three statements were each made twice and now are made once:
+ * the return shape (named in its own sentence AND in the read-only clause), the
+ * default depth (`default:` below AND spelled out in that field's prose), and
+ * the task's free-form-ness (the first sentence AND the `task` field). Every
+ * FACT the longer version carried is still here — the 402-entry measurement, the
+ * routing-criteria reading, the open-at-most-two rule, the read-only guarantee.
+ */
+export const SUGGEST_SKILL_TOOL: BuiltinTool = {
+    name: 'suggest_skill_for_task',
+    side_effect: 'ro',
+    description:
+        'Rank skills against a free-form task by deterministic keyword ' +
+        'scoring over SKILL.md frontmatter. Use when the skill you need ' +
+        "is absent from the host's catalogue — one measured host dropped " +
+        '402 entries from its model-visible list — so asking by name is ' +
+        'impossible and asking by task is not. ' +
+        "Each row gives a name, score, personas and the skill's own " +
+        'description, its routing criteria including any clause pointing ' +
+        // "Choose by reading the rows" rather than "Read the rows to choose":
+        // `mcp_server_tools.test.ts` pins this clause, and the gerund is what it
+        // pins. The two phrasings carry the same instruction, so the text bends
+        // to the assertion rather than the assertion to the text — an evaluator
+        // is not something the code it checks gets to edit for its own
+        // convenience. Costs one token against eight of headroom.
+        'elsewhere. Choose by reading the rows, then open at most two bodies ' +
+        'with read_skill. Read-only: no shell, no writes, no bodies.',
+    input_schema: {
+        type: 'object',
+        required: ['task'],
+        properties: {
+            task: {
+                type: 'string',
+                description: 'The task to match skills against.',
+            },
+            limit: {
+                type: 'integer',
+                minimum: 1,
+                default: DEFAULT_SUGGEST_LIMIT,
+                description:
+                    'Maximum skills to return; the default is a pre-registered ' +
+                    'recall depth, not a round number.',
+            },
+        },
+        additionalProperties: false,
+    },
+    handler: suggestSkillForTask,
+};

package/src/scripts/mcp_server/tools.ts

@@ -47,7 +47,7 @@ import {
     slice_around as _chSliceAround,
     read_header as _chReadHeaderImpl,
 } from '../chat_history.js';
-import { suggestSkillForTask } from './suggest_skill.js';
+import { SUGGEST_SKILL_TOOL } from './suggest_skill.js';
 import {
     type CatalogEntry,
     install_hint as _catalog_install_hint,
@@ -1202,38 +1202,7 @@ async function _readResourceBodyHandler(
 
 export const ALLOWLIST: Record<string, BuiltinTool> = {
     ...GRAPH_TOOLS,
-    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 — a measured host dropped 402 entries from ' +
-            'its model-visible list — 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: suggestSkillForTask,
-    },
+    suggest_skill_for_task: SUGGEST_SKILL_TOOL,
     lint_skills: {
         name: 'lint_skills',
         side_effect: 'ro',