@event4u/agent-config 14.10.0 → 14.12.0

package/dist/cli/commands/uiRender.js

@@ -0,0 +1,206 @@
+/**
+ * `agent-config ui:render <path|url>` — headless capture, then exit.
+ *
+ * Step E3.1 of `road-to-frontend-power`. Captures DOM, computed styles and a
+ * screenshot at three viewports — desktop, 375 px and 320 px — into
+ * `agents/runtime/state/render/<slug>/`, then terminates.
+ *
+ * CLASS A, and the boundary is the whole design constraint. `docs/contracts/
+ * no-runtime-boundary.md` plus ADR-124 put a *resident* browser, a dev-server
+ * bridge and a watcher in Class B, which is prohibited in core. A headless
+ * render per command is Class A because it terminates and its state is a
+ * rebuildable directory. So:
+ *
+ *   - the browser is closed in a `finally`, on every path including a throw;
+ *   - nothing is cached between invocations;
+ *   - no listener, no watch mode, no `--serve` flag exists to add one.
+ *
+ * Live-browser iteration stays out of scope (recorded as a null in R3.1). The
+ * in-scope substitute is a turn-scoped variant capture built on this command.
+ *
+ * WHY 320 px is captured: the fidelity roadmap's AC-6 asserts a 320 px floor
+ * and had no primitive to measure it with, which is why its
+ * `b-page-capture-primitive` closed as a recorded null. This supplies the
+ * primitive, so that null's own reopening condition fires.
+ *
+ * Playwright is a devDependency (`package.json:97`) and is therefore NOT
+ * guaranteed present in a consumer install. The import is dynamic and the
+ * absence path is a clean, explained exit rather than a stack trace — and it
+ * reports `verification: unverified` instead of writing an empty manifest that
+ * would read as a successful capture of nothing.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** The three viewports E3.1 names. Widths are the contract, not a preference. */
+export const VIEWPORTS = [
+    { name: 'desktop', width: 1440, height: 900 },
+    { name: 'mobile-375', width: 375, height: 812 },
+    { name: 'mobile-320', width: 320, height: 640 },
+];
+/** Computed properties captured per element — the A1.5 delta inputs, plus the overflow signals. */
+export const CAPTURED_PROPERTIES = [
+    'color',
+    'background-color',
+    'border-color',
+    'font-family',
+    'font-size',
+    'line-height',
+    'overflow-x',
+    'overflow-y',
+];
+export const RENDER_REL = path.join('agents', 'runtime', 'state', 'render');
+export function slugify(target) {
+    return (target
+        .replace(/^https?:\/\//, '')
+        .replace(/[^a-z0-9]+/gi, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase()
+        .slice(0, 60) || 'render');
+}
+/** Colour-ish computed values, normalised. Used to build the palette snapshot. */
+export function collectPalette(styleRecords) {
+    const out = new Set();
+    for (const rec of styleRecords) {
+        for (const key of ['color', 'background-color', 'border-color']) {
+            const v = (rec[key] ?? '').trim().toLowerCase();
+            if (!v || v === 'rgba(0, 0, 0, 0)' || v === 'transparent')
+                continue;
+            out.add(v);
+        }
+    }
+    return [...out].sort();
+}
+/** First-choice families only — the A1.5 threshold is about the family that wins. */
+export function collectTypeFamilies(styleRecords) {
+    const out = new Set();
+    for (const rec of styleRecords) {
+        const fam = (rec['font-family'] ?? '').split(',')[0]?.trim().replace(/^["']|["']$/g, '').toLowerCase();
+        if (fam)
+            out.add(fam);
+    }
+    return [...out].sort();
+}
+export async function runUiRender(opts) {
+    const projectRoot = path.resolve(opts.projectRoot ?? process.cwd());
+    const isUrl = /^https?:\/\//i.test(opts.target);
+    const abs = isUrl ? opts.target : path.resolve(projectRoot, opts.target);
+    if (!isUrl && !fs.existsSync(abs)) {
+        process.stderr.write(`[ui:render] path not found: ${abs}\n`);
+        return 1;
+    }
+    const slug = opts.slug ?? slugify(opts.target);
+    const outDir = path.join(projectRoot, RENDER_REL, slug);
+    let chromium;
+    try {
+        ({ chromium } = await import('@playwright/test'));
+    }
+    catch {
+        const manifest = {
+            schema: 1,
+            generated_at: new Date().toISOString(),
+            target: opts.target,
+            slug,
+            captures: [],
+            palette: [],
+            type_families: [],
+            verification: 'unverified',
+            degradation_reason: '@playwright/test is not installed — it is a devDependency, so a consumer install has no browser. ' +
+                'Install it, or scope any verdict to the static checks that actually ran.',
+        };
+        writeManifest(outDir, manifest);
+        process.stderr.write(`[ui:render] ${manifest.degradation_reason}\n`);
+        if (opts.json)
+            process.stdout.write(`${JSON.stringify(manifest, null, 2)}\n`);
+        // Exit 0, deliberately: an absent devDependency is a capability fact,
+        // not a failure of this command. The manifest carries the honest state.
+        return 0;
+    }
+    fs.mkdirSync(outDir, { recursive: true });
+    const captures = [];
+    const allStyles = [];
+    let browser = null;
+    try {
+        browser = await chromium.launch({ headless: true });
+        for (const vp of VIEWPORTS) {
+            const page = await browser.newPage({ viewport: { width: vp.width, height: vp.height } });
+            await page.goto(isUrl ? abs : `file://${abs}`, { waitUntil: 'load', timeout: 30_000 });
+            const shot = path.join(outDir, `${vp.name}.png`);
+            await page.screenshot({ path: shot, fullPage: true });
+            const dom = await page.content();
+            const domPath = path.join(outDir, `${vp.name}.dom.html`);
+            fs.writeFileSync(domPath, dom);
+            const styles = await page.evaluate((props) => {
+                const rows = [];
+                for (const el of Array.from(document.querySelectorAll('*')).slice(0, 1500)) {
+                    const cs = window.getComputedStyle(el);
+                    const rec = { selector: el.tagName.toLowerCase() };
+                    for (const p of props)
+                        rec[p] = cs.getPropertyValue(p);
+                    rows.push(rec);
+                }
+                return rows;
+            }, CAPTURED_PROPERTIES);
+            allStyles.push(...styles);
+            const stylePath = path.join(outDir, `${vp.name}.styles.json`);
+            fs.writeFileSync(stylePath, `${JSON.stringify(styles, null, 2)}\n`);
+            const scrollWidth = await page.evaluate(() => document.documentElement.scrollWidth);
+            await page.close();
+            captures.push({
+                viewport: vp.name,
+                width: vp.width,
+                height: vp.height,
+                screenshot: path.relative(projectRoot, shot).split(path.sep).join('/'),
+                dom: path.relative(projectRoot, domPath).split(path.sep).join('/'),
+                styles: path.relative(projectRoot, stylePath).split(path.sep).join('/'),
+                document_scroll_width: scrollWidth,
+                horizontal_overflow: scrollWidth > vp.width + 1,
+            });
+        }
+    }
+    catch (err) {
+        const manifest = {
+            schema: 1,
+            generated_at: new Date().toISOString(),
+            target: opts.target,
+            slug,
+            captures,
+            palette: collectPalette(allStyles),
+            type_families: collectTypeFamilies(allStyles),
+            verification: 'degraded',
+            degradation_reason: `capture failed after ${captures.length} viewport(s): ${String(err)}`,
+        };
+        writeManifest(outDir, manifest);
+        process.stderr.write(`[ui:render] ${manifest.degradation_reason}\n`);
+        return 1;
+    }
+    finally {
+        // The Class-A boundary. Closed on every path, throw included — this is
+        // what keeps a resident browser from becoming an accident.
+        await browser?.close();
+    }
+    const manifest = {
+        schema: 1,
+        generated_at: new Date().toISOString(),
+        target: opts.target,
+        slug,
+        captures,
+        palette: collectPalette(allStyles),
+        type_families: collectTypeFamilies(allStyles),
+        verification: 'verified',
+    };
+    writeManifest(outDir, manifest);
+    if (opts.json)
+        process.stdout.write(`${JSON.stringify(manifest, null, 2)}\n`);
+    else {
+        const overflow = manifest.captures.filter((c) => c.horizontal_overflow).map((c) => c.viewport);
+        process.stdout.write(`✅  ui:render — ${manifest.captures.length} viewport(s), ${manifest.palette.length} colour(s), ` +
+            `${manifest.type_families.length} family(ies)\n    ${path.relative(projectRoot, outDir)}\n` +
+            (overflow.length ? `    ⚠️  horizontal overflow at: ${overflow.join(', ')}\n` : ''));
+    }
+    return 0;
+}
+function writeManifest(outDir, manifest) {
+    fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(path.join(outDir, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+}
+//# sourceMappingURL=uiRender.js.map

package/dist/cli/main.js

@@ -21,6 +21,8 @@ import { runVersions } from './commands/versions.js';
 import { runRecordTriggerEval } from './commands/recordTriggerEval.js';
 import { runDoctorShell } from './commands/doctorShell.js';
 import { runRtkDetect } from './commands/rtkDetect.js';
+import { runUiAudit } from './commands/uiAudit.js';
+import { runUiRender } from './commands/uiRender.js';
 import { runUiServe } from './commands/uiServe.js';
 import { shouldInitLaunchGui, buildInitGuiOptions, buildProjectInitDelegation, findInitGuiConflict, withoutGuiFlag } from './initRouting.js';
 import { maybePrintFirstRunNotice } from './firstRunNotice.js';
@@ -107,6 +109,25 @@ async function main(rawArgv) {
         // process exit naturally once stdin is at EOF and stdout drained.
         process.exitCode = await runMcpServer();
     });
+    program
+        .command('ui:audit')
+        .argument('[path]', 'UI tree or file to inventory (default: cwd)')
+        .description('Inventory a UI tree into agents/runtime/state/ui-audit.json (Class A)')
+        .option('--json', 'Print the artefact on stdout as well as writing it')
+        .option('--project-root <path>', 'Override the project root')
+        .action((target, opts) => {
+        process.exitCode = runUiAudit({ target, ...opts });
+    });
+    program
+        .command('ui:render')
+        .argument('<target>', 'HTML file or http(s) URL to capture')
+        .description('Headless capture at desktop / 375px / 320px into agents/runtime/state/render/ (Class A)')
+        .option('--json', 'Print the manifest on stdout as well as writing it')
+        .option('--project-root <path>', 'Override the project root')
+        .option('--slug <name>', 'Override the output directory name')
+        .action(async (target, opts) => {
+        process.exitCode = await runUiRender({ target, ...opts });
+    });
     program
         .command('ui:serve')
         .description('Start the local UI server (127.0.0.1, auto-picked port)')
@@ -338,7 +359,7 @@ async function main(rawArgv) {
         return 0;
     }
     // Native subcommand → commander handles it (exits inside action).
-    const native = ['versions', 'doctor-shell', 'rtk:detect', 'mcp-server', 'ui:serve', 'settings', 'config', 'install', 'setup', 'workspaces', 'packs', 'commands', 'help', 'eval:record'];
+    const native = ['versions', 'doctor-shell', 'rtk:detect', 'mcp-server', 'ui:serve', 'ui:audit', 'ui:render', 'settings', 'config', 'install', 'setup', 'workspaces', 'packs', 'commands', 'help', 'eval:record'];
     if (head !== undefined && native.includes(head)) {
         await program.parseAsync(['node', 'agent-config', ...argv]);
         // Actions that don't hard-exit signal failure via process.exitCode.

package/dist/cli/mcp/content.js

@@ -12,6 +12,7 @@
  * downstream (dispatch) is a pure function of the returned tree.
  */
 import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { INDEXED_TRIGGER_KEYS } from '../../shared/skillRanking.js';
 import { join, resolve, basename, relative, sep } from 'node:path';
 import * as yaml from 'js-yaml';
 const MIME_MARKDOWN = 'text/markdown';
@@ -36,6 +37,36 @@ function parseFrontmatter(raw) {
 function str(v, fallback = '') {
     return typeof v === 'string' ? v : fallback;
 }
+/** Frontmatter `personas:` — a bare string counts as a one-element list. */
+function personaList(v) {
+    if (typeof v === 'string')
+        return v ? [v] : [];
+    if (!Array.isArray(v))
+        return [];
+    return v.filter((x) => typeof x === 'string');
+}
+/**
+ * `triggers[].keyword` + `triggers[].phrase` as plain text.
+ *
+ * Which keys count is `INDEXED_TRIGGER_KEYS`, shared with the disk-side reader
+ * so the two cannot disagree about what a trigger contributes.
+ */
+function triggerText(v) {
+    if (!Array.isArray(v))
+        return [];
+    const out = [];
+    for (const item of v) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const rec = item;
+        for (const key of INDEXED_TRIGGER_KEYS) {
+            const val = rec[key];
+            if (typeof val === 'string' && val)
+                out.push(val);
+        }
+    }
+    return out;
+}
 /** Recursively collect `*.md` files under `dir` (empty if `dir` is absent). */
 function walkMd(dir) {
     if (!existsSync(dir))
@@ -68,6 +99,15 @@ function makeEntry(file, kind, scheme, fallbackName) {
     };
     if (kind === 'rule' || kind === 'guideline')
         entry.mime_type = MIME_MARKDOWN;
+    // Ranking inputs — only skills are ranked, so only skills carry them.
+    if (kind === 'skill') {
+        const personas = personaList(fm.personas);
+        if (personas.length > 0)
+            entry.personas = personas;
+        const triggers = triggerText(fm.triggers);
+        if (triggers.length > 0)
+            entry.trigger_text = triggers;
+    }
     return entry;
 }
 /**
@@ -76,6 +116,28 @@ function makeEntry(file, kind, scheme, fallbackName) {
  * (a partial install still serves what is present). Never throws on a single
  * malformed file — that file is skipped with a stderr note.
  */
+/**
+ * Tier A names, or `undefined` when no split has been computed here.
+ *
+ * The file is gitignored and per-machine (`compute_skill_tiers` writes it), so
+ * absent is the common case and must stay distinguishable from empty. A
+ * malformed or unreadable file is also `undefined`: a half-read split would
+ * filter the wrong skills out of the one tool that exists to find them.
+ */
+export function loadTierA(packageRoot) {
+    const file = resolve(packageRoot, 'agents', 'runtime', 'state', 'skill-tiers.json');
+    if (!existsSync(file))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (!Array.isArray(parsed.tier_a))
+            return undefined;
+        return new Set(parsed.tier_a.filter((n) => typeof n === 'string'));
+    }
+    catch {
+        return undefined;
+    }
+}
 export function loadContentTree(packageRoot) {
     const uris = {};
     const add = (e) => {
@@ -117,7 +179,8 @@ export function loadContentTree(packageRoot) {
         const fallback = relative(guidelinesRoot, f).replace(/\.md$/, '').split(sep).join('/');
         safe(() => add(makeEntry(f, 'guideline', 'guideline', fallback)), f);
     }
-    return { uris };
+    const tierA = loadTierA(packageRoot);
+    return tierA ? { uris, tier_a: tierA } : { uris };
 }
 /** All entries of the given kinds (insertion order). */
 export function entriesOfKind(tree, kinds) {

package/dist/cli/mcp/dispatch.js

@@ -1,16 +1,31 @@
 /**
- * Pure JSON-RPC dispatch for the local stdio-lite MCP server (ADR-085).
+ * Pure JSON-RPC dispatch for the local stdio-lite MCP server (ADR-207).
  *
  * Wire shapes are mirrored VERBATIM from the hosted Worker
  * (`internal/workers/mcp/src/{handlers,prompts,resources}.ts`) so the local
  * stdio surface and the hosted HTTP surface return identical envelopes —
- * the multi-channel-consistency guarantee in ADR-085. If you change a shape
- * here, change it there too (and the Python kernel `scripts/mcp_server/`).
+ * the multi-channel-consistency guarantee. If you change a shape here, change
+ * it there too (and the kernel `src/scripts/mcp_server/`).
  *
- * Read-only: `tools/list` is empty and `tools/call` returns the
- * `not_implemented` envelope. Execution (the `full` kernel) is deferred per
- * ADR-085 § Phase-2 trigger. Pure — no I/O, no clock, no stdout.
+ * Read-only, and still read-only after Phase 1.1 of
+ * `road-to-skill-delivery-over-mcp`: `tools/list` now returns exactly TWO
+ * discovery tools — `suggest_skill_for_task` and `read_skill` — both of which
+ * only read the in-memory content tree. Execution (the `full` kernel) remains
+ * deferred per ADR-085 § Phase-2 trigger, and every other tool name still gets
+ * the `not_implemented` envelope. Pure — no I/O, no clock, no stdout.
+ *
+ * WHY THESE TWO AND NOT MORE. The turnkey server is small enough to load
+ * upfront (Claude Code defers MCP tool definitions only above ~10% of context),
+ * so every tool here is standing cost in every session. `LITE_TOOLS_TOKEN_CAP`
+ * below is that budget, asserted in `tests/scripts/mcp_lite_tools.test.ts`.
+ * `list_skills` is deliberately absent: the host already lists the names, and a
+ * 290-name tool result is the context cost this whole surface exists to avoid.
+ *
+ * The read-only boundary itself is accepted policy, owned with its revisit
+ * trigger by ADR-112 and restated as the distribution shape by ADR-207 on
+ * Node-only grounds; Phase 1.1 widens what is READ, never what is executed.
  */
+import { rankSkills } from '../../shared/skillRanking.js';
 import { entriesOfKind } from './content.js';
 export const RPC_PARSE_ERROR = -32700;
 export const RPC_INVALID_REQUEST = -32600;
@@ -97,13 +112,155 @@ function readResource(tree, uri) {
         _meta: { source: e.source, kind: e.kind },
     };
 }
-/** Read-only lite surface: no executable tools. ADR-085 defers `full`. */
+/**
+ * Server `instructions` (Phase 1.2).
+ *
+ * The AAIF Skills-over-MCP working group's June-2026 experiments found models
+ * routinely ignoring skills served over MCP and reaching for tools instead, and
+ * found that a server-side instruction nudge helped. This is that nudge, and it
+ * is the ONE positive finding from that work applied here — its decay with
+ * context length is a measurement (Phase 4.3), not something this paragraph
+ * fixes. Derived from the Iron Law of `rules/missing-skill-recovery.md`.
+ */
+export const INSTRUCTIONS = 'This server indexes the full skill catalogue, including skills the host ' +
+    'listed without a description or did not list at all. A skill missing from ' +
+    'the catalogue still exists: ask by task with suggest_skill_for_task, then ' +
+    'read the winner with read_skill. Never conclude that no skill covers a ' +
+    'task from the list you were shown.';
+/** Standing-context budget for the two tool definitions, in tokens (chars/4). */
+export const LITE_TOOLS_TOKEN_CAP = 600;
+/** Byte cap on `INSTRUCTIONS`, so the nudge cannot grow into a preamble. */
+export const INSTRUCTIONS_BYTE_CAP = 400;
+/**
+ * The two discovery tools. Read-only, shell-free, and pure over the content
+ * tree — `read_skill` resolves a NAME through the tree's uri map and never
+ * joins a path, so directory traversal is not merely rejected but unexpressible.
+ */
+export const LITE_TOOLS = [
+    {
+        name: 'suggest_skill_for_task',
+        description: 'Rank skills against a free-form task description. Use when the ' +
+            'skill you need is not in the catalogue the host delivered, so ' +
+            'asking by name is impossible and asking by task is not. Returns ' +
+            'names, scores and personas only — never bodies.',
+        inputSchema: {
+            type: 'object',
+            required: ['task'],
+            properties: {
+                task: { type: 'string', description: 'The task to match skills against.' },
+                limit: { type: 'integer', minimum: 1, default: 5, description: 'Max results. Default 5.' },
+            },
+            additionalProperties: false,
+        },
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: 'read_skill',
+        description: 'Return one skill body by name, as listed by suggest_skill_for_task.',
+        inputSchema: {
+            type: 'object',
+            required: ['name'],
+            properties: { name: { type: 'string', description: 'Skill name.' } },
+            additionalProperties: false,
+        },
+        annotations: { readOnlyHint: true },
+    },
+];
+const LITE_TOOL_NAMES = new Set(LITE_TOOLS.map((t) => t.name));
+/** Chars/4 over the served `tools/list` payload — the figure the cap is on. */
+export function liteToolsTokenCost() {
+    return Math.round(JSON.stringify({ tools: LITE_TOOLS }).length / 4);
+}
+/** MCP `tools/call` success shape: text content plus the structured result. */
+function toolTextResult(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload) }],
+        structuredContent: payload,
+        isError: false,
+    };
+}
+function rankableSkills(tree) {
+    return entriesOfKind(tree, ['skill']).map((e) => ({
+        name: e.name,
+        description: e.description,
+        personas: e.personas ?? [],
+        triggerText: e.trigger_text ?? [],
+    }));
+}
+/**
+ * Phase 3.3 — when the host already lists a skill WITH its description,
+ * returning it from the recovery tool is noise. Filter Tier A out if a split
+ * exists on this machine; return everything and say `tiers: unknown` if not.
+ *
+ * The filter deliberately does NOT apply when it would empty the result. A
+ * ranked list that went empty only because every match was Tier A is
+ * indistinguishable, to the caller, from "no skill covers this" — which is the
+ * exact wrong conclusion `missing-skill-recovery.md` exists to prevent.
+ */
+function tierState(tree) {
+    return tree.tier_a ? 'tier-b-only' : 'unknown';
+}
+/**
+ * `suggest_skill_for_task`. Mirrors the kernel handler's envelope — `status`,
+ * `suggestions[]` of `{skill, score, personas}` — so a consumer that learned the
+ * shape on one server does not have to relearn it on the other. `tiers` is
+ * Phase 3.3's field and reports `unknown` until a tier file is wired in.
+ */
+function suggestSkillForTask(tree, params) {
+    const task = typeof params.task === 'string' ? params.task.trim() : '';
+    if (!task)
+        return { status: 'error', error: 'params.task is required', suggestions: [] };
+    const rawLimit = typeof params.limit === 'number' ? Math.floor(params.limit) : 5;
+    const limit = Math.max(1, rawLimit);
+    const skills = rankableSkills(tree);
+    if (skills.length === 0) {
+        return { status: 'no_catalogue', suggestions: [], tiers: 'unknown' };
+    }
+    const all = rankSkills(task, skills);
+    const tiers = tierState(tree);
+    const tierA = tree.tier_a;
+    const filtered = tierA ? all.filter((r) => !tierA.has(r.name)) : all;
+    // Never let the tier filter turn a real match into an empty answer.
+    const kept = filtered.length > 0 ? filtered : all;
+    return {
+        status: 'ok',
+        skills_indexed: skills.length,
+        tiers,
+        ...(tierA && filtered.length === 0 && all.length > 0 ? { tier_filter: 'bypassed-to-avoid-empty' } : {}),
+        suggestions: kept.slice(0, limit).map((r) => ({ skill: r.name, score: r.score, personas: r.personas })),
+    };
+}
+/** `read_skill`. Name lookup through the uri map; no path is ever constructed. */
+function readSkill(tree, params) {
+    const name = typeof params.name === 'string' ? params.name.trim() : '';
+    if (!name)
+        return { status: 'error', error: 'params.name is required' };
+    // Structurally unnecessary — the lookup is a map hit on `skill://<name>` and
+    // cannot escape anywhere — but rejected explicitly so a reader does not have
+    // to reconstruct that argument, and so a future path-based backend inherits
+    // the guard rather than the hole.
+    if (name.includes('/') || name.includes('\\') || name.includes('..')) {
+        return { status: 'error', error: 'skill name must not contain a path separator' };
+    }
+    const entry = tree.uris[`skill://${name}`];
+    if (!entry || entry.kind !== 'skill') {
+        return { status: 'not_found', name };
+    }
+    return {
+        status: 'ok',
+        name: entry.name,
+        description: entry.description,
+        source: entry.source,
+        body: entry.body,
+    };
+}
+/** Read-only lite surface: only the two discovery tools. ADR-085 defers `full`. */
 function notImplementedEnvelope(name) {
     return {
         code: 'not_implemented',
         message: `Tool '${name}' is not available on the local stdio-lite surface ` +
-            `(read-only, ADR-085). Execution is deferred; self-host the Python ` +
-            `kernel (scripts/mcp_server/) for tool execution.`,
+            `(read-only, ADR-112). Execution is deferred; self-host the kernel ` +
+            `(src/scripts/mcp_server/) for tool execution.`,
         tool: name,
     };
 }
@@ -120,6 +277,7 @@ export function dispatch(tree, identity, req) {
                     tools: { listChanged: false },
                 },
                 serverInfo: { name: identity.name, version: identity.version },
+                instructions: INSTRUCTIONS,
             });
         case 'ping':
             return rpcResult(id, {});
