@wrongstack/core 0.277.2 → 0.280.1

package/dist/{selector-Cq72C0Oy.d.ts → selector-Dy-MzKp1.d.ts}

@@ -1,4 +1,4 @@
-import { M as Message } from './context-DPlA6kid.js';
+import { M as Message } from './tool-BkOgs_KL.js';
 
 /**
  * Result of LLM-driven message importance analysis.

package/dist/{session-event-bridge-DG94B3Bk.d.ts → session-event-bridge-CqdiGnfU.d.ts}

@@ -1,4 +1,4 @@
-import { S as SessionEvent, b as SessionWriter } from './context-DPlA6kid.js';
+import { S as SessionEvent, b as SessionWriter } from './tool-BkOgs_KL.js';
 
 type AuditLevel = 'minimal' | 'standard' | 'full';
 /**

package/dist/{session-reader-BzT-iMQT.d.ts → session-reader-Hk0WbNm9.d.ts}

@@ -1,4 +1,4 @@
-import { i as ContentBlock, S as SessionEvent, j as SessionMetadata, k as SessionStore } from './context-DPlA6kid.js';
+import { i as ContentBlock, S as SessionEvent, j as SessionMetadata, k as SessionStore } from './tool-BkOgs_KL.js';
 
 type AttachmentKind = 'text' | 'image' | 'file';
 interface AttachmentMeta {

package/dist/{skill-DGIXCtdv.d.ts → skill-DHniprNl.d.ts}

@@ -2,8 +2,20 @@ interface SkillManifest {
     name: string;
     description: string;
     version?: string | undefined;
+    /** agentskills.io optional frontmatter fields. */
+    license?: string | undefined;
+    compatibility?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    allowedTools?: string[] | undefined;
     path: string;
