@khorsheed/dsh-capability-catalog 0.1.98 → 0.1.99

package/lib/types/evidence.js

@@ -0,0 +1,179 @@
+/**
+ * The PRODUCER side of capability-composition evidence: pure data, computed
+ * where the composition runs, for a consumer in another process to verify.
+ *
+ * {@link produceCapabilityEvidence} answers "what is the capability face of
+ * THIS composition, and how completely was it measured?" — the composition
+ * digest plus a per-section completeness descriptor, the measurement object
+ * (what claims to have been measured), and the caller's coverage declaration
+ * (what directories/services were read). It reuses this package's own
+ * snapshot and digest algorithms (`catalogSnapshot`, `hashOf` — via
+ * `remote.ts` and `capabilities.ts`), so the digest it reports is the digest
+ * `snapshotFor` would stamp over the same registries: parity is by
+ * construction, and a test pins it.
+ *
+ * Two deliberate absences, both by design:
+ *
+ * - **No standing-scope mount.** The function takes no roster and no cordis
+ *   Context, so it CANNOT resolve a preset's standing scope — resolving one
+ *   mounts the preset (see `preset-scope.ts`), and a target-side producer
+ *   must not pay that side effect to measure. The normal target-side
+ *   topology needs no scope at all: the producer's own registries already
+ *   ARE the composition's face. A caller holding an already-resolved scope
+ *   may pass it as `scope`; resolution and release stay the caller's
+ *   business.
+ * - **No service registration.** Nothing is mounted, provided or injected as
+ *   a side effect; the function reads the slices it is handed and returns
+ *   plain JSON-safe data. It runs in a bare process (node builtins and this
+ *   package's existing dependencies only).
+ *
+ * The digest algorithm is owned by THIS package. A consumer MUST NOT
+ * recompute it from the rows, and MUST treat a `partial` or `unavailable`
+ * section as "not verified" — never as complete, and never as "the section
+ * is empty". An empty-but-complete section (scanned, zero found) and an
+ * unmeasured section produce distinguishable descriptors, which is the
+ * point: an empty digest is not a complete one unless every section says so.
+ * @module @khorsheed/dsh-capability-catalog/evidence
+ */
+import { isAbsolute } from 'node:path';
+import { catalogSnapshot } from './remote.js';
+import { collectToolFace } from './tool-face.js';
+/** The registry that measures as "no skills", for a composition without a skills service. */
+const EMPTY_REGISTRY = {
+    snapshot: async () => ({ skills: [], complete: true }),
+    get: async () => undefined,
+};
+/**
+ * Wrap the caller's tools slice so a `get()` that throws degrades to an
+ * unreadable origin tag (a partial section) instead of failing the whole
+ * measurement. Member-call semantics are preserved — the slice may be a
+ * traceable proxy whose methods need their receiver.
+ */
+function guardToolReads(tools) {
+    if (tools.get === undefined)
+        return tools;
+    const get = tools.get;
+    return {
+        schemas: (scope) => tools.schemas(scope),
+        get: (name, scope) => {
+            try {
+                return get.call(tools, name, scope);
+            }
+            catch {
+                return undefined;
+            }
+        },
+    };
+}
+/** The skills section's descriptor, from the collection's own report. */
+function skillsCompleteness(skills, report) {
+    if (skills === undefined)
+        return { state: 'unavailable', reason: 'the skills service is not installed' };
+    if (report === undefined || report.attemptedScopes === 0)
+        return { state: 'unavailable', reason: 'no skill scope was read' };
+    if (report.failedScopes === report.attemptedScopes) {
+        return { state: 'unavailable', reason: `the skill registry read failed for every scope (${report.attemptedScopes} attempted)` };
+    }
+    const problems = [];
+    if (report.failedScopes > 0)
+        problems.push(`the skill registry read failed for ${report.failedScopes} of ${report.attemptedScopes} scopes`);
+    if (report.incompleteReads > 0)
+        problems.push('the registry reported incomplete skill discovery');
+    if (report.unreadableBodies > 0)
+        problems.push(`${report.unreadableBodies} skill bodies could not be read`);
+    return problems.length === 0 ? { state: 'complete' } : { state: 'partial', reason: problems.join('; ') };
+}
+/** The tools section's descriptor, from how the tools-side read went. */
+function toolsCompleteness(tools, readFailed, face) {
+    if (tools === undefined)
+        return { state: 'unavailable', reason: 'the tools service is not installed' };
+    if (readFailed || face === undefined)
+        return { state: 'unavailable', reason: 'the tool registry read failed' };
+    if (face.untaggedOrigins.length > 0) {
+        return { state: 'partial', reason: `origin tags unreadable for ${face.untaggedOrigins.length} visible tools — channel attribution fell back to heuristics` };
+    }
+    return { state: 'complete' };
+}
+/** The MCP section is derived from the tools section, so it inherits its failures. */
+function mcpCompleteness(tools) {
+    if (tools.state === 'unavailable')
+        return { state: 'unavailable', reason: 'MCP servers are derived from the tools section, which is unavailable' };
+    if (tools.state === 'partial')
+        return { state: 'partial', reason: 'derived from a partially measured tools section' };
+    return { state: 'complete' };
+}
+/** The channel summary is derived from the skills and tools rows, so it is only as strong as they are. */
+function channelsCompleteness(skills, tools) {
+    if (skills.state === 'unavailable' && tools.state === 'unavailable') {
+        return { state: 'unavailable', reason: 'neither the skills nor the tools section could be measured' };
+    }
+    if (skills.state !== 'complete' || tools.state !== 'complete') {
+        return { state: 'partial', reason: `summarizes sections that are not fully measured (skills: ${skills.state}, tools: ${tools.state})` };
+    }
+    return { state: 'complete' };
+}
+/**
+ * Produce the capability-composition evidence of the composition THIS
+ * process runs, as plain data another process can verify.
+ *
+ * The measurement reuses the package's own algorithms end to end: the tools
+ * side is read by `tool-face.ts` (the same reads the Remote verbs make), the
+ * snapshot is `catalogSnapshot` in fingerprint mode, and the digest is its
+ * stamped `sha` — nothing is re-implemented, so the answer is comparable
+ * with a `snapshotFor` digest taken over the same registries.
+ * @param options - every input, explicit; see {@link ProduceCapabilityEvidenceOptions}.
+ * @returns the evidence bundle — digest, completeness, measurement, coverage.
+ * @throws when `workdir` is given but not absolute, when `presetId` is given
+ *   but blank, or when the coverage declaration is missing — the caller
+ *   verifies identity and coverage; this function only measures.
+ */
+export async function produceCapabilityEvidence(options) {
+    if (options.workdir !== undefined && !isAbsolute(options.workdir)) {
+        throw new Error(`produceCapabilityEvidence needs an absolute workdir (caller-verified); got ${JSON.stringify(options.workdir)}`);
+    }
+    if (options.presetId !== undefined && options.presetId.trim() === '') {
+        throw new Error(`produceCapabilityEvidence needs a non-empty presetId when one is given; got ${JSON.stringify(options.presetId)}`);
+    }
+    if (options.coverage === undefined || options.coverage === null) {
+        throw new Error('produceCapabilityEvidence needs the caller\'s coverage declaration (what directories/services were measured)');
+    }
+    const warn = options.warn ?? (() => { });
+    // The tools side: one read of the caller's slice, with a throwing `get`
+    // degraded to an untagged origin. A throwing `schemas()` is the caller's
+    // unavailable — nothing was measured.
+    let toolFace;
+    let toolsReadFailed = false;
+    if (options.tools !== undefined) {
+        try {
+            toolFace = collectToolFace(guardToolReads(options.tools), options.scope, warn);
+        }
+        catch {
+            toolsReadFailed = true;
+        }
+    }
+    // The skills side + the snapshot itself: the SAME catalogSnapshot call the
+    // fingerprint verb makes, with the health report the verbs never ask for.
+    const report = {};
+    const snapshot = await catalogSnapshot(options.workdir, options.skills ?? EMPTY_REGISTRY, toolFace?.schemas ?? [], toolFace?.mcpServerNames ?? [], options.appearedAfterApply ?? new Set(), [options.scope], toolFace?.origins ?? new Map(), { fingerprint: true, report, ...options.presetId !== undefined ? { preset: options.presetId } : {} });
+    const skills = skillsCompleteness(options.skills, report.skills);
+    const tools = toolsCompleteness(options.tools, toolsReadFailed, toolFace);
+    return {
+        measurement: {
+            kind: 'preset-composition',
+            ...options.presetId !== undefined ? { presetId: options.presetId } : {},
+            ...options.workdir !== undefined ? { workdir: options.workdir } : {},
+            ...options.revision !== undefined ? { revision: options.revision } : {},
+        },
+        sha: snapshot.sha,
+        completeness: {
+            skills,
+            tools,
+            mcpServers: mcpCompleteness(tools),
+            channels: channelsCompleteness(skills, tools),
+        },
+        coverage: {
+            ...options.coverage.directories !== undefined ? { directories: [...options.coverage.directories] } : {},
+            ...options.coverage.services !== undefined ? { services: [...options.coverage.services] } : {},
+        },
+    };
+}

