@event4u/agent-config 16.0.0 → 16.2.0

package/src/scripts/lint_roadmap_blockers.ts

@@ -3,7 +3,8 @@
  * Hard-gate linter for the roadmap `## Blockers` contract
  * (`templates/roadmaps.md` rule 20 / `roadmap-ci-steps-policy` siblings).
  *
- * Validates, for every active roadmap under `agents/roadmaps/*.md`:
+ * Validates, for every active roadmap and every parked idea one directory
+ * down in `stubs/`:
  *
  *   1. Every `### blocker: <id>` entry declares all five required fields
  *      (Status, Owner, Blocks, What to do, Resolved when).
@@ -22,16 +23,71 @@
  *      road-to-asked-not-parked exists to stop; without this field a marker
  *      cannot distinguish a declined decision from an unoffered one.
  *
- *      HARD, not ratcheted, and it can be: no active roadmap carries a real
- *      checkbox annotation today, so on the day it ships the rule fires on
- *      nothing — the same "no backlog to grandfather" argument the `Class:`
- *      contract above makes. `later/` and `archive/` are outside this gate's
- *      glob and are untouched by it.
+ *      HARD, not ratcheted, and it can be: no file in scope carries a real
+ *      checkbox annotation pointing at a blocker today, so on the day it ships
+ *      the rule fires on nothing — the same "no backlog to grandfather"
+ *      argument the `Class:` contract above makes. Re-measured when `stubs/`
+ *      entered scope on 2026-09-28: 7 stubs carry checkboxes and 0 of them
+ *      carry a `blocked-by:` marker, so the rule stays latent there too.
+ *      `later/`, `archive/` and `skipped/` are outside this gate's glob and
+ *      are untouched by it; `stubs/` is inside it — see § SCOPE.
+ *
+ *   5. An entry that declares `- **Ownership:**` declares one of the three
+ *      OWNER-OWNED classes (`product-owned`, `business-owned`,
+ *      `destructive-owned`). A technical class there is a judgement call
+ *      parked in a file instead of closed, which is the shape ADR-268 § 10
+ *      retires: a technical decision does not become owner-owned because it is
+ *      hard, so it routes back through the closure pass rather than into
+ *      `## Blockers`.
+ *
+ *      HARD rather than ratcheted, on the same "no backlog to grandfather"
+ *      argument the `Class:` contract makes: `Ownership:` is a new opt-in
+ *      field, so on the day it ships no entry in the tree declares one and the
+ *      rule fires on nothing.
+ *
+ * SCOPE — the active tree plus `stubs/`, and deliberately nothing else.
+ *
+ * Widened from the active tree alone by an owner ruling on 2026-09-28. Before
+ * it, a stub's hold was unreachable by every blocker gate: a parked idea is
+ * where a hold sits LONGEST, so excluding it exempted exactly the entries most
+ * likely to rot. The rejected alternative was to keep the scope and reword the
+ * acceptance criterion that named this gate — refused because a criterion
+ * edited to match what was achieved stops being an acceptance test.
+ *
+ * Measured on the tree the widening shipped against: 121 files under `stubs/`
+ * (120 stubs plus the directory README), of which 6 carry a `### blocker:`
+ * heading and 4 declare one open inside a `## Blockers` section. Zero hard
+ * violations, zero additions to the decidability ratchet, zero new
+ * active/archived overlaps. So it lands on nothing — the same "no backlog to
+ * grandfather" argument the `Class:` and `Ownership:` contracts make.
+ *
+ * REACH, stated honestly, because the obvious reading of the paragraph above
+ * is wrong: this does NOT hold every future stub blocker to the contract. Both
+ * scanners require the entry to sit under a `## Blockers` heading, and 2 of
+ * today's 6 put it under `## State` instead — so a third of the population is
+ * in the glob and still unread. Stub headings are free-form, unlike the
+ * template-driven roadmaps this gate was written for, so that is the likely
+ * shape rather than an edge case. Widening the glob fixes WHERE the gate looks
+ * and not WHAT it can parse; the second half is the sibling defect recorded in
+ * `stubs/road-to-blocker-parse-visibility.md`, and it is untouched here.
+ *
+ * `later/`, `archive/` and `skipped/` stay OUT, and the reason is not symmetry:
+ * those record decisions already taken (parked, closed, dropped), so a blocker
+ * left unresolved there is history rather than debt. A stub records a decision
+ * still to take. The polarity is pinned in both directions by
+ * `tests/scripts/lint_roadmap_blockers.test.ts` § the scanned scope, so
+ * widening further cannot happen by accident.
+ *
+ * One consequence worth naming rather than discovering: `_archiveOverlap`
+ * defaults its ACTIVE corpus to this glob, so a stub declaring a blocker open
+ * that an archived roadmap also declares open now fails. That is the same
+ * self-contradiction the assertion already caught one directory up, and it
+ * measured 0 on the widening tree.
  *
  * Fenced code blocks are stripped before scanning so a roadmap that shows
  * the `## Blockers` shape as a documentation example is not flagged.
  *
