@daweifu/capability-menu 0.1.0

package/lib/registry.js

@@ -0,0 +1,509 @@
+/**
+ * Unified capability catalog for the DeepSeek Harness.
+ *
+ * @module @daweifu/capability-menu (registry plugin)
+ */
+import z from '@deepseek-ai/schemastery';
+import { isModelInvocable } from '@deepseek-ai/dsh-skill';
+import yaml from 'js-yaml';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { dirname, resolve, sep } from 'node:path';
+/** Stable identifier prefixes: MCP tools keep `mcp__...`, skills use `skill:<name>`. */
+export const SKILL_ID_PREFIX = 'skill:';
+export const MCP_ID_PREFIX = 'mcp__';
+/** Validate and default the registry configuration. */
+export const Config = z.object({
+    summaryMaxChars: z.number().default(160),
+    detailIncludesBody: z.boolean().default(false),
+    maxResults: z.number().default(20),
+    weighting: z.number().default(0.1),
+    // schemastery object properties are optional-by-default: a missing key or
+    // undefined value is accepted (no `meta.required`), so no `.optional()` needed.
+    progressiveSkillCatalog: z.string(),
+});
+function assertPositiveInteger(name, value, min) {
+    if (!Number.isInteger(value) || value < min) {
+        throw new Error(`${name} must be an integer >= ${min}`);
+    }
+}
+function assertWeight(name, value) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error(`${name} must be a number in [0, 1]`);
+    }
+}
+/** Trim a description to a model-friendly summary. */
+function toSummary(description, maxChars) {
+    const collapsed = description.replace(/\s+/g, ' ').trim();
+    if (collapsed.length <= maxChars)
+        return collapsed;
+    return `${collapsed.slice(0, maxChars - 1)}…`;
+}
+/** BM25-ish keyword score over one record (pure JS, zero dependencies). */
+function keywordScore(record, tokens) {
+    const haystack = [
+        record.name,
+        record.description,
+        record.whenToUse ?? '',
+        record.origin.provider,
+        ...record.tags,
+    ].join(' ').toLowerCase();
+    let score = 0;
+    for (const token of tokens) {
+        if (token.length === 0)
+            continue;
+        if (haystack.includes(token))
+            score += 1;
+        // Substring hits on the identifier are stronger (exact id match handled separately).
+        if (record.id.toLowerCase().includes(token))
+            score += 1.5;
+    }
+    return score;
+}
+function successRate(stats) {
+    if (stats.uses === 0)
+        return undefined;
+    return stats.successes / stats.uses;
+}
+/** Build the registry plugin. */
+export const name = 'capability-menu-registry';
+export const inject = ['tools', 'skills'];
+export function apply(ctx, config = {}) {
+    const summaryMaxChars = config.summaryMaxChars ?? 160;
+    const detailIncludesBody = config.detailIncludesBody ?? false;
+    const maxResults = config.maxResults ?? 20;
+    const weighting = config.weighting ?? 0.1;
+    assertPositiveInteger('summaryMaxChars', summaryMaxChars, 20);
+    assertPositiveInteger('maxResults', maxResults, 1);
+    assertWeight('weighting', weighting);
+    /** MCP tool records keyed by tool name; skills keyed by `skill:<name>`. */
+    let toolRecords = new Map();
+    let skillRecords = new Map();
+    /** The scope each indexed skill was collected from; undefined = global layer. */
+    let skillScopes = new Map();
+    const statsOf = (record) => record.stats;
+    /**
+     * Resolve a skill's root directory from the live skill registry. The
+     * directory comes from the skill provider's own locator (`resourceBase` for
+     * bundle skills, the SKILL.md parent for flat files) or the indexed origin
+     * path for progressive-catalog entries — never from caller input.
+     */
+    const skillRootOf = async (id) => {
+        const name = skillNameOf(id);
+        const scope = skillScopes.get(id);
+        const lookup = scope === undefined ? {} : { scope };
+        const definition = await ctx.skills.get(name, lookup).catch(() => undefined);
+        if (definition !== undefined) {
+            if (definition.resourceBase !== undefined && definition.resourceBase.kind === 'directory') {
+                return definition.resourceBase.path;
+            }
+            if (definition.path !== undefined)
+                return dirname(definition.path);
+        }
+        // Progressive-catalog skills are not registered with a provider; fall
+        // back to the catalog-declared path (a directory holding the SKILL.md).
+        const record = skillRecords.get(id);
+        if (record?.origin.path !== undefined)
+            return record.origin.path;
+        return undefined;
+    };
+    /** Rebuild the MCP tool index synchronously from the visible tool registry. */
+    const rebuildTools = () => {
+        const next = new Map();
+        for (const schema of ctx.tools.schemas()) {
+            // 只编目 mcp__ 工具：原生工具（bash/read 等非 mcp__ 前缀）不进能力目录，
+            // 因此不被 meta_search/meta_invoke 覆盖、也不在能力管理（classifyAll）
+            // 枚举中；它们由 dsh 原生暴露面直连，仅受投影链可见性裁剪，须在
+            // tools.exposed 保活。与 invoke 的 id 前缀守卫保持一致。
+            if (!schema.name.startsWith(MCP_ID_PREFIX))
+                continue;
+            const existing = toolRecords.get(schema.name);
+            const stats = existing?.stats ?? { uses: 0, successes: 0, failures: 0, totalMs: 0 };
+            const serverName = serverNameOf(schema.name);
+            next.set(schema.name, {
+                id: schema.name,
+                kind: 'tool',
+                actions: ['execute'],
+                name: schema.name,
+                description: schema.description,
+                origin: { provider: serverName, serverName },
+                parameters: schema.parameters,
+                invocation: { modelInvocable: true, userInvocable: false },
+                tags: [serverName, 'tool'],
+                stats,
+                summary: toSummary(schema.description, summaryMaxChars),
+            });
+        }
+        toolRecords = next;
+    };
+    /** Read and parse the Progressive-skill catalog YAML into entries (empty when unconfigured/unreadable). */
+    const loadProgressiveSkills = async () => {
+        const file = config.progressiveSkillCatalog;
+        if (file === undefined || file.length === 0)
+            return [];
+        const path = resolve(process.cwd(), file);
+        let text;
+        try {
+            text = await readFile(path, 'utf8');
+        }
+        catch (error) {
+            ctx.logger.warn(`meta-registry: progressive skill catalog not readable (${path}): ${String(error)}`);
+            return [];
+        }
+        let parsed;
+        try {
+            parsed = yaml.load(text);
+        }
+        catch (error) {
+            ctx.logger.warn(`meta-registry: progressive skill catalog parse failed (${path}): ${String(error)}`);
+            return [];
+        }
+        if (parsed === null || typeof parsed !== 'object')
+            return [];
+        const list = parsed.skills;
+        if (!Array.isArray(list))
+            return [];
+        const entries = [];
+        for (const raw of list) {
+            if (raw === null || typeof raw !== 'object')
+                continue;
+            const item = raw;
+            if (typeof item.name !== 'string' || item.name.length === 0)
+                continue;
+            const description = typeof item.description === 'string' ? item.description : '';
+            entries.push({
+                name: item.name,
+                description,
+                ...typeof item.whenToUse === 'string' ? { whenToUse: item.whenToUse } : {},
+                ...typeof item.path === 'string' ? { path: item.path } : {},
+            });
+        }
+        return entries;
+    };
+    /**
+     * Rebuild the skill index asynchronously; resolves when the refresh completes.
+     *
+     * Skills live in a per-scope registry: the global layer plus one layer per
+     * agent preset that mounts skill providers (a preset's `skill-filesystem`
+     * registers into that preset's layer, so the host-plane global read alone
+     * sees nothing). The management catalog enumerates the global layer and then
+     * every mountable preset's standing scope, so preset-scoped skills surface.
+     */
+    const refreshSkills = async () => {
+        const nextSkills = new Map();
+        const nextSkillScopes = new Map();
+        const indexSkill = (skill, scope) => {
+            if (!isModelInvocable(skill))
+                return;
+            const id = skillId(skill.name);
+            const existing = skillRecords.get(id);
+            const stats = existing?.stats ?? { uses: 0, successes: 0, failures: 0, totalMs: 0 };
+            nextSkills.set(id, {
+                id,
+                kind: 'skill',
+                actions: ['load'],
+                name: skill.name,
+                description: skill.description,
+                ...skill.whenToUse !== undefined ? { whenToUse: skill.whenToUse } : {},
+                origin: {
+                    provider: skill.provider,
+                },
+                parameters: { type: 'object', properties: {}, additionalProperties: false },
+                invocation: { modelInvocable: true, userInvocable: skill.invocation.userInvocable },
+                tags: [skill.provider, 'skill'],
+                stats,
+                summary: toSummary(skill.description, summaryMaxChars),
+            });
+            nextSkillScopes.set(id, scope);
+        };
+        const collectScoped = async (label, scope) => {
+            let skills = [];
+            try {
+                skills = scope === undefined ? await ctx.skills.list({}) : await ctx.skills.list({ scope });
+            }
+            catch (error) {
+                ctx.logger.warn(`meta-registry: skill catalog refresh failed for ${label}: ${String(error)}`);
+                return;
+            }
+            for (const skill of skills)
+                indexSkill(skill, scope);
+        };
+        // Global layer first: the host's own skill providers.
+        await collectScoped('global', undefined);
+        // Preset layers: agent presets mount skill providers into their own scope
+        // (web surface disables the host-plane rows by design). `agentPresets` is
+        // optional — headless bundles without it index the global layer only.
+        const agentPresets = ctx.get('agentPresets');
+        if (agentPresets !== undefined) {
+            let presets = [];
+            try {
+                presets = await agentPresets.list();
+            }
+            catch (error) {
+                ctx.logger.warn(`meta-registry: agent-presets enumeration failed: ${String(error)}`);
+            }
+            for (const preset of presets) {
+                if (preset.broken !== undefined)
+                    continue;
+                try {
+                    const scope = await agentPresets.standingKeyFor(preset.id);
+                    await collectScoped(`preset "${preset.id}"`, scope);
+                }
+                catch (error) {
+                    ctx.logger.warn(`meta-registry: preset "${preset.id}" skill scope unavailable: ${String(error)}`);
+                }
+            }
+        }
+        // Additionally index Progressive skills from the independent YAML catalog.
+        // Exposed skills (from ctx.skills) win on a name collision so an Exposed
+        // skill is never shadowed by a stale Progressive catalog entry.
+        const progressive = await loadProgressiveSkills();
+        for (const entry of progressive) {
+            const id = skillId(entry.name);
+            if (nextSkills.has(id))
+                continue;
+            const existing = skillRecords.get(id);
+            const stats = existing?.stats ?? { uses: 0, successes: 0, failures: 0, totalMs: 0 };
+            nextSkills.set(id, {
+                id,
+                kind: 'skill',
+                actions: ['load'],
+                name: entry.name,
+                description: entry.description,
+                ...entry.whenToUse !== undefined ? { whenToUse: entry.whenToUse } : {},
+                origin: {
+                    provider: 'progressive-catalog',
+                    ...entry.path !== undefined ? { path: entry.path } : {},
+                },
+                parameters: { type: 'object', properties: {}, additionalProperties: false },
+                invocation: { modelInvocable: true, userInvocable: false },
+                tags: ['progressive-catalog', 'skill'],
+                stats,
+                summary: toSummary(entry.description, summaryMaxChars),
+            });
+            nextSkillScopes.set(id, undefined);
+        }
+        skillRecords = nextSkills;
+        skillScopes = nextSkillScopes;
+    };
+    /** Refresh the whole catalog: MCP tools synchronously, skills asynchronously. */
+    const refresh = async () => {
+        rebuildTools();
+        await refreshSkills();
+    };
+    /** Register once; also subscribe to change events. */
+    const disposers = [];
+    disposers.push(ctx.on('tools/change', () => void refresh()));
+    disposers.push(ctx.on('skills/change', () => void refresh()));
+    // Build the synchronous tool index eagerly; the skill index is left to
+    // the first explicit `refresh()` (or a change event) so an eager load never
+    // snapshots — and caches inside the skill registry — an incomplete catalog.
+    rebuildTools();
+    void refreshSkills();
+    ctx.effect(() => () => {
+        for (const dispose of disposers)
+            dispose();
+    });
+    const service = {
+        search(options = {}) {
+            const kind = options.kind ?? 'all';
+            const server = options.server;
+            const tag = options.tag;
+            const query = options.query?.trim();
+            const id = options.id?.trim();
+            const all = [];
+            // Index/source is the GLOBAL registry — no visibility filter here.
+            // Exposed/Progressive is a projection-layer concern (`dsh-capability-policy`),
+            // so a Progressive tool hidden from the model's exposure surface must still
+            // be searchable so `meta_search` can return it for `meta_invoke`. Blocked
+            // enforcement lives at the model-facing tools (meta_search/meta_invoke),
+            // keeping the management surface able to list Blocked capabilities.
+            if (kind === 'all' || kind === 'tool') {
+                for (const record of toolRecords.values())
+                    all.push(record);
+            }
+            if (kind === 'all' || kind === 'skill') {
+                for (const record of skillRecords.values())
+                    all.push(record);
+            }
+            const filtered = all.filter(record => {
+                if (server !== undefined && record.origin.serverName !== server)
+                    return false;
+                if (tag !== undefined && !record.tags.includes(tag))
+                    return false;
+                if (id !== undefined && record.id !== id)
+                    return false;
+                return true;
+            });
+            // Rank: exact id/name first, then keyword score, then experience weight.
+            const tokens = (query ?? '').toLowerCase().split(/\s+/).filter(Boolean);
+            const ranked = filtered.map(record => {
+                let score = 0;
+                if (query !== undefined && query.length > 0) {
+                    const exact = record.id === query || record.name === query;
+                    if (exact)
+                        score += 100;
+                    score += keywordScore(record, tokens);
+                }
+                const rate = successRate(record.stats);
+                if (rate !== undefined && weighting > 0)
+                    score += rate * weighting * 10;
+                if (record.stats.uses > 0 && weighting > 0)
+                    score += Math.min(record.stats.uses, 100) * weighting * 0.01;
+                return { record, score };
+            }).sort((a, b) => b.score - a.score);
+            const limit = Math.max(1, options.maxResults ?? maxResults);
+            return ranked.slice(0, limit).map(({ record }) => {
+                const rate = successRate(record.stats);
+                return {
+                    id: record.id,
+                    kind: record.kind,
+                    name: record.name,
+                    summary: record.summary,
+                    ...record.origin.serverName !== undefined ? { server: record.origin.serverName } : {},
+                    tags: record.tags,
+                    ...rate !== undefined ? { success_rate: rate } : {},
+                    uses: record.stats.uses,
+                };
+            });
+        },
+        get(id) {
+            const key = id.trim();
+            return toolRecords.get(key) ?? skillRecords.get(key);
+        },
+        async getDetail(id, context = {}) {
+            const key = id.trim();
+            const record = toolRecords.get(key) ?? skillRecords.get(key);
+            if (record === undefined)
+                return undefined;
+            if (record.kind === 'tool') {
+                const definition = ctx.tools.get(record.name, context.scope);
+                if (definition === undefined)
+                    return undefined;
+                return {
+                    id: record.id,
+                    kind: 'tool',
+                    actions: record.actions,
+                    name: record.name,
+                    description: definition.description,
+                    parameters: definition.parameters,
+                    output: definition.output.schema,
+                    origin: record.origin,
+                    tags: record.tags,
+                    stats: statsOf(record),
+                };
+            }
+            // Skill: resolve the body if configured.
+            const lookup = {
+                cwd: context.cwd,
+                signal: context.signal,
+                scope: context.scope,
+            };
+            const skill = await ctx.skills.get(record.name, lookup).catch(() => undefined);
+            const detail = {
+                id: record.id,
+                kind: 'skill',
+                actions: record.actions,
+                name: record.name,
+                description: record.description,
+                ...record.whenToUse !== undefined ? { whenToUse: record.whenToUse } : {},
+                parameters: record.parameters,
+                origin: record.origin,
+                tags: record.tags,
+                stats: statsOf(record),
+            };
+            if (skill !== undefined && detailIncludesBody) {
+                return { ...detail, output: { type: 'object', properties: { content: { type: 'string' } } } };
+            }
+            return detail;
+        },
+        async listSkillDir(id, relPath = '') {
+            const root = await skillRootOf(id);
+            if (root === undefined)
+                return undefined;
+            const target = relPath.length === 0 ? root : resolve(root, relPath);
+            // Containment: the resolved path must stay inside the skill root.
+            if (target !== root && !target.startsWith(`${root}${sep}`))
+                return undefined;
+            try {
+                const entries = await readdir(target, { withFileTypes: true });
+                return entries.map(entry => ({
+                    name: entry.name,
+                    type: entry.isDirectory() ? 'directory' : 'file',
+                }));
+            }
+            catch (error) {
+                ctx.logger.warn(`meta-registry: skill dir listing failed for "${id}" at ${target}: ${String(error)}`);
+                return undefined;
+            }
+        },
+        async readSkillFile(id, relPath) {
+            const root = await skillRootOf(id);
+            if (root === undefined)
+                return undefined;
+            const target = resolve(root, relPath);
+            // Containment: the resolved path must stay inside the skill root.
+            if (target !== root && !target.startsWith(`${root}${sep}`))
+                return undefined;
+            try {
+                const info = await stat(target);
+                if (!info.isFile())
+                    return undefined;
+                const text = await readFile(target, 'utf8');
+                // NUL marks binary content; do not surface it as a text preview.
+                return text.includes('\0') ? undefined : text;
+            }
+            catch (error) {
+                ctx.logger.warn(`meta-registry: skill file read failed for "${id}" at ${target}: ${String(error)}`);
+                return undefined;
+            }
+        },
+        size() {
+            return toolRecords.size + skillRecords.size;
+        },
+        refresh() {
+            return refresh();
+        },
+    };
+    // Observe tool results to write back objective stats. Nested dispatches
+    // (parent set by meta_invoke) attribute to the target capability; the
+    // meta_invoke wrapper itself records nothing for any capability.
+    ctx.on('tools/result', (exec, result) => {
+        const name = exec.name;
+        if (!name.startsWith(MCP_ID_PREFIX))
+            return;
+        const record = toolRecords.get(name);
+        if (record === undefined)
+            return;
+        // meta_invoke never carries the `mcp__` prefix (filtered above), so a nested
+        // dispatch from meta_invoke attributes stats only to the target capability.
+        const durationMs = result.meta !== undefined && typeof result.meta === 'object'
+            && result.meta !== null && 'durationMs' in result.meta
+            ? result.meta.durationMs
+            : undefined;
+        const base = statsOf(record);
+        const next = {
+            uses: base.uses + 1,
+            successes: base.successes + (result.isError ? 0 : 1),
+            failures: base.failures + (result.isError ? 1 : 0),
+            totalMs: base.totalMs + (typeof durationMs === 'number' && Number.isFinite(durationMs) ? durationMs : 0),
+            lastUsedAt: Date.now(),
+        };
+        toolRecords.set(name, { ...record, stats: next });
+    });
+    ctx.provide('meta', service);
+}
+/** Derive the server namespace from an `mcp__<server>__<raw>` name. */
+export function serverNameOf(publicName) {
+    const rest = publicName.startsWith(MCP_ID_PREFIX) ? publicName.slice(MCP_ID_PREFIX.length) : publicName;
+    const index = rest.indexOf('__');
+    return index === -1 ? rest : rest.slice(0, index);
+}
+/** Build the stable skill identifier `skill:<name>`. */
+export function skillId(name) {
+    return `${SKILL_ID_PREFIX}${name}`;
+}
+/** Strip the `skill:` prefix from a capability id. */
+export function skillNameOf(id) {
+    return id.startsWith(SKILL_ID_PREFIX) ? id.slice(SKILL_ID_PREFIX.length) : id;
+}
+//# sourceMappingURL=registry.js.map

