sfora-cli 0.14.0 → 0.16.0

package/dist/local/workspace.js

@@ -1,3 +1,4 @@
+import { atomicWrite, withLocalLock } from "../local-core/files.js";
 /**
  * LocalWorkspace — the OSS local mode. A `.sfora/` directory in your repo is
  * the workspace: tasks, posts, and docs are plain markdown files on disk, in
@@ -224,32 +225,37 @@ export class LocalWorkspace {
      * scanning the board. The markdown is written verbatim — files are storage.
      */
     async writeTask(markdown, opts = {}) {
-        const parsed = parseMarkdownCard(markdown);
-        if (!parsed.title.trim()) {
-            throw new Error("Title is required — add an H1 (`# Title`) or a frontmatter `title:`");
-        }
-        const fmColumn = typeof parsed.frontmatter.column === "string"
-            ? parsed.frontmatter.column
-            : undefined;
-        const fmStatus = typeof parsed.frontmatter.status === "string"
-            ? parsed.frontmatter.status
-            : undefined;
-        const column = await this.#resolveColumn(opts.column ?? fmColumn, fmStatus);
-        // Existing card (by explicit frontmatter number) → replace in place,
-        // wherever it currently lives (the new write may also move it).
-        const fmNumber = typeof parsed.frontmatter.number === "string"
-            ? Number.parseInt(parsed.frontmatter.number, 10)
-            : undefined;
-        const existing = fmNumber !== undefined && Number.isFinite(fmNumber)
-            ? await this.#findByNumber(fmNumber)
-            : undefined;
-        if (existing) {
-            await rm(join(this.root, "board", existing.column, existing.filename));
-        }
-        const number = existing?.number ?? (await this.#nextNumber());
-        const filename = cardFilename({ number, title: parsed.title });
-        await writeFile(join(this.root, "board", column, filename), markdown, "utf8");
-        return { filename, column, number };
+        return withLocalLock(join(this.root, "board"), async () => {
+            const parsed = parseMarkdownCard(markdown);
+            if (!parsed.title.trim()) {
+                throw new Error("Title is required — add an H1 (`# Title`) or a frontmatter `title:`");
+            }
+            const fmColumn = typeof parsed.frontmatter.column === "string"
+                ? parsed.frontmatter.column
+                : undefined;
+            const fmStatus = typeof parsed.frontmatter.status === "string"
+                ? parsed.frontmatter.status
+                : undefined;
+            const column = await this.#resolveColumn(opts.column ?? fmColumn, fmStatus);
+            // Existing card (by explicit frontmatter number) → replace in place,
+            // wherever it currently lives (the new write may also move it).
+            const fmNumber = typeof parsed.frontmatter.number === "string"
+                ? Number.parseInt(parsed.frontmatter.number, 10)
+                : undefined;
+            const existing = fmNumber !== undefined && Number.isFinite(fmNumber)
+                ? await this.#findByNumber(fmNumber)
+                : undefined;
+            const number = existing?.number ?? (await this.#nextNumber());
+            const filename = cardFilename({ number, title: parsed.title });
+            const destination = join(this.root, "board", column, filename);
+            await atomicWrite(destination, markdown, 0o644);
+            if (existing) {
+                const previous = join(this.root, "board", existing.column, existing.filename);
+                if (previous !== destination)
+                    await rm(previous);
+            }
+            return { filename, column, number };
+        });
     }
     // ─── Posts & docs ────────────────────────────────────────────────
     async writePost(markdown, opts = {}) {
@@ -261,7 +267,7 @@ export class LocalWorkspace {
         const filename = `${date}-${slugify(parsed.title)}.md`;
         const dir = opts.draft ? "drafts" : "posts";
         await mkdir(join(this.root, dir), { recursive: true });
-        await writeFile(join(this.root, dir, filename), markdown, "utf8");
+        await withLocalLock(join(this.root, dir, filename), () => atomicWrite(join(this.root, dir, filename), markdown, 0o644));
         return { filename };
     }
     async writeDoc(markdown) {
@@ -271,7 +277,7 @@ export class LocalWorkspace {
         }
         const filename = noteFilename({ title: parsed.title });
         await mkdir(join(this.root, "docs"), { recursive: true });
-        await writeFile(join(this.root, "docs", filename), markdown, "utf8");
+        await withLocalLock(join(this.root, "docs", filename), () => atomicWrite(join(this.root, "docs", filename), markdown, 0o644));
         return { filename };
     }
     async listPosts(kind = "posts") {

package/dist/local-core/files.d.ts

@@ -0,0 +1,23 @@
+import { type FSWatcher } from "node:fs";
+export declare const sha256: (bytes: Uint8Array | string) => string;
+export declare class LocalConflictError extends Error {
+    readonly code = "LOCAL_CONFLICT";
+    constructor(message?: string);
+}
+/** Exclusive cross-process lock. A crashed process leaves an explicit recoverable lock;
+ * never steal a live/slow operation's lock based on a timeout. */
+export declare function withLocalLock<T>(path: string, operation: () => Promise<T>): Promise<T>;
+/** Write a complete staged file on the same filesystem before replacing the destination. */
+export declare function atomicWrite(path: string, content: string | Uint8Array, mode?: number): Promise<void>;
+export interface LocalMarkdownSnapshot {
+    path: string;
+    content: string;
+    revision: string;
+}
+export declare function readLocalMarkdown(path: string): Promise<LocalMarkdownSnapshot>;
+export declare function saveLocalMarkdown(path: string, content: string, expectedRevision: string): Promise<LocalMarkdownSnapshot>;
+/** Save As creates a new path only. Replacing an existing file requires its current revision. */
+export declare function atomicCreate(path: string, content: string | Uint8Array, mode?: number): Promise<string>;
+export declare function saveNewLocalMarkdown(path: string, content: string): Promise<LocalMarkdownSnapshot>;
+/** Watch the parent so atomic replacement by another editor remains observable. */
+export declare function watchLocalMarkdown(path: string, onChange: () => void): FSWatcher;

package/dist/local-core/files.js

@@ -0,0 +1,110 @@
+import { createHash, randomUUID } from "node:crypto";
+import { watch } from "node:fs";
+import { mkdir, open, readFile, realpath, rename, rm, stat, link } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+export const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+export class LocalConflictError extends Error {
+    code = "LOCAL_CONFLICT";
+    constructor(message = "The file changed on disk. Reload or save a separate copy.") { super(message); this.name = "LocalConflictError"; }
+}
+/** Exclusive cross-process lock. A crashed process leaves an explicit recoverable lock;
+ * never steal a live/slow operation's lock based on a timeout. */
+export async function withLocalLock(path, operation) {
+    const lock = `${path}.sfora-lock`;
+    const deadline = Date.now() + 5000;
+    for (;;) {
+        try {
+            await mkdir(lock, { mode: 0o700 });
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            if (Date.now() >= deadline)
+                throw new Error(`Local operation locked: ${lock}. If no Sfora process is using it, remove this lock directory and retry.`);
+            await delay(25);
+        }
+    }
+    try {
+        return await operation();
+    }
+    finally {
+        await rm(lock, { recursive: true, force: true });
+    }
+}
+/** Write a complete staged file on the same filesystem before replacing the destination. */
+export async function atomicWrite(path, content, mode = 0o600) {
+    const temporary = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+    const handle = await open(temporary, "wx", mode);
+    try {
+        await handle.writeFile(content);
+        await handle.sync();
+    }
+    catch (error) {
+        await rm(temporary, { force: true });
+        throw error;
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+const MAX_MARKDOWN_BYTES = 20 * 1024 * 1024;
+export async function readLocalMarkdown(path) {
+    const canonical = await realpath(path);
+    const info = await stat(canonical);
+    if (!info.isFile() || info.size > MAX_MARKDOWN_BYTES)
+        throw new Error("Select a regular Markdown file smaller than 20 MiB.");
+    const bytes = await readFile(canonical);
+    // Buffer decoding preserves BOM. Reject invalid UTF-8 instead of silently corrupting it.
+    const content = bytes.toString("utf8");
+    if (!Buffer.from(content, "utf8").equals(bytes))
+        throw new Error("This file is not valid UTF-8.");
+    return { path: canonical, content, revision: sha256(bytes) };
+}
+export async function saveLocalMarkdown(path, content, expectedRevision) {
+    const canonical = await realpath(path);
+    if (Buffer.byteLength(content) > MAX_MARKDOWN_BYTES)
+        throw new Error("Markdown exceeds 20 MiB.");
+    return withLocalLock(canonical, async () => {
+        const previous = await readLocalMarkdown(canonical);
+        if (previous.revision !== expectedRevision)
+            throw new LocalConflictError();
+        const mode = (await stat(canonical)).mode & 0o777;
+        await atomicWrite(canonical, content, mode);
+        return { path: canonical, content, revision: sha256(content) };
+    });
+}
+/** Save As creates a new path only. Replacing an existing file requires its current revision. */
+export async function atomicCreate(path, content, mode = 0o600) {
+    const destination = join(await realpath(dirname(resolve(path))), basename(path));
+    const temporary = `${destination}.${randomUUID()}.tmp`;
+    try {
+        await atomicWrite(temporary, content, mode);
+        // Hard link publishes atomically and fails EEXIST instead of overwriting a raced save.
+        await link(temporary, destination);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return destination;
+}
+export async function saveNewLocalMarkdown(path, content) {
+    if (Buffer.byteLength(content) > MAX_MARKDOWN_BYTES)
+        throw new Error("Markdown exceeds 20 MiB.");
+    const destination = await atomicCreate(path, content);
+    return { path: destination, content, revision: sha256(content) };
+}
+/** Watch the parent so atomic replacement by another editor remains observable. */
+export function watchLocalMarkdown(path, onChange) {
+    return watch(dirname(path), (_event, filename) => {
+        if (filename === null || filename.toString() === basename(path))
+            onChange();
+    });
+}

package/dist/local-core/index.d.ts

@@ -0,0 +1,16 @@
+/** Trusted Node-only operations shared by the CLI and Electron main process.
+ * Renderers must obtain native dialog grants; never expose these as arbitrary IPC paths. */
+export * from "./files.js";
+export * from "./skills.js";
+export * from "./skill-domain.js";
+export * from "./skill-discovery.js";
+export * from "./skill-store.js";
+export * from "./skill-service.js";
+export * from "./skill-sync.js";
+export * from "./skill-operations.js";
+export { SKILL_AGENT_ADAPTERS, projectSkillSources } from "./skill-adapters.js";
+export type { SkillAgentAdapter } from "./skill-adapters.js";
+export * from "./skill-local-executor.js";
+export * from "./skill-executor.js";
+export { SkillIndex } from './skill-index.js';
+export { SkillReviewService, type SkillReview } from './skill-review.js';

package/dist/local-core/index.js

@@ -0,0 +1,15 @@
+/** Trusted Node-only operations shared by the CLI and Electron main process.
+ * Renderers must obtain native dialog grants; never expose these as arbitrary IPC paths. */
+export * from "./files.js";
+export * from "./skills.js";
+export * from "./skill-domain.js";
+export * from "./skill-discovery.js";
+export * from "./skill-store.js";
+export * from "./skill-service.js";
+export * from "./skill-sync.js";
+export * from "./skill-operations.js";
+export { SKILL_AGENT_ADAPTERS, projectSkillSources } from "./skill-adapters.js";
+export * from "./skill-local-executor.js";
+export * from "./skill-executor.js";
+export { SkillIndex } from './skill-index.js';
+export { SkillReviewService } from './skill-review.js';

package/dist/local-core/skill-adapters.d.ts

@@ -0,0 +1,21 @@
+import type { SkillSource } from './skill-discovery.js';
+export interface SkillAgentAdapter {
+    id: string;
+    label: string;
+    globalPath: string;
+    projectPath: string;
+    depth: number;
+    /** A folder observation alone never establishes that an agent enables a skill. */
+    activation: 'unknown';
+    deploymentModes: readonly ['copy'];
+    caches: readonly {
+        id: string;
+        path: string;
+        label: string;
+        depth: number;
+    }[];
+}
+export declare const SKILL_AGENT_ADAPTERS: readonly SkillAgentAdapter[];
+export declare function defaultSkillSources(home?: string): SkillSource[];
+/** Caller explicitly selects/registers the project; never infer access from cwd in desktop. */
+export declare function projectSkillSources(project: string): SkillSource[];

package/dist/local-core/skill-adapters.js

@@ -0,0 +1,19 @@
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+export const SKILL_AGENT_ADAPTERS = [
+    { id: 'agents', label: 'Agents', globalPath: '.agents/skills', projectPath: '.agents/skills', depth: 1, activation: 'unknown', deploymentModes: ['copy'], caches: [] },
+    { id: 'codex', label: 'Codex', globalPath: '.codex/skills', projectPath: '.codex/skills', depth: 2, activation: 'unknown', deploymentModes: ['copy'], caches: [{ id: 'codex-plugin-cache', path: '.codex/plugins/cache', label: 'Codex plugin cache', depth: 6 }] },
+    { id: 'claude', label: 'Claude', globalPath: '.claude/skills', projectPath: '.claude/skills', depth: 1, activation: 'unknown', deploymentModes: ['copy'], caches: [{ id: 'claude-plugin-cache', path: '.claude/plugins/cache', label: 'Claude plugin cache', depth: 6 }] },
+    { id: 'cursor', label: 'Cursor', globalPath: '.cursor/skills', projectPath: '.cursor/skills', depth: 1, activation: 'unknown', deploymentModes: ['copy'], caches: [] },
+];
+export function defaultSkillSources(home = homedir()) {
+    return SKILL_AGENT_ADAPTERS.flatMap(adapter => [
+        { id: adapter.id, path: join(home, adapter.globalPath), label: adapter.label, depth: adapter.depth, kind: 'agent' },
+        ...adapter.caches.map(cache => ({ id: cache.id, path: join(home, cache.path), label: cache.label, depth: cache.depth, kind: 'cache' })),
+    ]);
+}
+/** Caller explicitly selects/registers the project; never infer access from cwd in desktop. */
+export function projectSkillSources(project) {
+    const root = resolve(project);
+    return SKILL_AGENT_ADAPTERS.map(adapter => ({ id: `project:${root}:${adapter.id}`, path: join(root, adapter.projectPath), label: `${adapter.label} · project`, depth: adapter.depth, kind: 'agent' }));
+}

package/dist/local-core/skill-discovery.d.ts

@@ -0,0 +1,22 @@
+export { defaultSkillSources } from './skill-adapters.js';
+export interface SkillSource {
+    path: string;
+    label: string;
+    depth: number;
+    id?: string;
+    kind?: "agent" | "cache" | "custom";
+}
+export interface LocalSkill {
+    path: string;
+    name: string;
+    sources: string[];
+    aliases: import("./skill-domain.js").SkillAlias[];
+    hash?: string;
+    fileCount?: number;
+    error?: string;
+}
+/** Bounded discovery; canonical aliases share a row. Bundles retain strict link/size checks. */
+export declare function discoverSkills(sources?: SkillSource[]): Promise<{
+    skills: LocalSkill[];
+    warnings: string[];
+}>;

package/dist/local-core/skill-discovery.js

@@ -0,0 +1,79 @@
+import { readdir, realpath, lstat } from 'node:fs/promises';
+import { defaultSkillSources } from './skill-adapters.js';
+export { defaultSkillSources } from './skill-adapters.js';
+import { join, basename } from 'node:path';
+import { readSkillBundle } from './skills.js';
+class ScanLimitError extends Error {
+}
+/** Bounded discovery; canonical aliases share a row. Bundles retain strict link/size checks. */
+export async function discoverSkills(sources = defaultSkillSources()) {
+    const found = new Map();
+    const warnings = [];
+    let visited = 0;
+    for (const source of sources) {
+        const seen = new Set();
+        async function walk(path, depth) {
+            if (++visited > 5000 || found.size >= 1000)
+                throw new ScanLimitError('Scan limit reached. Choose a narrower folder to find more skills.');
+            const canonical = await realpath(path);
+            if (seen.has(canonical)) {
+                const existing = found.get(canonical);
+                if (existing && !existing.aliases.some(a => a.sourceId === (source.id ?? source.path) && a.path === path))
+                    existing.aliases.push({ sourceId: source.id ?? source.path, path, label: source.label, kind: source.kind ?? "custom" });
+                return;
+            }
+            seen.add(canonical);
+            const entries = await readdir(canonical, { withFileTypes: true });
+            if (entries.some(entry => entry.name === 'SKILL.md')) {
+                const existing = found.get(canonical);
+                if (existing) {
+                    if (!existing.sources.includes(source.label))
+                        existing.sources.push(source.label);
+                    existing.aliases.push({ sourceId: source.id ?? source.path, path, label: source.label, kind: source.kind ?? "custom" });
+                    return;
+                }
+                const skill = { path: canonical, name: basename(canonical), sources: [source.label], aliases: [{ sourceId: source.id ?? source.path, path, label: source.label, kind: source.kind ?? "custom" }] };
+                found.set(canonical, skill);
+                try {
+                    const bundle = await readSkillBundle(canonical);
+                    skill.hash = bundle.hash;
+                    skill.fileCount = bundle.files.length;
+                }
+                catch (error) {
+                    skill.error = error instanceof Error ? error.message : String(error);
+                }
+                return;
+            }
+            if (depth === 0)
+                return;
+            for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+                if (['node_modules', '.git'].includes(entry.name))
+                    continue;
+                if (!entry.isDirectory() && !entry.isSymbolicLink())
+                    continue;
+                const child = join(path, entry.name);
+                try {
+                    if ((await lstat(await realpath(child))).isDirectory())
+                        await walk(child, depth - 1);
+                }
+                catch (error) {
+                    if (error instanceof ScanLimitError)
+                        throw error;
+                    warnings.push(`${source.label}: ${child}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        try {
+            await walk(source.path, source.depth);
+        }
+        catch (error) {
+            if (error instanceof ScanLimitError) {
+                warnings.push(error.message);
+                break;
+            }
+            if (error.code !== 'ENOENT')
+                warnings.push(`${source.label}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { skills: [...found.values()].sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path)), warnings };
+}

package/dist/local-core/skill-domain.d.ts

@@ -0,0 +1,74 @@
+/** Stable domain records. Names/hashes are labels/content, never identity or permission. */
+export interface SkillIdentity {
+    id: string;
+    createdAt: number;
+}
+export interface SkillAlias {
+    sourceId: string;
+    path: string;
+    label: string;
+    kind: 'agent' | 'cache' | 'custom';
+}
+export interface SkillLocation {
+    id: string;
+    skillId: string;
+    path: string;
+    aliases: SkillAlias[];
+    createdAt: number;
+}
+export interface SkillObservation {
+    locationId: string;
+    name: string;
+    observedAt: number;
+    hash?: string;
+    fileCount?: number;
+    error?: string;
+    availability: 'available' | 'unavailable';
+}
+export interface SkillRevision {
+    hash: string;
+    contentPolicy: 'bundle-v1';
+    cloudVersion?: number;
+}
+export interface CloudSkillIdentity {
+    deployment: string;
+    organizationId: string;
+    skillId: string;
+}
+export interface SkillCloudBinding {
+    id: string;
+    localSkillId: string;
+    remote: CloudSkillIdentity & {
+        projectId: string;
+    };
+    /** Authenticated member ID, never an API key or its fingerprint. */
+    accountId: string;
+    /** Lookup hints only; every lookup must revalidate the qualified IDs. */
+    locator: {
+        project: string;
+        name: string;
+    };
+    baseline?: SkillRevision;
+}
+export interface SkillProjectAssignment {
+    projectId: string;
+    remote: CloudSkillIdentity;
+    pinnedVersion: number;
+    overrideSkillId?: string;
+}
+export interface SkillAgentTarget {
+    skillId: string;
+    agentId: string;
+    path: string;
+    scope: 'global' | 'project';
+    mode: 'copy' | 'link';
+    ownership: 'managed' | 'unmanaged' | 'unknown';
+}
+export interface SkillOperation {
+    id: string;
+    kind: 'push' | 'pull' | 'install';
+    skillId: string;
+    expectedLocalHash?: string;
+    expectedRemote?: SkillRevision;
+    status: 'planned' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+}

package/dist/local-core/skill-executor.d.ts

@@ -0,0 +1,23 @@
+import { SkillOperationJournal, type SkillPushPorts } from './skill-operations.js';
+import type { SkillStore } from './skill-store.js';
+export declare class SkillOperationExecutor {
+    readonly store: SkillStore;
+    readonly journal: SkillOperationJournal;
+    readonly cloud: SkillPushPorts;
+    constructor(store: SkillStore, journal: SkillOperationJournal, cloud: SkillPushPorts);
+    apply(id: string, recover?: boolean): Promise<import("./skill-operations.js").SkillTransferOperation>;
+    /** Each item owns its durable outcome. Successful work is never replayed. */
+    batch(ids: string[], options?: {
+        recover?: boolean;
+        signal?: AbortSignal;
+        onResult?: (result: {
+            id: string;
+            status: string;
+            error?: string;
+        }) => void;
+    }): Promise<{
+        id: string;
+        status: string;
+        error?: string;
+    }[]>;
+}

package/dist/local-core/skill-executor.js

@@ -0,0 +1,51 @@
+import { SkillPushExecutor, operationDirection } from './skill-operations.js';
+import { SkillLocalExecutor } from './skill-local-executor.js';
+export class SkillOperationExecutor {
+    store;
+    journal;
+    cloud;
+    constructor(store, journal, cloud) {
+        this.store = store;
+        this.journal = journal;
+        this.cloud = cloud;
+    }
+    async apply(id, recover = false) {
+        const op = (await this.journal.list()).find(o => o.id === id);
+        if (!op)
+            throw new Error('Operation not found.');
+        return operationDirection(op.plan) === 'push'
+            ? new SkillPushExecutor(this.store, this.journal, this.cloud).apply(id, recover)
+            : new SkillLocalExecutor(this.store, this.journal, this.cloud).apply(id, recover);
+    }
+    /** Each item owns its durable outcome. Successful work is never replayed. */
+    async batch(ids, options = {}) {
+        if (!Array.isArray(ids) || !ids.length || ids.length > 1000 || new Set(ids).size !== ids.length || ids.some(id => typeof id !== 'string'))
+            throw new Error('Select 1–1000 distinct operation IDs.');
+        const operations = await this.journal.list();
+        if (ids.some(id => !operations.some(op => op.id === id)))
+            throw new Error('A selected operation no longer exists. Refresh before running.');
+        const results = [];
+        for (const id of ids) {
+            let result;
+            if (options.signal?.aborted) {
+                const op = (await this.journal.list()).find(o => o.id === id);
+                if (op.status === 'planned')
+                    result = { id, status: (await this.journal.cancel(id)).status };
+                else
+                    result = { id, status: op.status, error: ['succeeded', 'cancelled'].includes(op.status) ? undefined : 'Batch stopped before this item; its previous outcome is retained.' };
+            }
+            else {
+                try {
+                    result = { id, status: (await this.apply(id, options.recover)).status };
+                }
+                catch (error) {
+                    const current = (await this.journal.list()).find(o => o.id === id);
+                    result = { id, status: current.status, error: error.message };
+                }
+            }
+            results.push(result);
+            options.onResult?.(result);
+        }
+        return results;
+    }
+}

package/dist/local-core/skill-index.d.ts

@@ -0,0 +1,54 @@
+import { SkillService } from './skill-service.js';
+/** Events are hints; periodic reconciliation repairs missed events and root changes. */
+export declare class SkillIndex {
+    readonly service: SkillService;
+    readonly changed: () => void;
+    readonly reconciliationMs: number;
+    private watchers;
+    private timer?;
+    private interval?;
+    private pending;
+    private full;
+    private running;
+    private active?;
+    private closed;
+    private started?;
+    private warnings;
+    constructor(service: SkillService, changed?: () => void, reconciliationMs?: number);
+    start(): Promise<void>;
+    inventory(): Promise<{
+        warnings: string[];
+        skills: {
+            skillId: string;
+            locationId: string;
+            path: string;
+            name: string;
+            sources: string[];
+            aliases: import("./skill-domain.js").SkillAlias[];
+            hash: string | undefined;
+            fileCount: number | undefined;
+            error: string | undefined;
+            availability: "available" | "unavailable";
+        }[];
+    }>;
+    invalidate(path?: string): void;
+    private configure;
+    refresh(): Promise<{
+        warnings: string[];
+        skills: {
+            skillId: string;
+            locationId: string;
+            path: string;
+            name: string;
+            sources: string[];
+            aliases: import("./skill-domain.js").SkillAlias[];
+            hash: string | undefined;
+            fileCount: number | undefined;
+            error: string | undefined;
+            availability: "available" | "unavailable";
+        }[];
+    }>;
+    private flush;
+    private perform;
+    close(): void;
+}