- * Exit codes: 0 = clean / no active roadmaps, 1 = violations.
+ * Exit codes: 0 = clean / nothing in scope, 1 = violations.
  */
 
 import * as fs from 'node:fs';
@@ -45,7 +101,14 @@ const _HERE = fileURLToPath(import.meta.url);
 const QUIET = process.argv.slice(2).includes('--quiet');
 
 const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
-const ROADMAP_GLOB = 'agents/roadmaps/*.md';
+/**
+ * The scanned scope, for display. Two plain globs rather than one brace
+ * expression: nothing globs with this string, and a `{,stubs/}` empty
+ * alternative is bash-only syntax that would mislead anyone who tried.
+ */
+const ROADMAP_GLOB = 'agents/roadmaps/*.md + agents/roadmaps/stubs/*.md';
+/** The one subdirectory inside the glob. See § SCOPE for why only this one. */
+const SCANNED_SUBDIRS: readonly string[] = ['stubs'];
 
 const FENCED_CODE_RE = /^[ \t]*```[^\n]*\n[\s\S]*?^[ \t]*```[ \t]*$/gm;
 const BLOCKERS_SECTION_RE = /^##[ \t]+Blockers[ \t]*$/im;
@@ -107,6 +170,29 @@ const KNOWN_CLASSES: ReadonlySet<string> = new Set(['0', '1', '2', '3']);
 /** The classes whose whole claim is that an agent can execute them. */
 const RUNNABLE_CLASSES: ReadonlySet<string> = new Set(['0', '1']);
 