-    source: 'project' | 'user' | 'bundled';
+    /**
+     * Discovery layer the skill came from. `claude-*`, `foreign`, and `extra` are
+     * read-only foreign sources (other coding agents' dirs, or
+     * `config.skills.extraDirs`); they are never written to by the skill installer.
+     */
+    source: 'project' | 'user' | 'bundled' | 'claude-project' | 'claude-user' | 'extra' | 'foreign';
+    /** For `foreign` sources: the originating tool id (codex, cursor, agents, …). */
+    originTool?: string | undefined;
 }
 /** Parsed skill entry for structured rendering in system prompt. */
 interface SkillEntry {
@@ -13,6 +25,8 @@ interface SkillEntry {
     /** Comma-separated scope items */
     scope: string[];
     source: SkillManifest['source'];
+    /** For `foreign` sources: the originating tool id. */
+    originTool?: string | undefined;
     path: string;
 }
 interface SkillLoader {

package/dist/skills/index.d.ts

@@ -1,4 +1,226 @@
-import { S as SkillLoader } from '../skill-DGIXCtdv.js';
+import { b as SkillEntry, S as SkillLoader } from '../skill-DHniprNl.js';
+
+/**
+ * Well-known foreign coding-agent skill directories. All follow the
+ * agentskills.io `SKILL.md` format, so the same loader reads them — this just
+ * tells it WHERE each agent keeps them.
+ *
+ * Claude is handled separately by the loader (`claude-project` / `claude-user`
+ * sources); this list covers the OTHER agents. Every tool here stores skills
+ * under `~/.<tool>/skills` (+ `<project>/.<tool>/skills`).
+ *
+ * Dirs that don't exist are skipped gracefully, so listing many is cheap.
+ *
+ * NOTE: Cursor previously used a non-standard `skills-cursor` subdir. As of the
+ * 2026-07 alignment with the broader skills.sh / antfu-skills-cli / vercel-labs
+ * ecosystem, Cursor uses the standard `skills` subdir like everyone else.
+ * (`skills-cursor` was WrongStack-only and meant real Cursor skills were never
+ * discovered — see docs/skills.md.)
+ */
+interface ForeignSkillTool {
+    /** Tool id — also the directory name segment (`~/.<id>/…`). */
+    id: string;
+    /** Skills subdirectory name under `~/.<id>/`. */
+    subdir: string;
+}
+declare const FOREIGN_SKILL_TOOLS: readonly ForeignSkillTool[];
+/** Result of resolving a `foreignSources` config option. */
+interface ResolvedForeignTools {
+    /** Tool ids that will be scanned (subset of {@link FOREIGN_SKILL_TOOLS}). */
+    ids: string[];
+    /** Tool ids the user asked for that aren't known — likely typos (e.g. `corser`). */
+    unknownIds: string[];
+}
+/**
+ * Resolve the `config.skills.foreignSources` option into the list of tool ids
+ * to scan. Kept for backward compatibility (returns only `ids`).
+ * - `false` → none
+ * - `string[]` → only those ids (unknown ids silently dropped — see
+ *   {@link resolveForeignToolIdsWithWarnings} to surface them)
+ * - `true` / `undefined` → all well-known tools
+ */
+declare function resolveForeignToolIds(opt: boolean | string[] | undefined): string[];
+/**
+ * Like {@link resolveForeignToolIds}, but also returns tool ids the caller asked
+ * for that don't match any known agent. Callers that want to warn the user
+ * about a likely typo (e.g. `foreignSources: ["corser"]`) should prefer this.
+ *
+ * - `false` → none
+ * - `string[]` → known ids included, unknown ones returned in `unknownIds`
+ * - `true` / `undefined` → all well-known tools (no unknowns possible)
+ */
+declare function resolveForeignToolIdsWithWarnings(opt: boolean | string[] | undefined): ResolvedForeignTools;
+/**
+ * Security tier bucket for a registry skill's `securityScore` (0–100).
+ * Mirrors the ags (agentskill-sh/ags) thresholds: skills below 30 need
+ * explicit confirmation before install.
+ */
+type SkillSecurityTier = 'low' | 'medium' | 'high';
+/** Classify a 0–100 security score into a tier. 0/undefined → unknown → `low`. */
+declare function securityScoreToTier(score: number | undefined | null): SkillSecurityTier;
+
+/**
+ * Shared SKILL.md frontmatter parser + agentskills.io name validation.
+ *
+ * The SKILL.md format (https://agentskills.io/specification) is YAML
+ * frontmatter between `---` markers followed by a Markdown body. This parser is
+ * intentionally minimal — it handles the fields skills actually use, with YAML
+ * block scalars (`|` / `>`) for multi-line values and an indented map for
+ * `metadata`. It is NOT a general YAML parser; skill files are trusted markdown.
+ */
+interface ParsedSkillFrontmatter {
+    name?: string | undefined;
+    description?: string | undefined;
+    /** WrongStack extension; informational only. */
+    version?: string | undefined;
+    license?: string | undefined;
+    compatibility?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    /** `allowed-tools` (spec, experimental) → split on whitespace. */
+    allowedTools?: string[] | undefined;
+}
+/**
+ * Parse the YAML frontmatter block from a raw SKILL.md file. Returns `{}` when
+ * there is no (or unclosed) frontmatter — callers treat that as "skip".
+ *
+ * Line endings are normalized first: CRLF (and lone CR) would otherwise leave a
+ * trailing `\r` on each line, and since `.` / `$` don't match `\r`, the
+ * `key: value` regex would fail on every line and silently drop the whole
+ * frontmatter. Real skill files are frequently CRLF (Windows / some editors).
+ */
+declare function parseSkillFrontmatter(raw: string): ParsedSkillFrontmatter;
+/** Strip leading YAML frontmatter (`---\n…\n---`) from a SKILL.md file. */
+declare function stripFrontmatter(raw: string): string;
+/** True when `name` matches the agentskills.io name format (chars + length only). */
+declare function isValidSkillNameFormat(name: string): boolean;
+/**
+ * Validate a skill `name` against the agentskills.io spec:
+ * 1-64 chars; lowercase letters, digits, and single hyphens only; no
+ * leading/trailing/consecutive hyphens. Pass the parent directory name to also
+ * enforce the "name must match the parent directory" rule.
+ *
+ * Returns a list of human-readable violations (empty = valid).
+ */
+declare function validateSkillName(name: string, parentDirName?: string): string[];
+
+interface ParsedRef {
+    owner: string;
+    repo: string;
+    ref: string;
+}
+/**
+ * Parse a skill reference string.
+ * Formats: `user/repo` (default ref: main), `user/repo@ref`
+ */
+declare function parseSkillRef(input: string): ParsedRef;
+interface DownloadResult {
+    /** Temp directory containing the extracted repo. Caller must clean up. */
+    tempDir: string;
+}
+/**
+ * Download and extract a GitHub repository tarball.
+ *
+ * Auth: reads `WRONGSTACK_GITHUB_TOKEN` / `GITHUB_TOKEN` / `GH_TOKEN` (in that
+ * order). Without a token only public repos work; with one, private repos the
+ * token can read also work, and the API rate limit is the authenticated
+ * (much higher) limit instead of the anonymous 60/hour.
+ *
+ * Returns the path to a temp directory with the extracted contents. The caller
+ * must remove it (the installer does this in a `finally`).
+ */
+declare function downloadGitHubTarball(parsed: ParsedRef): Promise<DownloadResult>;
+
+/**
+ * Centralized skill system limits.
+ *
+ * Before this file existed, the magic numbers below were scattered across five
+ * modules (`skill-installer`, `github-fetcher`, `skill` tool, system-prompt
+ * builder, skill-loader), sometimes duplicated (e.g. per-skill body cap was
+ * defined independently in the builder and the tool). Centralizing them here
+ * keeps the budget model coherent — change one, change everywhere — and makes
+ * the trade-offs visible in one place.
+ *
+ * Values are frozen at their pre-centralization defaults so this is a pure
+ * refactor (no behavior change).
+ */
+declare const SKILL_LIMITS: {
+    /**
+     * Per-skill body cap when injecting a full skill body into the system prompt
+     * (eager mode), and when returning a skill body from the `skill` tool.
+     * ~4k tokens. Oversized bodies are truncated at a paragraph boundary.
+     *
+     * Consumers: `system-prompt-builder.capSkillBody`, `skill` tool body return.
+     */
+    readonly MAX_SKILL_BODY_CHARS: 16000;
+    /**
+     * Per-resource cap when the `skill` tool loads a bundled file
+     * (`scripts/`, `references/`, `assets/`). ~8k tokens.
+     *
+     * Consumer: `skill` tool `loadResource`.
+     */
+    readonly MAX_RESOURCE_CHARS: 32000;
+    /**
+     * Maximum number of bundled resource paths the `skill` tool lists in one
+     * response. Caps a pathological skill (huge `assets/` tree) from blowing up
+     * the tool result.
+     *
+     * Consumer: `skill` tool resource listing.
+     */
+    readonly MAX_LISTED_RESOURCES: 100;
+    /**
+     * Max size of a single installed skill file (SKILL.md or a bundled resource).
+     * Guards against a malicious registry skill shipping a multi-MB blob that
+     * then flows into the prompt. 100KB.
+     *
+     * Consumer: `SkillInstaller.install` / `importFromDir`.
+     */
+    readonly MAX_SKILL_FILE_SIZE: number;
+    /**
+     * Max size of a GitHub tarball downloaded by the skill installer. Guards
+     * against a repo accidentally (or maliciously) shipping a giant tarball that
+     * would be extracted into a temp dir. 50MB.
+     *
+     * Consumer: `downloadGitHubTarball`.
+     */
+    readonly MAX_TARBALL_SIZE: number;
+    /**
+     * Default total char budget for skill bodies injected in eager mode when
+     * `config.skills.eagerMaxChars` is unset. ~6k tokens. Skills are injected
+     * highest-priority first; once the budget is exhausted the remaining skills
+     * are listed as a manifest the agent loads via the `skill` tool. Set very
+     * high to effectively disable budgeting.
+     *
+     * Consumer: `DefaultSystemPromptBuilder.buildMemoryAndSkills` (default for
+     * `skillEagerMaxChars`).
+     */
+    readonly EAGER_DEFAULT_MAX_CHARS: 24000;
+    /**
+     * Auto-compact body limits (the token-saving fallback used when a skill has
+     * no hand-crafted `SKILL.save.md`). The Overview and Rules sections are
+     * extracted and trimmed to these char budgets, then the total is capped.
+     *
+     * Consumer: `DefaultSkillLoader.compactSkillBody`.
+     */
+    readonly COMPACT_OVERVIEW_MAX: 200;
+    readonly COMPACT_RULES_MAX: 350;
+    readonly COMPACT_TOTAL_MAX: 450;
+    /**
+     * Max length of a skill name (agentskills.io spec). Enforced by the
+     * frontmatter validator's format regex plus this length bound.
+     *
+     * Consumer: `isValidSkillNameFormat`.
+     */
+    readonly SKILL_NAME_MAX_LEN: 64;
+    /**
+     * Soft line limit for a SKILL.md body, per the bundled `skill-creator` rule.
+     * Not enforced in code (a skill can exceed it) — surfaced by `/skill-gen
+     * validate` and the `skill-creator` skill as guidance to move deep material
+     * into `references/`.
+     *
+     * Consumer: `skill-creator` skill, `/skill-gen validate` advisory.
+     */
+    readonly SKILL_BODY_LINE_LIMIT: 500;
+};
 
 interface InstalledSkillEntry {
     name: string;
@@ -14,6 +236,15 @@ interface InstalledSkillEntry {
     installedAt: string;
     /** List of files that were installed (relative to skill dir) */
     files: string[];
+    /**
+     * When the install was resolved through a registry (e.g. `skills.sh`), the
+     * adapter id + registry id that mapped to the GitHub `source`. Absent for
+     * direct `user/repo` installs.
+     */
+    registryFrom?: {
+        adapterId: string;
+        registryId: string;
+    } | undefined;
 }
 interface ManifestData {
     skills: InstalledSkillEntry[];
@@ -33,6 +264,200 @@ declare class SkillManifestStore {
     invalidateCache(): void;
 }
 
+/**
+ * Skill registry adapter contract.
+ *
+ * A registry is a searchable catalog of skills that resolves to a concrete
+ * install target (a GitHub `user/repo[@ref]`). Two adapters ship out of the
+ * box:
+ *
+ *   - `githubDirectAdapter`  — no search; `user/repo` is typed directly. This
+ *                              is the original pre-registry install path.
+ *   - `skillsShAdapter`     — searches the skills.sh marketplace
+ *                              (https://skills.sh/api/skills), which indexes
+ *                              34k+ skills from 2.8k+ repos and computes a
+ *                              per-skill security score (0–100).
+ *
+ * The adapter layer keeps the installer registry-agnostic: it asks each
+ * adapter to resolve a `<adapterId>:<registryId>` ref to a `user/repo@ref`
+ * and reuses the existing GitHub tarball path. New registries (an internal
+ * company hub, ags, …) are added by implementing this interface and passing
+ * them to the `SkillInstaller`.
+ */
+/**
+ * One hit from a registry search. Fields are optional where the underlying
+ * registry doesn't guarantee them — every adapter normalizes to this shape.
+ */
+interface RegistrySkillSummary {
+    /** Registry-native id (used as `<adapterId>:<id>` in `/skill-install`). */
+    id: string;
+    /** Skill name (kebab-case, as it will appear once installed). */
+    name: string;
+    /** Short description / trigger line. */
+    description: string;
+    /** Author / owner (often the GitHub owner). */
+    author?: string | undefined;
+    /** Install count, if the registry reports it. */
+    installs?: number | undefined;
+    /** Star count, if the registry reports it. */
+    stars?: number | undefined;
+    /**
+     * Security score 0–100 (skills.sh computes this; ags uses the same scale).
+     * Lower = riskier. Below 30 the install command prompts for confirmation.
+     */
+    securityScore?: number | undefined;
+    /** ISO timestamp of the skill's last update, if known. */
+    updatedAt?: string | undefined;
+    /**
+     * The `user/repo[@ref]` the installer passes to `downloadGitHubTarball`.
+     * Always present for real registry hits — it's the whole point of resolving.
+     */
+    installRef: string;
+}
+interface RegistrySearchOptions {
+    /** 1-indexed page (default 1). */
+    page?: number | undefined;
+    /** Page size (default 20; registries may cap this). */
+    pageSize?: number | undefined;
+}
+interface RegistrySearchResult {
+    /** Which adapter produced these results. */
+    adapterId: string;
+    results: RegistrySkillSummary[];
+    /** True when the registry indicates more pages exist. */
+    hasMore?: boolean | undefined;
+}
+/**
+ * A searchable skill catalog that resolves to a GitHub install target.
+ *
+ * `search` is optional in spirit (the github-direct adapter doesn't search),
+ * but the interface requires it so callers can fan out uniformly — adapters
+ * that can't search simply return `[]`.
+ */
+interface SkillRegistryAdapter {
+    /** Stable id used in `<adapterId>:<registryId>` refs (e.g. `'skills.sh'`). */
+    readonly id: string;
+    /** Human label for UI (e.g. `'skills.sh'`). */
+    readonly displayName: string;
+    /** Search the catalog. Return `[]` if the adapter doesn't support search. */
+    search(query: string, opts?: RegistrySearchOptions): Promise<RegistrySearchResult>;
+    /**
+     * Resolve a registry-native id to a `user/repo[@ref]` install ref. Should
+     * validate the id shape and throw on an id this adapter can't resolve.
+     */
+    resolveInstallRef(registryId: string): string;
+}
+
+/**
+ * GitHub-direct registry adapter.
+ *
+ * This is the original pre-registry install path wrapped in the adapter
+ * interface: the user types `user/repo[@ref]` directly. It does NOT search
+ * (GitHub code search is a separate API with its own auth/rate-limit story and
+ * isn't a skill catalog), so `search()` returns an empty result. Its job is
+ * solely to make `user/repo` flow through the same `<adapterId>:<registryId>`
+ * resolution as the skills.sh adapter — except here the "registry id" IS the
+ * install ref already.
+ *
+ * Registered as the fallback adapter so `/skill-install user/repo` keeps
+ * working unchanged when no `<adapterId>:` prefix is given.
+ */
+
+declare const githubDirectAdapter: SkillRegistryAdapter;
+
+/** Default skills.sh base URL. Override via `config.skills.registryUrl`. */
+declare const DEFAULT_SKILLS_SH_URL = "https://skills.sh";
+/** Injectable fetcher (mirrors the `prompt-installer` JsonFetcher pattern). */
+type SkillsShFetcher = (url: string) => Promise<unknown>;
+interface SkillsShAdapterOptions {
+    /** Base URL (no trailing slash). Defaults to {@link DEFAULT_SKILLS_SH_URL}. */
+    baseUrl?: string | undefined;
+    /** Injectable fetcher for tests. */
+    fetcher?: SkillsShFetcher | undefined;
+}
+declare function createSkillsShAdapter(opts?: SkillsShAdapterOptions): SkillRegistryAdapter;
+
+/** Result of validating a proposed skill name. */
+interface SkillNameValidation {
+    /** Whether the name is valid kebab-case AND free of collisions. */
+    ok: boolean;
+    /** Format violations (empty when the name is valid kebab-case). */
+    formatViolations: string[];
+    /** Existing skills with the same name (empty when there's no collision). */
+    conflicts: SkillEntry[];
+}
+/**
+ * Validate a proposed skill name: format (kebab-case, ≤64 chars) plus collision
+ * check against every skill the loader can see (project, user, foreign,
+ * bundled). A collision isn't fatal — project skills intentionally shadow
+ * lower layers — so `ok` is true when the only collision is with a foreign or
+ * bundled skill (intended shadowing), but `conflicts` is still populated so the
+ * user can decide. A collision with another project or user skill of the same
+ * name does fail (`ok: false`), since that would silently overwrite it.
+ */
+declare function validateSkillNameAvailable(name: string, loader?: SkillLoader): Promise<SkillNameValidation>;
+interface SkillSkeletonOptions {
+    name: string;
+    description: string;
+    /** Trigger keywords for the `Triggers:` line. */
+    triggerKeywords?: string[] | undefined;
+    /** Optional version (default `1.0.0`). */
+    version?: string | undefined;
+}
+/**
+ * Generate a SKILL.md body (with frontmatter) following the agentskills.io
+ * format and the `skill-creator` skill's recommended skeleton. Deterministic:
+ * the same inputs always produce the same output, and the result round-trips
+ * through `parseSkillFrontmatter` (so what we write is what the loader reads).
+ *
+ * The body is a skeleton — the user fills in Rules/Patterns/etc. The
+ * `skill-creator` skill is the right tool for the open-ended authoring; this
+ * is the scaffold.
+ */
+declare function generateSkillSkeleton(opts: SkillSkeletonOptions): string;
+/** Result of extracting a skill draft from a free-form prompt. */
+interface ExtractedSkillDraft {
+    /** Suggested name (kebab-case) derived from the prompt, or empty. */
+    suggestedName: string;
+    /** Description (first paragraph of the prompt). */
+    description: string;
+    /** Remaining prompt text, used as the skill body. */
+    body: string;
+    /** Trigger keywords extracted from the prompt. */
+    triggerKeywords: string[];
+}
+/**
+ * Heuristically extract a skill draft from a free-form prompt. No LLM — just
+ * light structure detection:
+ *   - First non-empty paragraph → `description`.
+ *   - A `# heading` or the first line → suggested kebab-case `suggestedName`.
+ *   - Remaining text → `body`.
+ *   - Quoted tokens and the heading words → `triggerKeywords`.
+ *
+ * The output is a starting point the user (or the skill-creator wizard) refines.
+ */
+declare function extractSkillFromPrompt(prompt: string): ExtractedSkillDraft;
+/**
+ * Open a file in the user's editor (`$VISUAL` → `$EDITOR` → platform default).
+ * Detached + unref'd so the editor outlives the WrongStack process. Throws a
+ * `WrongStackError` when no editor can be resolved.
+ */
+declare function openInEditor(filePath: string, env?: NodeJS.ProcessEnv): Promise<void>;
+/**
+ * Write a skeleton skill to `<skillsDir>/<name>/SKILL.md`. Returns the written
+ * path. Used by `/skill-gen skeleton` and `/skill-gen from-prompt`. Refuses to
+ * overwrite an existing SKILL.md unless `overwrite` is set — a guard against
+ * clobbering a hand-edited skill.
+ */
+declare function writeSkeletonSkill(skillsDir: string, body: string, opts?: {
+    overwrite?: boolean | undefined;
+}): Promise<string>;
+/** Soft length advisory for a SKILL.md body (the `skill-creator` 500-line rule). */
+declare function bodyLineAdvisory(body: string): {
+    lines: number;
+    over: boolean;
+};
+
 interface SkillInstallerOptions {
     /** Path to the manifest file (~/.wrongstack/installed-skills.json) */
     manifestPath: string;
@@ -45,7 +470,14 @@ interface SkillInstallerOptions {
     /** Skill loader — cache will be invalidated after mutations */
     skillLoader?: SkillLoader | undefined;
     /** Logger for status messages */
-    log?: (((msg: string) => void)) | undefined;
+    log?: ((msg: string) => void) | undefined;
+    /**
+     * Skill registries used to resolve `<adapterId>:<registryId>` refs and to
+     * serve `/skill-search`. Defaults to `[githubDirectAdapter]` (the original
+     * direct `user/repo` install path). Add a skills.sh adapter to enable
+     * searching the marketplace and installing registry hits by id.
+     */
+    registryAdapters?: SkillRegistryAdapter[] | undefined;
 }
 interface InstallResult {
     name: string;
@@ -70,14 +502,36 @@ interface UpdateResult {
 declare class SkillInstaller {
     private readonly opts;
     private readonly manifest;
+    private readonly adapters;
     constructor(opts: SkillInstallerOptions);
     /**
-     * Install skills from a GitHub repository.
-     * Supports both single-skill repos (SKILL.md at root) and multi-skill repos (skills/ subdirectory).
+     * Install skills from a skill reference.
+     *
+     * Accepts two ref formats:
+     *   - `user/repo[@ref]`               — direct GitHub install (original path)
+     *   - `<adapterId>:<registryId>`      — registry-resolved (e.g.
+     *                                       `skills.sh:owner/repo@v1`); the
+     *                                       adapter resolves it to a `user/repo`
+     *                                       ref and the install proceeds as above.
+     *
+     * Supports both single-skill repos (SKILL.md at root) and multi-skill repos
+     * (skills/ subdirectory). The manifest records the GitHub source as
+     * `github:owner/repo` (so `/skill-update` keeps working) plus the originating
+     * registry in `registryFrom` when the install came through a registry.
      */
     install(refInput: string, opts?: {
         global?: boolean | undefined;
     }): Promise<InstallResult[]>;
+    /**
+     * Import skills from a local directory (e.g. `.claude/skills`) into the
+     * project or user skills dir, optionally as symlinks. Used by `/skill-import`
+     * to take ownership of foreign skills so they can be edited/committed.
+     * Each direct subdirectory containing a valid `SKILL.md` is copied verbatim.
+     */
+    importFromDir(srcDir: string, opts?: {
+        global?: boolean | undefined;
+        link?: boolean | undefined;
+    }): Promise<InstallResult[]>;
     /**
      * Update installed skills.
      * - No args: update all
@@ -97,6 +551,13 @@ declare class SkillInstaller {
      * List all installed skills from the manifest.
      */
     listInstalled(): Promise<InstalledSkillEntry[]>;
+    /**
+     * Search across all configured registry adapters. Results from each adapter
+     * are merged (deduplicated by `installRef`, adapters earlier in the list win
+     * conflicts). Adapters that don't support search (e.g. github-direct)
+     * contribute nothing.
+     */
+    search(query: string, opts?: RegistrySearchOptions): Promise<RegistrySearchResult[]>;
     /**
      * Detect skills in an extracted repository.
      * Returns an array of detected skills with their files.
@@ -110,27 +571,12 @@ declare class SkillInstaller {
      * Invalidate the skill loader's cache so newly installed skills appear.
      */
     private invalidateLoaderCache;
+    /**
+     * Resolve an install ref, dispatching registry-prefixed refs to the matching
+     * adapter. Returns the concrete `user/repo[@ref]` install ref plus provenance
+     * (which adapter resolved it, if any).
+     */
+    private resolveRef;
 }
 
-interface ParsedRef {
-    owner: string;
-    repo: string;
-    ref: string;
-}
-/**
- * Parse a skill reference string.
- * Formats: `user/repo` (default ref: main), `user/repo@ref`
- */
-declare function parseSkillRef(input: string): ParsedRef;
-interface DownloadResult {
-    /** Temp directory containing the extracted repo. Caller must clean up. */
-    tempDir: string;
-}
-/**
- * Download and extract a GitHub repository tarball.
- * Uses the public GitHub API — no auth token required for public repos.
- * Returns the path to a temp directory with the extracted contents.
- */
-declare function downloadGitHubTarball(parsed: ParsedRef): Promise<DownloadResult>;
-
-export { type DownloadResult, type InstallResult, type InstalledSkillEntry, type ManifestData, type ParsedRef, SkillInstaller, type SkillInstallerOptions, SkillManifestStore, type UpdateResult, downloadGitHubTarball, parseSkillRef };
+export { DEFAULT_SKILLS_SH_URL, type DownloadResult, type ExtractedSkillDraft, FOREIGN_SKILL_TOOLS, type ForeignSkillTool, type InstallResult, type InstalledSkillEntry, type ManifestData, type ParsedRef, type ParsedSkillFrontmatter, type RegistrySearchOptions, type RegistrySearchResult, type RegistrySkillSummary, type ResolvedForeignTools, SKILL_LIMITS, SkillInstaller, type SkillInstallerOptions, SkillManifestStore, type SkillNameValidation, type SkillRegistryAdapter, type SkillSecurityTier, type SkillSkeletonOptions, type UpdateResult, bodyLineAdvisory, createSkillsShAdapter, downloadGitHubTarball, extractSkillFromPrompt, generateSkillSkeleton, githubDirectAdapter, isValidSkillNameFormat, openInEditor, parseSkillFrontmatter, parseSkillRef, resolveForeignToolIds, resolveForeignToolIdsWithWarnings, securityScoreToTier, stripFrontmatter, validateSkillName, validateSkillNameAvailable, writeSkeletonSkill };