@@ -150,11 +308,18 @@ export function dispatch(tree, identity, req) {
             return rpcResult(id, r);
         }
         case 'tools/list':
-            return rpcResult(id, { tools: [] });
+            return rpcResult(id, { tools: LITE_TOOLS });
         case 'tools/call': {
             const name = typeof params.name === 'string' ? params.name : '';
             if (!name)
                 return rpcError(id, RPC_INVALID_PARAMS, 'params.name is required');
+            if (LITE_TOOL_NAMES.has(name)) {
+                const args = (params.arguments ?? {});
+                const payload = name === 'suggest_skill_for_task'
+                    ? suggestSkillForTask(tree, args)
+                    : readSkill(tree, args);
+                return rpcResult(id, toolTextResult(payload));
+            }
             const env = notImplementedEnvelope(name);
             // Mirror the Worker: -32601 with the envelope in `data`; consumers
             // drive logic off `error.data.code`, never the wire message.

package/dist/cli/registry.js

@@ -35,6 +35,8 @@ export const REGISTRY = [
     { name: 'doctor-shell', disposition: 'native', synopsis: 'Native TS-shell environment probe.' },
     { name: 'rtk:detect', disposition: 'native', synopsis: 'rtk (Rust Token Killer) presence + identity readout — contract: docs/contracts/rtk-detection.md.' },
     { name: 'ui:serve', disposition: 'native', synopsis: 'Start the local UI server.' },
+    { name: 'ui:audit', disposition: 'native', synopsis: 'Inventory a UI tree into agents/runtime/state/ui-audit.json (Class A; the artefact ui-audit-gate reads).' },
+    { name: 'ui:render', disposition: 'native', synopsis: 'Headless capture at desktop / 375px / 320px into agents/runtime/state/render/ (Class A; no process survives).' },
     { name: 'config', disposition: 'native', synopsis: 'Open the configuration GUI (global by default; --project for the project surface).' },
     { name: 'settings', disposition: 'native', synopsis: 'Open the local Settings GUI (alias of config).' },
     { name: 'install', disposition: 'native', synopsis: 'Open the install wizard (UI server, lands on Step 1 / AI tools).' },
@@ -59,6 +61,7 @@ export const REGISTRY = [
     { name: 'sessions:list', disposition: 'delegate', synopsis: 'List live agent sessions plus unmerged branches held by other worktrees; --json, --branches.' },
     { name: 'sessions:claim', disposition: 'delegate', synopsis: 'Claim a roadmap for this session so other sessions skip it; --release clears it.' },
     { name: 'session:recycle', disposition: 'delegate', synopsis: 'Validate + write the main-session recycle envelope (--verify validates only, --project names the repo); the successor resumes from it after /clear.' },
+    { name: 'roadmap:context', disposition: 'delegate', synopsis: 'One live situational-awareness probe: open PRs + their file sets, roadmap-tail branches, live sessions, inbox note names, sibling-roadmap keyword hits; --roadmap <slug>, --json.' },
     { name: 'roadmap:progress', disposition: 'delegate', synopsis: 'Regenerate agents/roadmaps-progress.md from open roadmaps; archives completed ones (--no-archive to skip).' },
     { name: 'roadmap:progress-check', disposition: 'delegate', synopsis: 'Fail if agents/roadmaps-progress.md is stale (for CI).' },
     { name: 'roadmap:archive', disposition: 'delegate', synopsis: 'Archive completed roadmaps (PR-gate sweep).' },

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

@@ -201,6 +201,61 @@ function resolve_rule_pack_scope(raw, package_root, runtime_active_packs = []) {
   }
   return null;
 }
+function prune_modules_by(deploy_results, is_pruned) {
+  let pruned = 0;
+  const adjusted = {};
+  for (const tool_id of Object.keys(deploy_results)) {
+    const [written, skipped, status, paths] = deploy_results[tool_id];
+    const pruned_skill_dirs = /* @__PURE__ */ new Set();
+    for (const p of paths) {
+      const parts = p.split(path2.sep);
+      if (parts.includes("skills")) {
+        const i = parts.indexOf("skills");
+        if (i + 1 < parts.length) {
+          const skill_root = parts.slice(0, i + 2).join(path2.sep);
+          if (!pruned_skill_dirs.has(skill_root)) {
+            const skillmd = path2.join(skill_root, "SKILL.md");
+            if (fs2.existsSync(skillmd) && is_pruned(skillmd)) {
+              pruned_skill_dirs.add(skill_root);
+            }
+          }
+        }
+      }
+    }
+    const keep = [];
+    const delete_files = [];
+    for (const p of paths) {
+      const parts = p.split(path2.sep);
+      let is_target = false;
+      if (parts.includes("skills")) {
+        const i = parts.indexOf("skills");
+        if (i + 1 < parts.length && pruned_skill_dirs.has(parts.slice(0, i + 2).join(path2.sep))) {
+          is_target = true;
+        }
+      } else if (parts.includes("commands") && path2.extname(p) === ".md" && is_pruned(p)) {
+        is_target = true;
+      }
+      (is_target ? delete_files : keep).push(p);
+    }
+    for (const d of pruned_skill_dirs) {
+      fs2.rmSync(d, { recursive: true, force: true });
+    }
+    for (const p of delete_files) {
+      if (p.split(path2.sep).includes("commands") && fs2.existsSync(p)) {
+        try {
+          fs2.unlinkSync(p);
+        } catch {
+        }
+      }
+    }
+    pruned += delete_files.length;
+    adjusted[tool_id] = [Math.max(0, written - delete_files.length), skipped, status, keep];
+  }
+  return [pruned, adjusted];
+}
+function prune_lab_modules(deploy_results, lab_ids) {
+  return prune_modules_by(deploy_results, (p) => is_lab_artefact(p, lab_ids));
+}
 
 // src/install/ruleInScope.ts
 var YAML = __toESM(require_dist(), 1);
@@ -328,10 +383,11 @@ function excludedRuleBasenames(rulesDir, scope) {
 
 export {
   load_lab_pack_ids,
-  is_lab_artefact,
   load_packs_registry,
   compute_active_pack_ids,
   is_pruned_under_scoped,
+  prune_modules_by,
+  prune_lab_modules,
   parseFrontmatter,
   LEGACY_ALL,
   ruleScopeFromSettings,