+/**
+ * The ownership axis, as a blocker may declare it.
+ *
+ * Only the three owner-owned classes are legal here. A blocker IS the record
+ * of a decision the agent correctly did not own; a technical class in that
+ * field says the opposite — that something the ownership ladder can close was
+ * filed instead. The remaining five ownership classes are deliberately absent
+ * rather than listed as "also accepted".
+ */
+const OWNERSHIP_FIELD_RE = /^-[ \t]*\*\*Ownership:\*\*[ \t]*`?([a-z-]+)`?/im;
+const OWNER_OWNED_CLASSES: ReadonlySet<string> = new Set([
+    'product-owned',
+    'business-owned',
+    'destructive-owned',
+]);
+const TECHNICAL_CLASSES: ReadonlySet<string> = new Set([
+    'deterministic',
+    'reversible-technical',
+    'contested-technical',
+    'critical-technical',
+    'spend-exhaustion',
+]);
+
 /**
  * The authored class, or `''` when the entry declares none.
  *
@@ -248,6 +334,28 @@ function _scanBoth(rawText: string): ScanResult {
                         });
                     }
                 }
+                const ownership = OWNERSHIP_FIELD_RE.exec(body);
+                if (ownership !== null) {
+                    const declared = ownership[1] as string;
+                    if (TECHNICAL_CLASSES.has(declared)) {
+                        violations.push({
+                            line: _lineAt(text, sectionStart + cur.start),
+                            message:
+                                `blocker '${cur.id}' declares ownership '${declared}', which is ` +
+                                'a technical class — a technical decision does not become ' +
+                                'owner-owned because it is hard (ADR-268 § 10). Route it back ' +
+                                'through the closure pass and record the answer as a ' +
+                                '`## Decisions` row instead of parking it here',
+                        });
+                    } else if (!OWNER_OWNED_CLASSES.has(declared)) {
+                        violations.push({
+                            line: _lineAt(text, sectionStart + cur.start),
+                            message:
+                                `blocker '${cur.id}' declares unknown ownership '${declared}' ` +
+                                '(expected product-owned, business-owned or destructive-owned)',
+                        });
+                    }
+                }
                 const gaps = DECIDABILITY_FIELDS.filter(([, re]) => !re.test(body)).map(
                     ([name]) => name,
                 );
@@ -312,13 +420,14 @@ function _scanBoth(rawText: string): ScanResult {
     return { hard: violations, decidability };
 }
 
-/** Sorted `agents/roadmaps/*.md` (non-recursive — active roadmaps only). */
-function _globRoadmaps(): string[] {
-    const dir = path.join(REPO_ROOT, 'agents', 'roadmaps');
+/** Sorted `*.md` directly inside `dir` — never recursive. */
+function _globFlat(dir: string): string[] {
     let entries: fs.Dirent[];
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
     } catch {
+        // A missing directory is not an error: `stubs/` is optional, and the
+        // dead-scope assertion in `main` is what catches a MOVED root.
         return [];
     }
     const out: string[] = [];
@@ -330,6 +439,21 @@ function _globRoadmaps(): string[] {
     return out.sort();
 }
 
+/**
+ * The files this gate judges: active roadmaps, plus `stubs/`. See § SCOPE.
+ *
+ * Takes its root so the scope can be driven from a fixture tree. Asserting the
+ * rule against the real tree would only restate today's file list; the test
+ * pins which DIRECTORIES are in and which are out, in both directions.
+ */
+function _globRoadmaps(roadmapRoot: string = path.join(REPO_ROOT, 'agents', 'roadmaps')): string[] {
+    const out = _globFlat(roadmapRoot);
+    for (const sub of SCANNED_SUBDIRS) {
+        out.push(..._globFlat(path.join(roadmapRoot, sub)));
+    }
+    return out;
+}
+
 function _relPosix(target: string, root: string): string {
     return path.relative(root, target).split(path.sep).join('/');
 }
@@ -503,7 +627,7 @@ function main(): number {
     const roadmaps = _globRoadmaps();
     if (roadmaps.length === 0) {
         if (!QUIET) {
-            process.stdout.write(`✅  no active roadmaps under ${ROADMAP_GLOB}\n`);
+            process.stdout.write(`✅  nothing in scope under ${ROADMAP_GLOB}\n`);
         }
         return 0;
     }
@@ -628,10 +752,13 @@ if (_isCliEntry() || process.argv[1] === _HERE) {
 export {
     REPO_ROOT,
     ROADMAP_GLOB,
+    _stripFencedCode,
     REQUIRED_FIELDS,
     DECIDABILITY_FIELDS,
     KNOWN_CLASSES,
     RUNNABLE_CLASSES,
+    OWNER_OWNED_CLASSES,
+    TECHNICAL_CLASSES,
     _blockerClass,
     _hasExecutableSubstance,
     _scan,

package/src/scripts/lint_roadmap_producers.ts

@@ -0,0 +1,202 @@
+#!/usr/bin/env tsx
+/**
+ * Every roadmap producer ends in closure — mechanically, not by convention.
+ *
+ * A command that produces a plan and hands it back with open decisions in it
+ * has moved those decisions into execution, where meeting one costs a run.
+ * The entrance list used to be hard-coded in three command bodies, so the
+ * other six producers were simply not in it and nothing said so.
+ *
+ * The declaration is now the command's own: `produces_roadmap: true` in the
+ * frontmatter. This gate reds a command that declares it and does not end in
+ * the closure pass, which is the half a hard-coded list could never check.
+ *
+ * What counts as ending in closure: the body references the closure pass by
+ * one of its two names — the `/challenge-me closure` sub-command, or the
+ * `closure_scan` detector it runs. Deliberately a reference check rather than
+ * a prose check: prose drifts, and a gate that guesses at intent from wording
+ * is the detector that gets weakened until it finds nothing.
+ *
+ * Exit codes: 0 clean · 1 violations · 2 internal error / bad argv.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const _PROG = 'lint_roadmap_producers';
+
+/** The frontmatter declaration a producer carries. */
+export const DECLARATION_RE = /^produces_roadmap:\s*true\s*$/m;
+
+/** Either name of the closure pass discharges the obligation. */
+export const CLOSURE_REFS: readonly RegExp[] = [
+    /\/challenge-me\s+closure/,
+    /challenge-me\/closure/,
+    /\bclosure_scan\b/,
+];
+
+export interface Violation {
+    readonly file: string;
+    readonly reason: string;
+}
+
+function _frontmatter(text: string): string {
+    if (!text.startsWith('---')) return '';
+    const end = text.indexOf('\n---', 3);
+    return end < 0 ? '' : text.slice(0, end);
+}
+
+export function declaresProducer(text: string): boolean {
+    return DECLARATION_RE.test(_frontmatter(text));
+}
+
+export function endsInClosure(text: string): boolean {
+    return CLOSURE_REFS.some((re) => re.test(text));
+}
+
+export function checkFile(rel: string, text: string): Violation[] {
+    if (!declaresProducer(text)) return [];
+    if (endsInClosure(text)) return [];
+    return [
+        {
+            file: rel,
+            reason:
+                'declares `produces_roadmap: true` and does not end in the closure pass — ' +
+                'a producer hands back an execution contract, not a plan with open decisions ' +
+                'in it. Reference `/challenge-me closure` (or the `closure_scan` detector) ' +
+                'as the command’s last step.',
+        },
+    ];
+}
+
+function _walk(dir: string, out: string[]): void {
+    let entries: fs.Dirent[];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+        return;
+    }
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) _walk(full, out);
+        else if (e.isFile() && e.name === 'command.md') out.push(full);
+    }
+}
+
+export function listCommands(root: string): string[] {
+    const out: string[] = [];
+    _walk(root, out);
+    return out;
+}
+
+function _repoRoot(): string {
+    return path.resolve(path.dirname(_HERE), '..', '..');
+}
+
+function _usage(): string {
+    return (
+        `usage: ${_PROG} [-h] [--quiet] [--json] [--self-test]\n\n` +
+        `Every command declaring \`produces_roadmap: true\` ends in the closure pass.\n`
+    );
+}
+
+export function main(argv?: readonly string[]): number {
+    const args = argv ?? process.argv.slice(2);
+    let quiet = false;
+    let json = false;
+    let selfTest = false;
+    const unknown: string[] = [];
+    for (const a of args) {
+        if (a === '-h' || a === '--help') {
+            process.stdout.write(_usage());
+            return 0;
+        } else if (a === '--quiet') quiet = true;
+        else if (a === '--json') json = true;
+        else if (a === '--self-test') selfTest = true;
+        else unknown.push(a);
+    }
+    if (unknown.length) {
+        process.stderr.write(`${_usage()}${_PROG}: error: unrecognized arguments: ${unknown.join(' ')}\n`);
+        return 2;
+    }
+    if (selfTest) return _selfTest();
+
+    const repo = _repoRoot();
+    const root = path.join(repo, 'src', 'domains');
+    const files = listCommands(root);
+    const producers = files.filter((f) => declaresProducer(fs.readFileSync(f, 'utf-8')));
+
+    try {
+        // The corpus is the DECLARED producers, not every command: a tree where
+        // nobody declares the key is a tree where the declaration was lost, and
+        // that is exactly the silent-disarm this assertion exists to catch.
+        assertScanned({
+            gate: _PROG,
+            scanned: producers.length,
+            units: 'roadmap producer(s)',
+            roots: ['src/domains'],
+        });
+    } catch (e) {
+        if (e instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${e.message}\n`);
+            return 2;
+        }
+        throw e;
+    }
+
+    const violations: Violation[] = [];
+    for (const f of producers) {
+        violations.push(...checkFile(path.relative(repo, f), fs.readFileSync(f, 'utf-8')));
+    }
+
+    if (json) {
+        process.stdout.write(JSON.stringify(violations, null, 2) + '\n');
+        return violations.length ? 1 : 0;
+    }
+    if (violations.length) {
+        process.stderr.write(`❌  ${_PROG}: ${violations.length} producer(s) do not end in closure\n`);
+        for (const v of violations) process.stderr.write(`   ${v.file} — ${v.reason}\n`);
+        return 1;
+    }
+    if (!quiet) {
+        process.stdout.write(
+            `✅  ${_PROG}: ${producers.length} roadmap producer(s), all ending in closure\n`,
+        );
+    }
+    return 0;
+}
+
+/** Both directions in-process: a producer without closure reds, one with it does not. */
+function _selfTest(): number {
+    const withClosure = '---\nname: x\nproduces_roadmap: true\n---\n\nRun `/challenge-me closure`.\n';
+    const without = '---\nname: x\nproduces_roadmap: true\n---\n\nHand the plan back.\n';
+    const notAProducer = '---\nname: x\n---\n\nHand the plan back.\n';
+    const failures: string[] = [];
+    if (checkFile('a.md', without).length === 0) failures.push('a producer without closure did not red');
+    if (checkFile('b.md', withClosure).length !== 0) failures.push('a producer with closure red');
+    if (checkFile('c.md', notAProducer).length !== 0) failures.push('a non-producer was judged');
+    if (failures.length) {
+        for (const f of failures) process.stderr.write(`❌  ${_PROG} --self-test: ${f}\n`);
+        return 1;
+    }
+    process.stdout.write(`✅  ${_PROG} --self-test: both directions hold\n`);
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    if (!process.argv[1]) return false;
+    try {
+        return fs.realpathSync(_HERE) === fs.realpathSync(path.resolve(process.argv[1]));
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry() || process.argv[1] === _HERE) {
+    process.exitCode = main();
+}

package/src/scripts/lint_skill_descriptions.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S node --import tsx
+#!/usr/bin/env tsx
 /**
  * lint_skill_descriptions — description-quality gate (ecosystem-harvest
  * skill-quality-gates, Phase 1).

package/src/scripts/lint_skill_scripts_readonly.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S node --import tsx
+#!/usr/bin/env tsx
 /**
  * lint_skill_scripts_readonly — read-only-by-default script convention
  * (ecosystem-harvest skill-quality-gates, Phase 3).

package/src/scripts/mcp_server/prompts.ts

@@ -69,6 +69,22 @@ export interface SkillPrompt {
     readonly kind: PromptKind;
     readonly recommended_for_user_types: readonly string[];
     readonly user_type_match: UserTypeMatch;
+    /**
+     * Declared parameters, from the frontmatter `inputs:` block.
+     *
+     * Empty for every artifact that declares none, which is the whole corpus
+     * today — so `arguments: []` on the wire stays the behaviour for an
+     * undeclared prompt rather than becoming a special case
+     * (road-to-an-invocation-contract-that-reaches-the-wire 3.2).
+     */
+    readonly inputs: readonly PromptInput[];
+}
+
+/** One declared parameter, reduced to what the MCP `arguments` shape carries. */
+export interface PromptInput {
+    readonly name: string;
+    readonly description: string;
+    readonly required: boolean;
 }
 
 /** Walk up from this file to the repo root (parent of `scripts/`). */
@@ -92,6 +108,124 @@ export function _project_root(): string {
  * Avoids a YAML dependency for Phase 1; the frontmatter shape is
  * enforced by `task lint-skills` upstream.
  */
+/** The raw frontmatter block of a document, or `''` when it has none. */
+export function _frontmatter_text(text: string): string {
+    if (!text.startsWith('---\n')) return '';
+    const parts = _splitMax(text, '---\n', 2);
+    return parts.length < 3 ? '' : (parts[1] as string);
+}
+
+/**
+ * Parse the frontmatter `inputs:` block out of raw frontmatter text.
+ *
+ * WHY THIS EXISTS RATHER THAN A YAML CALL. `_strip_frontmatter` is a flat
+ * `key: value` line scanner and cannot represent a nested list — `inputs:`
+ * would land as an empty string and its `- name: x` lines as stray keys. The
+ * MCP server is deliberately stdlib-only and is bundled for the wire, so
+ * pulling a YAML parser in to read one optional block would pay a dependency
+ * on every install for a block almost nothing declares yet.
+ *
+ * IT READS ONE SHAPE AND REFUSES THE REST. Accepted:
+ *
+ *     inputs:
+ *       - name: target
+ *         type: string
+ *         required: true
+ *         description: What to act on.
+ *
+ * Refused, by yielding NOTHING for the whole block: the flow form
+ * (`inputs: [{name: a}]`), a block scalar (`description: >`), and any nested
+ * mapping under an item key. Refusing is not silent — `check_inputs_parity`
+ * compares this reader against a real YAML parse for every declaring artifact
+ * and FAILS the build on any difference, so an unsupported form is a red gate
+ * with a named remedy rather than a wrong argument on the wire.
+ *
+ * That gate is the answer to the defect an independent review found here: the
+ * key scan used to run at any depth, so a `default:` MAPPING whose first child
+ * was `name:` overwrote the parameter's own name and the server offered a host
+ * an argument that did not exist. The header promised "no guessed input" while
+ * the code guessed. Depth is now tracked, and where this reader cannot be sure
+ * it declines and the parity gate makes the decline visible.
+ */
+export function _parse_inputs(fm: string): PromptInput[] {
+    const lines = fm.split('\n');
+    let i = lines.findIndex((l) => /^inputs:/.test(l));
+    if (i === -1) return [];
+    // The flow form carries its payload on the `inputs:` line itself. This
+    // reader does not parse it; the parity gate turns that into a failure.
+    if (!/^inputs:\s*$/.test(lines[i] as string)) return [];
+
+    const out: PromptInput[] = [];
+    let current: { name?: string; description?: string; required?: boolean } | null = null;
+    /** Indent of the key lines belonging to the item being read. */
+    let keyIndent: number | null = null;
+    let refused = false;
+
+    const flush = (): void => {
+        if (current?.name !== undefined) {
+            out.push({
+                name: current.name,
+                description: current.description ?? '',
+                required: current.required === true,
+            });
+        }
+        current = null;
+    };
+
+    const clean = (raw: string): string => {
+        const v = raw.trim();
+        // An unquoted trailing comment is not part of the value — the same strip
+        // `_strip_frontmatter` applies, kept consistent deliberately.
+        const hashed = /^(?!["'])([^#]*?)\s+#.*$/.exec(v);
+        return _stripQuotes((hashed === null ? v : (hashed[1] ?? '')).trim());
+    };
+
+    for (i += 1; i < lines.length && !refused; i += 1) {
+        const line = lines[i] as string;
+        if (line.trim() === '') continue;
+        // A comment at any column is not block content and does not end the block.
+        if (/^\s*#/.test(line)) continue;
+        // A non-indented line ends the block.
+        if (!/^\s/.test(line)) break;
+
+        const indent = (/^(\s*)/.exec(line) as RegExpExecArray)[1]!.replace(/\t/g, '    ').length;
+
+        const item = /^\s*-\s+([A-Za-z_]\w*):\s*(.*)$/.exec(line);
+        if (item !== null) {
+            flush();
+            current = {};
+            keyIndent = line.indexOf('-') + 2;
+            if (item[1] === 'name') current.name = clean(item[2] ?? '');
+            continue;
+        }
+
+        const kv = /^\s+([A-Za-z_]\w*):\s*(.*)$/.exec(line);
+        if (kv === null || current === null || keyIndent === null) continue;
+        // Deeper than the item's own keys: a nested mapping or sequence this
+        // reader does not model. Decline the whole block rather than absorb it.
+        if (indent > keyIndent) {
+            refused = true;
+            break;
+        }
+        const key = kv[1] as string;
+        const rawValue = (kv[2] ?? '').trim();
+        // A block scalar or an empty value means the real content is on the
+        // following lines, which this reader does not join.
+        if (rawValue === '' || rawValue === '>' || rawValue === '|') {
+            refused = true;
+            break;
+        }
+        const value = clean(rawValue);
+        if (key === 'name') current.name = value;
+        else if (key === 'description') current.description = value;
+        else if (key === 'required') current.required = value.toLowerCase() === 'true';
+    }
+
+    if (refused) return [];
+    flush();
+    return out;
+}
+
 export function _strip_frontmatter(text: string): [Record<string, string>, string] {
     if (!text.startsWith('---\n')) {
         return [{}, text];
@@ -365,6 +499,7 @@ function _load_file(p: string, kind: PromptKind, fallback_name: string): SkillPr
         kind,
         recommended_for_user_types: _parse_inline_array(meta.recommended_for_user_types ?? ''),
         user_type_match: '',
+        inputs: _parse_inputs(_frontmatter_text(text)),
     };
 }
 
@@ -548,7 +683,13 @@ export function to_mcp_prompt_meta(prompt: SkillPrompt): Record<string, unknown>
         name: wire,
         title: prompt.name,
         description: prompt.description,
-        arguments: [],
+        // Derived from the declaration, never invented. An artifact that
+        // declares nothing still serves `[]` — see `_parse_inputs`.
+        arguments: prompt.inputs.map((i) => ({
+            name: i.name,
+            description: i.description,
+            required: i.required,
+        })),
         _meta: meta,
     };
 }