package/lib/search.js

@@ -0,0 +1,127 @@
+/**
+ * Model-facing `meta_search` tool: capability catalog search + detail.
+ *
+ * @module @daweifu/capability-menu (search plugin)
+ */
+import z from '@deepseek-ai/schemastery';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+export const name = 'capability-menu-search';
+export const inject = ['meta', 'tools', 'skills'];
+/** Validate and default the tool configuration. */
+export const Config = z.object({
+    maxResults: z.number().default(20),
+});
+/**
+ * Register the `meta_search` tool.
+ *
+ * - Mode A (list, default): query by keyword/tag/server, returns id + short summary.
+ * - Mode B (detail): pass an exact id (optionally `detail: true`) to get the full schema.
+ *
+ * Validation rules enforced here:
+ * - `query` and `id` are mutually exclusive.
+ * - `detail: true` with a fuzzy query (no exact id) is rejected.
+ */
+export function apply(ctx, config = {}) {
+    const maxResults = config.maxResults ?? 20;
+    if (!Number.isInteger(maxResults) || maxResults < 1) {
+        throw new Error('maxResults must be a positive integer');
+    }
+    const tool = defineTool({
+        name: 'meta_search',
+        description: 'Search capabilities (tools and skills) by keyword/tag/source, or get full detail for one capability by exact id. Mode A (list, default): returns id + short summary for each hit. Mode B (detail): pass an exact id (optionally detail:true) to get the full schema/description. Use meta_invoke with a returned id to run/load the capability.',
+        parameters: {
+            query: { type: 'string', description: 'Natural-language or keyword query; mutually exclusive with id.' },
+            id: { type: 'string', description: 'Exact capability id (from a previous search results[].id); mutually exclusive with query, takes precedence.' },
+            detail: { type: 'boolean', description: 'When true, returns the single capability full schema; only meaningful with an exact id.' },
+            kind: { type: 'string', enum: ['tool', 'skill', 'all'], description: 'Filter by capability kind (default all).' },
+            server: { type: 'string', description: 'Filter by MCP serverName, e.g. gongfeng/iwiki/km/zhiyan_qci.' },
+            tag: { type: 'string', description: 'Filter by tag.' },
+            max_results: { type: 'integer', description: 'Maximum results in list mode (default 20, max 50).' },
+        },
+        output: {
+            schema: {
+                oneOf: [
+                    {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            mode: { type: 'string', required: true, const: 'list' },
+                            total: { type: 'integer', required: true },
+                            results: { type: 'array', required: true, items: { type: 'json' } },
+                            hint: { type: 'string', required: true },
+                        },
+                    },
+                    {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            mode: { type: 'string', required: true, const: 'detail' },
+                            result: { type: 'json', required: true },
+                        },
+                    },
+                ],
+            },
+            render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+        },
+        async execute(args, exec) {
+            const query = args.query?.trim() ?? '';
+            const id = args.id?.trim() ?? '';
+            const detail = args.detail === true;
+            const kind = args.kind ?? 'all';
+            const server = args.server?.trim() || undefined;
+            const tag = args.tag?.trim() || undefined;
+            const requestedMax = args.max_results;
+            if (query.length > 0 && id.length > 0) {
+                throw new Error('meta_search: query and id are mutually exclusive; pass exactly one');
+            }
+            if (detail && id.length === 0) {
+                throw new Error('meta_search: detail:true requires an exact id; pass id to get the full schema of one capability');
+            }
+            const scope = exec.agent;
+            const context = {
+                cwd: exec.agent?.session.header.cwd,
+                signal: exec.signal,
+                scope,
+            };
+            // Blocked capabilities are not discoverable: the registry keeps them
+            // indexed for the management surface, but meta_search never surfaces
+            // them to the model.
+            const policy = ctx.get('capabilityPolicy');
+            const isBlocked = (id) => policy?.isBlockedCapability(id) ?? false;
+            if (id.length > 0) {
+                if (isBlocked(id)) {
+                    throw new Error(`meta_search: capability "${id}" is blocked and cannot be inspected`);
+                }
+                const result = await ctx.meta.getDetail(id, context);
+                if (result === undefined) {
+                    throw new Error(`meta_search: capability "${id}" is unknown or no longer available`);
+                }
+                return { mode: 'detail', result: result };
+            }
+            const results = ctx.meta.search({
+                query,
+                kind,
+                server,
+                tag,
+                maxResults: Math.min(requestedMax ?? maxResults, 50),
+                scope,
+            }).filter(result => !isBlocked(result.id));
+            return {
+                mode: 'list',
+                total: results.length,
+                results: results,
+                hint: 'Call meta_search with an exact id for full schema, or meta_invoke to run/load it.',
+            };
+        },
+        presentCall(args) {
+            return {
+                card: 'generic',
+                title: args.id !== undefined ? `Inspect capability ${args.id}` : `Search capabilities${args.query ? `: ${args.query}` : ''}`,
+                kind: 'read',
+                rawInput: args.id ?? args.query ?? '',
+            };
+        },
+    });
+    ctx.tools.register(tool);
+}
+//# sourceMappingURL=search.js.map

package/lib/types/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @daweifu/capability-menu — consolidated plugin package.
+ *
+ * One installable source package exposing four cordis plugin factories that the
+ * bundle mounts as separate entries via subpath exports (`/registry`, `/search`,
+ * `/invoke`, `/policy`):
+ *
+ * - `registry` (P0): capability catalog + `ctx.meta` service (no model tool).
+ * - `search`   (P1): registers `meta_search`.
+ * - `invoke`   (P2): registers `meta_invoke`.
+ * - `policy`   (P3): Exposed/Progressive/Blocked projection policy + `ctx.capabilityPolicy`.
+ *
+ * @module @daweifu/capability-menu
+ */
+export * from './registry.ts';
+export * as registry from './registry.ts';
+export * as search from './search.ts';
+export * as invoke from './invoke.ts';
+export * as policy from './policy.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@daweifu/capability-menu`.
+ * @module @daweifu/capability-menu/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "capability-menu-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map