package/lib/types/frontmatter.d.ts

@@ -0,0 +1,78 @@
+/**
+ * SKILL.md frontmatter: ONE real-YAML parse shared by every catalog reader.
+ *
+ * Before this module, each reader carried its own line-based scan: a regex
+ * split plus per-key patterns that matched at any indentation, so a nested
+ * same-named key could shadow a top-level one and a `presetScope` under an
+ * unrelated key still counted. Everything here is derived from a single
+ * js-yaml parse of the block (js-yaml is the repo's YAML convention and a
+ * shipped runtime dependency), with the scalar semantics mirrored from the
+ * host's skill loader (`skill-filesystem`): booleans accept true/false, 1/0,
+ * yes/no, on/off.
+ *
+ * Two deliberate degradations, both pinned by specs:
+ *
+ * - A malformed `metadata:` block must not take the skill down. A bad metadata
+ *   value usually poisons the whole YAML parse, so on a parse failure the
+ *   block is retried once with the top-level `metadata:` section stripped:
+ *   the skill delivers minus metadata rather than being rejected.
+ * - A flag value outside the accepted variants reads as ABSENT (the caller's
+ *   default applies) instead of rejecting the skill the way the host loader
+ *   does — the catalog is a management/delivery surface, not the loader of
+ *   record.
+ * @module @khorsheed/dsh-capability-catalog/frontmatter
+ */
+/** Whether a string is a usable skill / preset id. */
+export declare function isKebabId(value: string): boolean;
+/** The frontmatter block split from the body it precedes. */
+export interface FrontmatterSplit {
+    /** The text between the `---` fences. */
+    readonly front: string;
+    /** Everything after the closing fence. */
+    readonly body: string;
+}
+/** Split a SKILL.md into its frontmatter block and body. */
+export declare function splitFrontmatter(content: string): FrontmatterSplit | undefined;
+/** A SKILL.md frontmatter block, parsed once with real YAML semantics. */
+export interface SkillFrontmatter {
+    /** Top-level `name`, when a non-empty string. */
+    readonly name?: string;
+    /** Top-level `description`, when a non-empty string (folded scalars included). */
+    readonly description?: string;
+    /** `when-to-use` / `whenToUse` routing guidance, kebab spelling first. */
+    readonly whenToUse?: string;
+    /** `disable-model-invocation`, inverted; absent/invalid means invocable. */
+    readonly modelInvocable: boolean;
+    /** `user-invocable`; absent/invalid means invocable. */
+    readonly userInvocable: boolean;
+    /**
+     * The declared preset ids: the canonical `metadata.presetScope`, falling
+     * back to a top-level `presetScope` (a form the line-based reader accepted
+     * and hand-edited files may still carry). A `presetScope` nested under any
+     * other key is NOT a declaration. `undefined` is absent; `[]` is the
+     * explicit every-preset form.
+     */
+    readonly presetScope?: readonly string[];
+    /** The verbatim top-level `metadata` map, when it is a plain object. */
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    /** The body after the closing fence. */
+    readonly body: string;
+}
+/**
+ * Parse a SKILL.md's frontmatter block once, with js-yaml.
+ * @param content - the whole file text.
+ * @returns the parsed fields plus the body, or undefined when there is no
+ *   frontmatter block or the block is not usable YAML even without its
+ *   `metadata:` section.
+ */
+export declare function parseSkillFrontmatter(content: string): SkillFrontmatter | undefined;
+/**
+ * A frontmatter boolean with the host skill loader's accepted variants:
+ * booleans, 1/0 (number or string), and yes/no/on/off (case-insensitive —
+ * js-yaml 4 leaves those as strings, so the string branch carries them).
+ * Absent or anything else reads as undefined: the catalog degrades to the
+ * caller's default instead of rejecting the skill the way the host loader
+ * does (`frontmatter field "<key>" must be a boolean` → file ignored).
+ */
+export declare function frontmatterBoolean(data: Record<string, unknown>, key: string): boolean | undefined;
+//# sourceMappingURL=frontmatter.d.ts.map

