@khorsheed/dsh-capability-catalog 0.1.95

package/lib/types/preset-scope.js

@@ -0,0 +1,117 @@
+/**
+ * Resolving WHICH scope the catalog reads — and the one place where a listing
+ * and a fingerprint part company.
+ *
+ * The catalog reads the skill and tool registries at an agent preset's
+ * standing scope, because that is the view the model actually has. Resolving
+ * it can fail: the composition may mount no roster, the named preset may not
+ * exist, or its composition may refuse to mount.
+ *
+ * The roster face depends on the host line: 0.1.5 exposes a lease-free
+ * `standingKeyFor(id)`, while rc.1 replaced it with a LEASED
+ * `acquireScope(id)` — the resolved lease carries the key and a release on
+ * `Symbol.asyncDispose`, and a lease never released leaks a generation user,
+ * so the preset's scope is never collected. Both faces resolve through
+ * {@link acquireStandingScope}; callers that hold the key across reads own
+ * the release (see {@link ResolvedPresetScope.dispose}).
+ *
+ * A LISTING degrades on all three. The settings card must not go blank
+ * because a preset has a bad row, and the global layer is a useful, honestly
+ * unlabelled answer there.
+ *
+ * A FINGERPRINT must not. Falling back to the global layer and stamping the
+ * requested preset's name on the result hands back a hash that is not that
+ * preset's face — which is precisely the "claim with nothing behind it" the
+ * hash exists to eliminate. It was not hypothetical: on a real sub-dsh whose
+ * preset carried one invalid row, two scopes rostering two different presets
+ * produced one identical hash, silently, and the only way to notice was to
+ * already know the answer.
+ * @module @khorsheed/dsh-capability-catalog/preset-scope
+ */
+/**
+ * Acquire one preset's standing scope key from whichever face the roster
+ * offers — 0.1.5's lease-free `standingKeyFor` first, rc.1's leased
+ * `acquireScope` when that is absent. Errors propagate unchanged, so the
+ * caller owns the strict/degrade policy; the caller also owns the release.
+ * @param roster - the agent-preset roster (already probed present).
+ * @param id - the preset to read, or undefined for the deployment default.
+ * @returns the key and the lease release, if the face leases.
+ */
+export async function acquireStandingScope(roster, id) {
+    if (roster.standingKeyFor !== undefined)
+        return { key: await roster.standingKeyFor(id) };
+    if (roster.acquireScope === undefined)
+        return { key: undefined };
+    const lease = await roster.acquireScope(id);
+    const dispose = leaseRelease(lease);
+    return { key: leaseKey(lease), ...dispose === undefined ? {} : { dispose } };
+}
+/**
+ * Resolve the catalog's reading scope.
+ *
+ * Resolving a preset MOUNTS it (the roster's single-flight standing mount),
+ * so this is not a free read: asking for the capability face of a preset
+ * nothing has composed yet composes it.
+ * @param roster - the optional agent-preset roster (`ctx.get('agentPresets')`).
+ * @param presetId - the preset to read, or undefined for the deployment default.
+ * @param strict - fingerprint mode: throw rather than degrade to the global layer.
+ * @returns the scope to read at and the label it may carry.
+ * @throws in strict mode when the roster is absent for a named preset, or
+ *   cannot resolve a standing scope.
+ */
+export async function resolvePresetScope(roster, presetId, strict) {
+    if (roster?.standingKeyFor === undefined && roster?.acquireScope === undefined) {
+        // No roster at all. Naming a preset here is a caller error; asking for
+        // the default face is honest — there is no preset to misreport.
+        if (strict && presetId !== undefined) {
+            throw new Error(`capability-catalog: cannot fingerprint preset ${JSON.stringify(presetId)} — this composition mounts no agent-preset roster`);
+        }
+        return { scope: undefined, preset: undefined };
+    }
+    const wanted = presetId ?? roster?.defaultId;
+    let read;
+    try {
+        read = await acquireStandingScope(roster, wanted);
+    }
+    catch (error) {
+        if (strict) {
+            throw new Error(`capability-catalog: cannot fingerprint preset ${JSON.stringify(wanted)}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return { scope: undefined, preset: undefined };
+    }
+    if (read.key === undefined) {
+        // No scope to hand out, so no caller will release the lease — do it here.
+        await read.dispose?.();
+        if (strict) {
+            throw new Error(`capability-catalog: the roster resolved no standing scope for preset ${JSON.stringify(wanted)}`);
+        }
+        return { scope: undefined, preset: undefined };
+    }
+    return {
+        scope: read.key,
+        preset: typeof wanted === 'string' && wanted !== '' ? wanted : undefined,
+        ...read.dispose === undefined ? {} : { dispose: read.dispose },
+    };
+}
+/** The lease's key, read structurally (`key` is opaque to the catalog). */
+function leaseKey(lease) {
+    if (lease === null || (typeof lease !== 'object' && typeof lease !== 'function'))
+        return undefined;
+    return lease.key;
+}
+/**
+ * The lease's release, hung on `Symbol.asyncDispose` by the roster. The
+ * es2024 target does not type that symbol, so it is read through a cast —
+ * any runtime hosting an rc.1 roster defines it, because the roster's own
+ * lease literal is keyed by it. A lease without a callable release degrades
+ * to the 0.1.5 shape (nothing to dispose) rather than failing the read.
+ */
+function leaseRelease(lease) {
+    if (lease === null || (typeof lease !== 'object' && typeof lease !== 'function'))
+        return undefined;
+    const asyncDispose = Symbol.asyncDispose;
+    const release = asyncDispose === undefined ? undefined : lease[asyncDispose];
+    if (typeof release !== 'function')
+        return undefined;
+    return async () => { await release.call(lease); };
+}

package/lib/types/remote.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Catalog data layer: pure functions the Remote service calls. Kept separate
+ * from the service so the snapshot/add/detail/credential logic is unit-testable
+ * without a Cordis context and stays independent of the typert decorators.
+ * @module @khorsheed/dsh-capability-catalog/remote
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { CapabilityCatalogSnapshot, CatalogAddSkillRequest, CatalogAddSkillResult, CatalogCredentialSetRequest, CatalogDeleteSkillResult, CatalogDirSkillInfo, CatalogJsonValue, CatalogSkillDetail, CatalogSkillFileRead, CatalogToolRow } from './types.ts';
+import { type CredentialsSlice, type RegistrySlice, type SkillDefinitionLike } from './skills.ts';
+import type { ToolOrigin } from './tool-origin.ts';
+import { resolveSkillNameFromContent } from './import.ts';
+export type { CredentialsSlice, RegistrySlice };
+/** Project visible tools onto catalog rows with channel attribution. */
+export declare function projectTools(schemas: readonly ToolSchemaLike[], mcpServers: readonly string[], appearedAfterApply: Set<string>, toolOrigins?: ReadonlyMap<string, ToolOrigin>): CatalogToolRow[];
+/** Minimal ToolSchema shape (model-facing name/description/parameters). */
+interface ToolSchemaLike {
+    readonly name: string;
+    readonly description?: string;
+    readonly parameters?: CatalogJsonValue;
+}
+/**
+ * Build the full catalog snapshot (skills + tools).
+ *
+ * `fingerprint` decides whether the snapshot is a LISTING or an IDENTITY: it
+ * loads every skill body (one registry read each) so the rows carry
+ * `bodySha`, and stamps `sha` — the capability hash. The browser card wants
+ * the listing; a condition's capability record wants the identity.
+ */
+export declare function catalogSnapshot(workdir: string | undefined, registry: RegistrySlice, toolsSchemas: readonly ToolSchemaLike[], mcpServers: readonly string[], appearedAfterApply: ReadonlySet<string>, scopes?: readonly unknown[], toolOrigins?: ReadonlyMap<string, ToolOrigin>, options?: {
+    fingerprint?: boolean;
+    preset?: string;
+}): Promise<CapabilityCatalogSnapshot>;
+/** Load one skill detail. */
+export declare function catalogDetail(ctx: Context, registry: RegistrySlice, name: string, workdir: string | undefined, scope?: unknown, fallback?: SkillDefinitionLike): Promise<CatalogSkillDetail | undefined>;
+/** Read one skill-bundle file's text content on demand. */
+export declare function catalogReadSkillFile(registry: RegistrySlice, name: string, filePath: string, workdir: string | undefined, scope?: unknown, fallback?: SkillDefinitionLike): Promise<CatalogSkillFileRead | undefined>;
+/** Open the host's native directory chooser (the workspace "add" dialog). */
+export declare function catalogPickDirectory(ctx: Context, signal?: AbortSignal): Promise<string | null>;
+/** Delete a catalog-owned file skill (rejects built-in / plugin-provided). */
+export declare function catalogDeleteSkill(registry: RegistrySlice, name: string, workdir: string | undefined, scope?: unknown): Promise<CatalogDeleteSkillResult>;
+/** Set one declared credential value (never returned on the wire). */
+export declare function catalogSetCredential(ctx: Context, request: CatalogCredentialSetRequest): Promise<boolean>;
+/** Add a skill from a raw SKILL.md text payload into the managed root. */
+export declare function catalogAddSkill(ctx: Context, request: CatalogAddSkillRequest, dshHome: string): Promise<CatalogAddSkillResult>;
+/** List the skills inside a local container dir (for the add-skill chooser). */
+export declare function catalogListDirSkills(dirPath: string): Promise<readonly CatalogDirSkillInfo[]>;
+export { resolveSkillNameFromContent };
+//# sourceMappingURL=remote.d.ts.map

package/lib/types/remote.js

@@ -0,0 +1,120 @@
+/**
+ * Catalog data layer: pure functions the Remote service calls. Kept separate
+ * from the service so the snapshot/add/detail/credential logic is unit-testable
+ * without a Cordis context and stays independent of the typert decorators.
+ * @module @khorsheed/dsh-capability-catalog/remote
+ */
+import { collectSkills, loadSkillDetail, readSkillFileContent, deleteSkillDir, resolveServices, CREDENTIAL_REF_NAME, } from './skills.js';
+import { attributeToolChannel } from './channels.js';
+import { hashOf } from './capabilities.js';
+import { addSkillFromPayload, commandInstall, listDirSkills, resolveSkillNameFromContent } from './import.js';
+import { OFFICIAL_TOOLS } from './official-tools.js';
+/** Load the cached official-tools names. */
+function officialToolsSet() {
+    return new Set(OFFICIAL_TOOLS);
+}
+/** Project visible tools onto catalog rows with channel attribution. */
+export function projectTools(schemas, mcpServers, appearedAfterApply, toolOrigins = new Map()) {
+    const official = officialToolsSet();
+    const rows = [];
+    for (const schema of schemas) {
+        const attributed = attributeToolChannel(schema.name, official, mcpServers, appearedAfterApply.has(schema.name), toolOrigins);
+        rows.push({
+            name: schema.name,
+            description: schema.description ?? '',
+            channel: attributed.channel,
+            confidence: attributed.confidence,
+            ...attributed.serverName !== undefined ? { serverName: attributed.serverName } : {},
+            ...attributed.owner !== undefined ? { owner: attributed.owner } : {},
+            ...schema.parameters !== undefined ? { parameters: schema.parameters } : {},
+        });
+    }
+    return rows;
+}
+/**
+ * Build the full catalog snapshot (skills + tools).
+ *
+ * `fingerprint` decides whether the snapshot is a LISTING or an IDENTITY: it
+ * loads every skill body (one registry read each) so the rows carry
+ * `bodySha`, and stamps `sha` — the capability hash. The browser card wants
+ * the listing; a condition's capability record wants the identity.
+ */
+export async function catalogSnapshot(workdir, registry, toolsSchemas, mcpServers, appearedAfterApply, scopes = [undefined], toolOrigins = new Map(), options = {}) {
+    const fingerprint = options.fingerprint === true;
+    const base = await collectSkills(registry, workdir, scopes, { bodySha: fingerprint });
+    const tools = projectTools(toolsSchemas, mcpServers, appearedAfterApply, toolOrigins);
+    const snapshot = {
+        skills: base.skills,
+        tools,
+        mcpServers: mcpServers.map(name => ({ name, toolCount: tools.filter(t => t.serverName === name).length })),
+        channels: [
+            { channel: 'skill', count: base.skills.length },
+            { channel: 'tool', count: tools.length },
+        ],
+        ...options.preset !== undefined ? { preset: options.preset } : {},
+    };
+    return fingerprint ? { ...snapshot, sha: hashOf(snapshot) } : snapshot;
+}
+/** Load one skill detail. */
+export async function catalogDetail(ctx, registry, name, workdir, scope = undefined, fallback) {
+    return loadSkillDetail(ctx, registry, name, workdir, scope, fallback);
+}
+/** Read one skill-bundle file's text content on demand. */
+export async function catalogReadSkillFile(registry, name, filePath, workdir, scope = undefined, fallback) {
+    return readSkillFileContent(registry, name, filePath, workdir, scope, fallback);
+}
+/** Open the host's native directory chooser (the workspace "add" dialog). */
+export async function catalogPickDirectory(ctx, signal) {
+    const picker = ctx.get?.('directoryPicker');
+    const cap = picker?.capability?.();
+    if (cap?.kind !== 'native' || cap.pick === undefined)
+        return null;
+    try {
+        return await cap.pick(signal ?? new AbortController().signal);
+    }
+    catch {
+        return null;
+    }
+}
+/** Delete a catalog-owned file skill (rejects built-in / plugin-provided). */
+export async function catalogDeleteSkill(registry, name, workdir, scope = undefined) {
+    const base = workdir === undefined ? {} : { cwd: workdir };
+    const lookup = scope === undefined ? base : { ...base, scope };
+    const def = await registry.get(name, lookup);
+    if (def === undefined)
+        return { ok: false, error: 'skill not found' };
+    return deleteSkillDir(def);
+}
+/** Set one declared credential value (never returned on the wire). */
+export async function catalogSetCredential(ctx, request) {
+    const { credentials } = resolveServices(ctx);
+    if (credentials === undefined)
+        return false;
+    try {
+        if (!CREDENTIAL_REF_NAME.test(request.key))
+            return false;
+        await credentials.set(request.key, request.value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Add a skill from a raw SKILL.md text payload into the managed root. */
+export async function catalogAddSkill(ctx, request, dshHome) {
+    const { registry } = resolveServices(ctx);
+    if (registry === undefined)
+        return { ok: false, error: 'skills service absent in this composition' };
+    if (request.channel === 'zip') {
+        return addSkillFromPayload(request, dshHome);
+    }
+    if (request.channel === 'command') {
+        return commandInstall(request, dshHome);
+    }
+    return { ok: false, error: 'github clone not wired in v1' };
+}
+/** List the skills inside a local container dir (for the add-skill chooser). */
+export async function catalogListDirSkills(dirPath) {
+    return listDirSkills(dirPath);
+}
+export { resolveSkillNameFromContent };

package/lib/types/scoped-delivery.d.ts

@@ -0,0 +1,243 @@
+/**
+ * Preset-scoped skill delivery: a plugin-owned skills root whose entries are
+ * delivered **into one preset's scope layer** instead of into the global layer.
+ *
+ * The skill registry is layered by the scope a registration is made from, and a
+ * read merges the global layer with the viewing agent's scope chain. A provider
+ * registered through a context scoped to a preset's standing key is therefore
+ * consulted only for sessions on that preset — no read-time identity guessing,
+ * and no dependence on the borrowed lookup options.
+ *
+ * The per-skill policy lives in the skill's own frontmatter
+ * (`metadata.presetScope: [<preset-id>, …]`); an absent or empty list means the
+ * entry is not delivered by this module at all. A managed name that ALSO exists
+ * in a default skill root is refused delivery and reported: a leftover copy is
+ * served by the host provider in every preset, so silently delivering a second
+ * candidate would make the scope a lie.
+ *
+ * Scope of enforcement: this is a discovery/delivery policy for one Harness
+ * instance, not an authorization boundary. `ScopeKey` values are ordinary
+ * objects and the roster hands real ones to any caller, so a same-process plugin
+ * can claim membership. In-process agents and children joining the parent's
+ * composition are covered; native codex/claude-code and ACP backends start their
+ * own runtime and never consult this registry at all.
+ * @module @khorsheed/dsh-capability-catalog/scoped-delivery
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SkillCandidate, SkillDefinition, SkillProvider, SkillProviderControl } from '@deepseek-ai/dsh-skill';
+import { type PresetRosterSlice } from './preset-scope.ts';
+/**
+ * Resolve the preset-registry module by name. The 0.1.7-rc.1 host renamed
+ * `@deepseek-ai/dsh-agent-presets` to `@deepseek-ai/dsh-agent-preset-registry`
+ * (the livePresetMounts API carried over); 0.1.5/0.1.6 hosts install only the
+ * old name, and a host without preset composition installs neither — `null`,
+ * and {@link ScopedSkillDelivery.liveKeys} then reports nothing live, the same
+ * degrade the call's own catch encodes. A STATIC import of either name is a
+ * module-resolution failure at load on hosts installing only the other —
+ * pack-dist strips `dependencies`, so the specifier resolves against the
+ * host's install tree. Both specifiers stay static string literals so tsdown
+ * externalizes them and tsc type-checks them.
+ * @returns the module namespace, or null when neither name resolves.
+ */
+export declare function loadPresetRegistry(): Promise<unknown>;
+/** Test seam: drop the cached probe so a mocked resolution path re-runs. */
+export declare function resetPresetRegistryProbeForTest(): void;
+/** Provider label for managed entries; also the candidate's `provider` field. */
+export declare const SCOPED_PROVIDER_NAME = "capability-catalog";
+/** Candidate rank, beside the filesystem provider's `custom` roots. */
+export declare const MANAGED_SKILL_RANK = 300;
+/** Directory under the harness home that holds preset-scoped skills. */
+export declare const SCOPED_SKILLS_DIR: string;
+/** One managed skill read from the plugin-owned root. */
+export interface ManagedSkill {
+    readonly name: string;
+    readonly description: string;
+    readonly whenToUse?: string;
+    readonly modelInvocable: boolean;
+    readonly userInvocable: boolean;
+    /** Preset ids this skill is delivered to; absent/empty means "not scoped". */
+    readonly presetScope: readonly string[] | undefined;
+    /** The skill's own directory (its `resourceBase`). */
+    readonly dir: string;
+    /** Absolute `SKILL.md` path. */
+    readonly path: string;
+    readonly content: string;
+}
+/** The managed root for one harness home. */
+export declare function scopedSkillsRoot(dshHome: string): string;
+/** One skill's delivery state, as the settings surface reads it. */
+export interface ScopedSkillStatus {
+    readonly name: string;
+    readonly description: string;
+    readonly modelInvocable: boolean;
+    readonly userInvocable: boolean;
+    /** The managed `SKILL.md` path. */
+    readonly path: string;
+    readonly presets: readonly string[];
+    /** Whether a delivery provider currently serves this skill. */
+    readonly delivered: boolean;
+    /** Present when delivery is refused (the same name exists in a default root). */
+    readonly conflict?: string;
+}
+/** One preset's delivery state. */
+export interface ScopedPresetStatus {
+    readonly presetId: string;
+    readonly skills: readonly string[];
+    /** Present when the preset's standing scope could not be resolved. */
+    readonly error?: string;
+}
+/** Whole-delivery status for the settings surface and the model-facing tool. */
+export interface ScopedDeliveryStatus {
+    readonly enabled: boolean;
+    /** Why delivery is off (or reduced) — absent when it is fully operational. */
+    readonly reason?: string;
+    readonly root: string;
+    readonly watching: boolean;
+    readonly skills: readonly ScopedSkillStatus[];
+    readonly presets: readonly ScopedPresetStatus[];
+    /** Default roots a duplicate could hide in but that cannot be enumerated. */
+    readonly customRootsUnverifiable: boolean;
+}
+/** The services this module borrows. Every one is optional. */
+export interface ScopedDeliveryDeps {
+    /** The harness home the managed root lives under. */
+    readonly dshHome: () => string;
+    /** The agent-preset roster (absent in a rosterless composition). */
+    readonly roster: () => PresetRosterSlice | undefined;
+    /** The skill registry's registration face (absent without `dsh-skill`). */
+    readonly registry: () => ScopedDeliveryRegistry | undefined;
+    /** The session's workspace, for project-root duplicate detection. */
+    readonly workdir?: () => string | undefined;
+    /** Logger for degradation and watcher diagnostics. */
+    readonly log: (message: string) => void;
+}
+/** The registry slice this module registers through. */
+export interface ScopedDeliveryRegistry {
+    readonly registerProvider?: (create: (control: SkillProviderControl) => SkillProvider) => () => void;
+}
+/**
+ * Read the `presetScope` list out of a frontmatter block.
+ *
+ * Accepted forms, at any indentation (the canonical one is
+ * `metadata.presetScope`):
+ *
+ * ```yaml
+ * metadata:
+ *   presetScope: [dsh-writing, dev]
+ *   presetScope:
+ *     - dsh-writing
+ * ```
+ * @param front - the frontmatter text without its `---` fences.
+ * @returns the declared ids, or undefined when the key is absent.
+ */
+export declare function parsePresetScopeFrontmatter(front: string): readonly string[] | undefined;
+/** Whether a string is a usable skill / preset id. */
+export declare function isKebabId(value: string): boolean;
+/** Split a SKILL.md into its frontmatter block and body. */
+export declare function splitFrontmatter(content: string): {
+    front: string;
+    body: string;
+} | undefined;
+/**
+ * Parse one managed `SKILL.md` into its delivery record.
+ * @param content - the file text.
+ * @param dir - the skill's directory (its resource base).
+ * @param path - the absolute `SKILL.md` path.
+ * @returns the record, or undefined when the frontmatter is unusable.
+ */
+export declare function managedSkillFrom(content: string, dir: string, path: string): ManagedSkill | undefined;
+/** Whether this skill asks to be delivered to a specific preset set. */
+export declare function isScoped(skill: ManagedSkill): boolean;
+/** Project one managed skill onto a provider candidate for one preset. */
+export declare function candidateFor(skill: ManagedSkill): SkillCandidate;
+/** Project one managed skill onto the complete definition the loader returns. */
+export declare function definitionFor(skill: ManagedSkill): SkillDefinition;
+/** The default roots a duplicate copy could live in. */
+export declare function defaultSkillRoots(dshHome: string, workdir?: string | undefined): readonly string[];
+/**
+ * Find managed names that a default root also supplies.
+ *
+ * A duplicate is what makes a scope claim false: the host provider delivers the
+ * default root's copy into every preset regardless of this module's decision.
+ * @param skills - the managed entries under consideration.
+ * @param dshHome - the harness home.
+ * @param workdir - the session workspace, when known.
+ * @returns skill name → the default root that already supplies it.
+ */
+export declare function detectConflicts(skills: readonly ManagedSkill[], dshHome: string, workdir?: string | undefined): Map<string, string>;
+/**
+ * Scan the managed root for skill directories.
+ * @param root - the managed skills root.
+ * @returns every readable, usable entry, sorted by name.
+ */
+export declare function scanManagedSkills(root: string): Promise<readonly ManagedSkill[]>;
+/**
+ * Delivers managed skills into the scope layers of the presets their
+ * frontmatter names.
+ *
+ * Lifecycle: {@link start} once (watcher + first reconcile), {@link reconcile}
+ * whenever policy or files may have changed, {@link dispose} when the owning
+ * plugin unloads. Reconciliation never fails loudly: every problem becomes a
+ * status field, because a catalog must not fail the boot of the instance it is
+ * describing.
+ */
+export declare class ScopedSkillDelivery {
+    private readonly ctx;
+    private readonly deps;
+    private readonly entries;
+    private managed;
+    private conflicts;
+    private presetErrors;
+    private watcher;
+    private timer;
+    private watching;
+    private failure;
+    private started;
+    private disposed;
+    /** The probed registry's mount list (undefined until start()'s probe resolves). */
+    private presetMounts;
+    /**
+     * @param ctx - the host context the delivery scopes are minted under.
+     * @param deps - borrowed services and paths, all optional at runtime.
+     */
+    constructor(ctx: Context, deps: ScopedDeliveryDeps);
+    /** Start watching the managed root and deliver what it currently holds. */
+    start(): Promise<void>;
+    /** Re-read policy and files, then converge the delivery registrations. */
+    reconcile(): Promise<void>;
+    /** The current status, for the settings surface and the model-facing tool. */
+    status(): ScopedDeliveryStatus;
+    /** Stop watching and dispose every delivery registration. */
+    dispose(): Promise<void>;
+    /** The managed root under the current harness home. */
+    private root;
+    /** Create the managed root if it is still absent. */
+    private ensureRoot;
+    /** Watch the managed root, degrading to on-demand rescans when it cannot. */
+    private watchRoot;
+    /** Coalesce a burst of filesystem events into one reconcile. */
+    private scheduleRescan;
+    /** The standing keys that still have a live mount in this process. */
+    private liveKeys;
+    /** Resolve one preset's standing key, remembering why it failed. */
+    private resolveKey;
+    /** Register one delivery provider into a preset's layer. */
+    private register;
+    /** Register the provider that serves every preset (the unscoped skills). */
+    private registerGlobal;
+    /**
+     * The provider serving one preset. It reads only its own preset's assignment
+     * and re-reads the files, so a policy or content edit needs no re-registration
+     * beyond the invalidation reconcile already performs.
+     */
+    private providerFor;
+    /** The managed skills one delivery currently serves. */
+    private skillsFor;
+    /** Invalidate every registration's completed catalogs. */
+    private invalidateAll;
+    /** Dispose every registration. */
+    private disposeEntries;
+    /** Dispose one registration and forget it. */
+    private dropEntry;
+}
+//# sourceMappingURL=scoped-delivery.d.ts.map