package/lib/types/frontmatter.js

@@ -0,0 +1,186 @@
+/**
+ * SKILL.md frontmatter: ONE real-YAML parse shared by every catalog reader.
+ *
+ * Before this module, each reader carried its own line-based scan: a regex
+ * split plus per-key patterns that matched at any indentation, so a nested
+ * same-named key could shadow a top-level one and a `presetScope` under an
+ * unrelated key still counted. Everything here is derived from a single
+ * js-yaml parse of the block (js-yaml is the repo's YAML convention and a
+ * shipped runtime dependency), with the scalar semantics mirrored from the
+ * host's skill loader (`skill-filesystem`): booleans accept true/false, 1/0,
+ * yes/no, on/off.
+ *
+ * Two deliberate degradations, both pinned by specs:
+ *
+ * - A malformed `metadata:` block must not take the skill down. A bad metadata
+ *   value usually poisons the whole YAML parse, so on a parse failure the
+ *   block is retried once with the top-level `metadata:` section stripped:
+ *   the skill delivers minus metadata rather than being rejected.
+ * - A flag value outside the accepted variants reads as ABSENT (the caller's
+ *   default applies) instead of rejecting the skill the way the host loader
+ *   does — the catalog is a management/delivery surface, not the loader of
+ *   record.
+ * @module @khorsheed/dsh-capability-catalog/frontmatter
+ */
+import yaml from 'js-yaml';
+/** Kebab-case skill / preset id grammar (the registry's own). */
+const KEBAB_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** Whether a string is a usable skill / preset id. */
+export function isKebabId(value) {
+    return KEBAB_ID.test(value);
+}
+/** Frontmatter block, then the body it precedes (CRLF-tolerant). */
+const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/** Split a SKILL.md into its frontmatter block and body. */
+export function splitFrontmatter(content) {
+    const match = FRONTMATTER.exec(content);
+    if (match === null)
+        return undefined;
+    return { front: match[1] ?? '', body: match[2] ?? '' };
+}
+/**
+ * Parse a SKILL.md's frontmatter block once, with js-yaml.
+ * @param content - the whole file text.
+ * @returns the parsed fields plus the body, or undefined when there is no
+ *   frontmatter block or the block is not usable YAML even without its
+ *   `metadata:` section.
+ */
+export function parseSkillFrontmatter(content) {
+    const split = splitFrontmatter(content);
+    if (split === undefined)
+        return undefined;
+    const parsed = parseFrontmatterData(split.front);
+    if (parsed === undefined)
+        return undefined;
+    const { data, metadataDropped } = parsed;
+    const rawMetadata = data['metadata'];
+    const metadata = !metadataDropped && typeof rawMetadata === 'object' && rawMetadata !== null && !Array.isArray(rawMetadata)
+        ? rawMetadata
+        : undefined;
+    const name = stringField(data, 'name');
+    const description = stringField(data, 'description');
+    const whenToUse = whenToUseOf(data);
+    const presetScope = presetScopeOf(data, metadata);
+    return {
+        ...name === undefined ? {} : { name },
+        ...description === undefined ? {} : { description },
+        ...whenToUse === undefined ? {} : { whenToUse },
+        modelInvocable: frontmatterBoolean(data, 'disable-model-invocation') !== true,
+        userInvocable: frontmatterBoolean(data, 'user-invocable') !== false,
+        ...presetScope === undefined ? {} : { presetScope },
+        ...metadata === undefined ? {} : { metadata },
+        body: split.body,
+    };
+}
+/**
+ * A frontmatter boolean with the host skill loader's accepted variants:
+ * booleans, 1/0 (number or string), and yes/no/on/off (case-insensitive —
+ * js-yaml 4 leaves those as strings, so the string branch carries them).
+ * Absent or anything else reads as undefined: the catalog degrades to the
+ * caller's default instead of rejecting the skill the way the host loader
+ * does (`frontmatter field "<key>" must be a boolean` → file ignored).
+ */
+export function frontmatterBoolean(data, key) {
+    if (!Object.hasOwn(data, key))
+        return undefined;
+    const value = data[key];
+    if (typeof value === 'boolean')
+        return value;
+    if (value === 1 || value === '1')
+        return true;
+    if (value === 0 || value === '0')
+        return false;
+    if (typeof value === 'string') {
+        switch (value.toLowerCase()) {
+            case 'true':
+            case 'yes':
+            case 'on':
+                return true;
+            case 'false':
+            case 'no':
+            case 'off':
+                return false;
+        }
+    }
+    return undefined;
+}
+/** A frontmatter string field: non-empty strings only (the host's stringField). */
+function stringField(data, key) {
+    const value = data[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/** The routing guidance, kebab spelling first (the catalog has always accepted both). */
+function whenToUseOf(data) {
+    return stringField(data, 'when-to-use') ?? stringField(data, 'whenToUse');
+}
+/** The declared preset scope; the canonical metadata-nested key wins over the legacy top-level one. */
+function presetScopeOf(data, metadata) {
+    const nested = metadata === undefined ? undefined : normalizePresetScope(metadata['presetScope']);
+    if (nested !== undefined)
+        return nested;
+    return normalizePresetScope(data['presetScope']);
+}
+/** Normalize a raw presetScope value: arrays filter to kebab ids, a scalar is a one-item list. */
+function normalizePresetScope(value) {
+    if (Array.isArray(value))
+        return presetIdsOf(value.map(String));
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return presetIdsOf([String(value)]);
+    }
+    return undefined;
+}
+/** Normalize YAML scalars onto the preset-id grammar (deduped, order preserved). */
+function presetIdsOf(values) {
+    const ids = [];
+    for (const value of values) {
+        const id = value.trim().replace(/^['"]|['"]$/g, '');
+        if (id === '' || !KEBAB_ID.test(id))
+            continue;
+        if (!ids.includes(id))
+            ids.push(id);
+    }
+    return ids;
+}
+/** Parse the block as a YAML mapping; on a YAML failure retry once without the
+ * top-level `metadata:` section (a malformed metadata value degrades to
+ * no-metadata instead of rejecting the file). */
+function parseFrontmatterData(front) {
+    try {
+        const data = loadYamlMapping(front);
+        return data === undefined ? undefined : { data, metadataDropped: false };
+    }
+    catch {
+        const stripped = stripTopLevelBlock(front, 'metadata');
+        if (stripped === undefined)
+            return undefined;
+        try {
+            const data = loadYamlMapping(stripped);
+            return data === undefined ? undefined : { data, metadataDropped: true };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+/** js-yaml parse of the block; only a plain object is a usable frontmatter map. */
+function loadYamlMapping(front) {
+    const parsed = yaml.load(front);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return undefined;
+    return parsed;
+}
+/** Remove a top-level `key:` line and its indented block; undefined when the key is absent. */
+function stripTopLevelBlock(front, key) {
+    const lines = front.split('\n');
+    const start = lines.findIndex(line => new RegExp(`^${key}\\s*:`).test(line));
+    if (start < 0)
+        return undefined;
+    let end = start + 1;
+    while (end < lines.length) {
+        const line = lines[end] ?? '';
+        if (line.trim() !== '' && !/^\s/.test(line))
+            break;
+        end += 1;
+    }
+    return [...lines.slice(0, start), ...lines.slice(end)].join('\n');
+}

package/lib/types/import.js

@@ -21,9 +21,9 @@ import { cp, mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from 'node
 import { homedir, tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { promisify } from 'node:util';
+import { isKebabId, parseSkillFrontmatter, splitFrontmatter } from './frontmatter.js';
 import { extractZip } from './zip.js';
 const execFileAsync = promisify(execFile);
-const FRONTMATTER = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
 /** First bytes of a ZIP archive (local file header / empty / spanned). */
 const ZIP_MAGIC_PK = 0x50; // 'P'
 const ZIP_MAGIC_K = 0x4b; // 'K'
@@ -35,13 +35,11 @@ export function managedRoot(root, dshHome) {
 }
 /** Extract the kebab-case `name` and `description` from a SKILL.md body. */
 export function resolveSkillNameFromContent(content) {
-    const m = FRONTMATTER.exec(content);
-    if (m === null)
+    const parsed = parseSkillFrontmatter(content);
+    if (parsed === undefined)
         return undefined;
-    const front = m[1] ?? '';
-    const name = /^name:\s*(.+)$/m.exec(front)?.[1]?.trim();
-    const description = /^description:\s*(.+)$/m.exec(front)?.[1]?.trim();
-    if (name === undefined || description === undefined || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name))
+    const { name, description } = parsed;
+    if (name === undefined || description === undefined || !isKebabId(name))
         return undefined;
     return { name, description };
 }
@@ -51,12 +49,7 @@ function decodeBase64(payload) {
 }
 /** Read the frontmatter `disable-model-invocation` flag (default model-invocable true). */
 export function inferModelInvocable(content) {
-    const m = FRONTMATTER.exec(content);
-    if (m === null)
-        return true;
-    const front = m[1] ?? '';
-    const line = /^disable-model-invocation:\s*(true|false)$/m.exec(front)?.[1];
-    return line !== 'true';
+    return parseSkillFrontmatter(content)?.modelInvocable ?? true;
 }
 /** Whether a filesystem path exists (dir or file). */
 async function pathExists(p) {
@@ -96,22 +89,20 @@ function sanitizeRelPath(p) {
 }
 /** Apply the frontmatter `disable-model-invocation` line to match the request. */
 function finalizeSkillText(content, modelInvocable) {
-    const m = FRONTMATTER.exec(content);
-    if (m === null)
+    const split = splitFrontmatter(content);
+    if (split === undefined)
         return content;
-    const front = String(m[1] ?? '');
-    const body = String(m[2] ?? '');
     const effective = inferModelInvocable(content);
     if (effective === modelInvocable)
         return content;
-    const without = front
+    const without = split.front
         .split('\n')
         .filter(line => !line.trim().startsWith('disable-model-invocation:'))
         .join('\n');
     const withFlag = modelInvocable
         ? without
         : `${without}${without.endsWith('\n') ? '' : '\n'}disable-model-invocation: true`;
-    return `---\n${withFlag}\n---\n${body}`;
+    return `---\n${withFlag}\n---\n${split.body}`;
 }
 /**
  * Add a skill from a base64 SKILL.md text payload into the managed root.

package/lib/types/index.d.ts

@@ -16,17 +16,21 @@ import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { CapabilityCatalogSnapshot, CatalogAddSkillRequest, CatalogAddSkillResult, CatalogCredentialSetRequest, CatalogDeleteSkillResult, CatalogMcpServerConfig, CatalogMcpSnapshot, CatalogMcpTool, CatalogModeFace, CatalogSkillDetail, CatalogSkillFileRead, CatalogDirSkillInfo, CatalogPresetScopeStatus, CatalogPresetOption, CatalogPresetScopeSetRequest, CatalogPresetScopeAdoptRequest, CatalogPresetScopeEditResult } from './types.ts';
 export { TOOL_ORIGIN, setToolOrigin, toolOrigin } from './tool-origin.ts';
 export type { ToolOrigin } from './tool-origin.ts';
-export type { CapabilityCatalogSnapshot, CatalogJsonValue, CatalogSkillRow, CatalogToolRow, CatalogMcpServerRow, CatalogChannelSummary, CatalogSkillDetail, CatalogSkillFileRead, CatalogCredentialState, CatalogAddSkillRequest, CatalogAddSkillResult, CatalogDeleteSkillResult, CatalogCredentialSetRequest, CatalogPresetScopeStatus, CatalogScopedSkillRow, CatalogScopedPresetRow, CatalogPresetOption, CatalogModeFace, CatalogPresetScopeSetRequest, CatalogPresetScopeAdoptRequest, CatalogPresetScopeEditResult, } from './types.ts';
+export type { CapabilityCatalogSnapshot, CatalogSectionCompleteness, CatalogSnapshotCompleteness, CatalogJsonValue, CatalogSkillRow, CatalogToolRow, CatalogMcpServerRow, CatalogChannelSummary, CatalogSkillDetail, CatalogSkillFileRead, CatalogCredentialState, CatalogAddSkillRequest, CatalogAddSkillResult, CatalogDeleteSkillResult, CatalogCredentialSetRequest, CatalogPresetScopeStatus, CatalogScopedSkillRow, CatalogScopedPresetRow, CatalogPresetOption, CatalogModeFace, CatalogPresetScopeSetRequest, CatalogPresetScopeAdoptRequest, CatalogPresetScopeEditResult, } from './types.ts';
 export { resolveSkillNameFromContent } from './import.ts';
 export { resolvePresetScope } from './preset-scope.ts';
 export type { PresetRosterSlice, PresetRosterRow, ResolvedPresetScope } from './preset-scope.ts';
 export { modeOptions, readModeFaces } from './modes.ts';
-export { ScopedSkillDelivery, scopedSkillsRoot, scanManagedSkills, managedSkillFrom, parsePresetScopeFrontmatter, defaultSkillRoots, detectConflicts, SCOPED_PROVIDER_NAME, MANAGED_SKILL_RANK, } from './scoped-delivery.ts';
+export { ScopedSkillDelivery, scopedSkillsRoot, scanManagedSkills, managedSkillFrom, defaultSkillRoots, detectConflicts, SCOPED_PROVIDER_NAME, MANAGED_SKILL_RANK, } from './scoped-delivery.ts';
 export { adoptManagedSkill, releaseManagedSkill, setManagedPresetScope, withPresetScope, findSkillSource, managedLocation, isDirectory, } from './scoped-edits.ts';
 export type { ScopedEditResult, SkillSource, ManagedSkillLocation } from './scoped-edits.ts';
 export type { ManagedSkill, ScopedDeliveryDeps, ScopedDeliveryRegistry, ScopedDeliveryStatus, ScopedPresetStatus, ScopedSkillStatus, } from './scoped-delivery.ts';
 export { canonicalCapabilities, canonicalJson, capsTag, hashOf, hashSkillBody, CAPS_TAG_PREFIX, } from './capabilities.ts';
 export type { CanonicalCapabilities, CanonicalMcpServer, CanonicalSkill, CanonicalTool, } from './capabilities.ts';
+export { produceCapabilityEvidence } from './evidence.ts';
+export type { CapabilityEvidenceCompleteness, CapabilityEvidenceCoverage, CapabilityEvidenceMeasurement, ProduceCapabilityEvidenceOptions, ProducedCapabilityEvidence, } from './evidence.ts';
+export type { RegistrySlice, SkillsCollectionReport } from './skills.ts';
+export type { CatalogToolsSlice, ToolSchemaLike } from './tool-face.ts';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         capabilityCatalog: CapabilityCatalogService;
@@ -184,7 +188,6 @@ export declare class CapabilityCatalogService extends TypertRemoteService {
     addSkill(request: CatalogAddSkillRequest): Promise<CatalogAddSkillResult>;
     deleteSkill(name: string, workdir?: string, presetId?: string): Promise<CatalogDeleteSkillResult>;
     pickDirectory(): Promise<string | null>;
-    mcpList(): Promise<readonly CatalogMcpServerConfig[]>;
     mcpAdd(config: CatalogMcpServerConfig): Promise<boolean>;
     mcpRemove(serverName: string): Promise<boolean>;
     mcpSetEnabled(serverName: string, enabled: boolean): Promise<void>;
@@ -192,6 +195,8 @@ export declare class CapabilityCatalogService extends TypertRemoteService {
     mcpSetToolEnabled(serverName: string, tool: string, enabled: boolean): Promise<void>;
     mcpDiscover(serverName: string): Promise<readonly CatalogMcpTool[]>;
     mcpSnapshot(): Promise<CatalogMcpSnapshot>;
+    /** The live tools registry, when the composition provides one. */
+    private toolsRegistry;
     /** The visible tool schemas in the standing scope (the set the model sees),
      * or the global layer when no preset standing key resolves. Skills already
      * enumerate through the same scope; tools must use it too so the