@vellumai/assistant 0.12.2-staging.4 → 0.12.2-staging.6

package/src/cli/lib/inspect-plugin.ts

@@ -27,6 +27,7 @@ import {
   type InstalledPluginInfo,
   readInstalledPlugin,
 } from "./list-installed-plugins.js";
+import { readBundledLocalPluginCatalog } from "./plugin-catalog-local.js";
 import { DEFAULT_PLUGIN_REF } from "./plugin-constants.js";
 import {
   compareFingerprint,
@@ -40,6 +41,7 @@ import {
   detectPluginSurfaces,
   type PluginSurfaces,
 } from "./plugin-surfaces.js";
+import type { PluginCatalog, PluginSearchMatch } from "./search-plugins.js";
 
 /** Full commit SHA (40 hex SHA-1 or 64 hex SHA-256). */
 const FULL_SHA_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
@@ -101,6 +103,8 @@ export interface PluginLocalInfo {
 
 /** The marketplace's current pin and advertised metadata for a plugin. */
 export interface PluginRemoteInfo {
+  /** Present for a package embedded in the assistant distribution. */
+  readonly kind?: "local";
   /** `owner/repo` of the external plugin repository. */
   readonly repo: string;
   /** Repo-relative directory holding the plugin root; `""` = repo root. */
@@ -119,6 +123,8 @@ export interface PluginRemoteInfo {
   readonly category: string | null;
   /** Ref of the canonical repo the marketplace manifest was read from. */
   readonly marketplaceRef: string;
+  /** Bundled package version. Present when {@link kind} is `local`. */
+  readonly version?: string;
 }
 
 /** Resolved inspection of a single plugin. */
@@ -165,6 +171,8 @@ export interface InspectPluginDeps {
   readonly fetch: FetchLike;
   /** Override the workspace plugins directory. Falls back to the live workspace. */
   readonly workspacePluginsDir?: string;
+  /** Override the embedded local-package catalog for focused tests. */
+  readonly localCatalog?: PluginCatalog;
 }
 
 function readLocal(
@@ -177,7 +185,7 @@ function readLocal(
   // revision instead of dropping to "unknown".
   const commit =
     manifest?.commit ??
-    (manifest && FULL_SHA_RE.test(manifest.source.ref)
+    (manifest?.source.kind === "github" && FULL_SHA_RE.test(manifest.source.ref)
       ? manifest.source.ref
       : null);
   // Compare the on-disk tree against the install-time baseline, applying the
@@ -203,6 +211,21 @@ function readRemote(
   marketplaceRef: string,
   committedAt: string | null,
 ): PluginRemoteInfo {
+  if (entry.source.source === "local") {
+    return {
+      kind: "local",
+      repo: "",
+      path: entry.source.path,
+      commit: entry.source.version,
+      committedAt: null,
+      description: entry.description ?? null,
+      homepage: entry.homepage ?? null,
+      license: entry.license ?? null,
+      category: entry.category ?? null,
+      marketplaceRef,
+      version: entry.source.version,
+    };
+  }
   return {
     repo: entry.source.repo,
     path: entry.source.path ?? "",
@@ -216,6 +239,28 @@ function readRemote(
   };
 }
 
+function readLocalPackageRemote(
+  match: PluginSearchMatch,
+  marketplaceRef: string,
+): PluginRemoteInfo | null {
+  if (match.source.kind !== "local") {
+    return null;
+  }
+  return {
+    kind: "local",
+    repo: "",
+    path: match.source.path,
+    commit: match.source.version,
+    committedAt: null,
+    description: match.description ?? null,
+    homepage: match.homepage ?? null,
+    license: match.license ?? null,
+    category: match.category,
+    marketplaceRef,
+    version: match.source.version,
+  };
+}
+
 /**
  * Resolve the committer date of a pinned commit from GitHub, normalized to a
  * UTC ISO-8601 string so it is directly comparable with the install-time
@@ -292,19 +337,34 @@ export async function inspectPlugin(
 
   let remote: PluginRemoteInfo | null = null;
   let remoteError: string | null = null;
+  const installedLocalSource = local?.source?.kind === "local";
   try {
-    const entries = await fetchMarketplaceEntries(
-      { fetch: deps.fetch },
-      { ref: marketplaceRef },
-    );
-    const match = entries.find((e) => e.name === name);
-    if (match) {
-      const committedAt = await fetchCommitDate(
-        match.source.repo,
-        match.source.ref,
-        deps.fetch,
+    if (installedLocalSource) {
+      const catalog = deps.localCatalog ?? readBundledLocalPluginCatalog();
+      const match = catalog.matches.find(
+        (candidate) =>
+          candidate.name === name &&
+          candidate.source.kind === "local" &&
+          candidate.source.path === local.source?.path,
       );
-      remote = readRemote(match, marketplaceRef, committedAt);
+      remote = match ? readLocalPackageRemote(match, catalog.ref) : null;
+    } else {
+      const entries = await fetchMarketplaceEntries(
+        { fetch: deps.fetch },
+        { ref: marketplaceRef },
+      );
+      const match = entries.find((entry) => entry.name === name);
+      if (match) {
+        const committedAt =
+          match.source.source === "github"
+            ? await fetchCommitDate(
+                match.source.repo,
+                match.source.ref,
+                deps.fetch,
+              )
+            : null;
+        remote = readRemote(match, marketplaceRef, committedAt);
+      }
     }
   } catch (err) {
     remoteError = err instanceof Error ? err.message : String(err);
@@ -335,6 +395,14 @@ function classify(
   if (!remote) {
     return "not-in-marketplace";
   }
+  if (remote.kind === "local") {
+    if (local?.source?.kind !== "local") {
+      return "unknown-provenance";
+    }
+    return local.source.version === remote.version
+      ? "up-to-date"
+      : "update-available";
+  }
   if (!local?.commit) {
     return "unknown-provenance";
   }

package/src/cli/lib/install-from-github.ts

@@ -1,13 +1,12 @@
 /**
- * Install a plugin by name from the canonical GitHub source.
+ * Install a reviewed plugin by name from its catalog source.
  *
- * A name resolves to a whitelisted external ecosystem plugin — an entry in the
- * curated `plugins/marketplace.json` manifest. The pinned
- * `owner/repo[/path]@ref` (see {@link ./plugin-marketplace}) is fetched with a
- * shallow `git` clone at that ref — one network operation regardless of repo
- * size, immune to GitHub's unauthenticated API rate-limit, and recording the
- * exact resolved commit for provenance — and materialized into
- * `<workspacePluginsDir>/<name>/` so the daemon discovers it on next start.
+ * A name resolves to an entry in the curated `plugins/marketplace.json`
+ * manifest. A GitHub source is fetched with a shallow clone at its pinned ref.
+ * A local source is read from the exact package version embedded in the
+ * assistant distribution. Both are materialized into
+ * `<workspacePluginsDir>/<name>/` and record their source in the provenance
+ * sidecar.
  *
  * When we curate an adapter stub for the plugin (a `plugins/<name>/` directory
  * in this repo with a `scripts.postinstall` command), the stub is overlaid
@@ -56,6 +55,7 @@ import {
   getPluginManifestInstallAction,
   readPluginManifest,
 } from "../../util/plugin-manifest.js";
+import { materializeBundledPluginPackage } from "./bundled-plugin-packages.js";
 import type { FetchLike } from "./fetch-like.js";
 import {
   type DependencyInstaller,
@@ -151,20 +151,13 @@ export interface InstallPluginOptions {
    */
   readonly directSource?: PluginFetchSource;
   /**
-   * Install from these PRE-RESOLVED, TRUSTED GitHub coordinates while STILL
-   * overlaying the curated `plugins/<name>` adapter stub. This is the offline
-   * analogue of a marketplace install: the pin came from the reviewed bundled
-   * catalog instead of a live marketplace fetch, so — unlike
-   * {@link InstallPluginOptions.directSource} — the source is trusted and the
-   * adapter stub is kept. `trustedSource` names the EXTERNAL plugin repo, so
-   * `trustedSource.ref` (its immutable content commit) cannot address the stub,
-   * which lives in this repo; the stub is fetched from the canonical repo at
-   * {@link InstallPluginOptions.ref} (default {@link DEFAULT_PLUGIN_REF}) — the
-   * bundled catalog records no canonical-repo pin. When set, marketplace
-   * resolution and {@link InstallPluginOptions.commitOverride} are skipped;
-   * `trustedSource.ref` selects the commit to clone (the reviewed pin).
+   * Install from an exact source resolved by the reviewed catalog. GitHub
+   * sources retain the curated adapter overlay. Local sources are complete
+   * packages embedded in the assistant distribution and do not use an adapter.
+   * Marketplace resolution and {@link InstallPluginOptions.commitOverride} are
+   * skipped when this is set.
    */
-  readonly trustedSource?: PluginFetchSource;
+  readonly trustedSource?: PluginMaterializeSource;
 }
 
 /**
@@ -197,6 +190,8 @@ export interface InstallPluginDeps {
   readonly beforeSwap?: () => Promise<void>;
   /** Consent gate between staging and finalize; see {@link ConfirmStagedInstall}. */
   readonly confirmStaged?: ConfirmStagedInstall;
+  /** Override embedded-package materialization for focused tests. */
+  readonly materializeLocalPackage?: typeof materializeBundledPluginPackage;
 }
 
 /** Successful install result. */
@@ -319,21 +314,39 @@ export interface PluginFetchSource {
   readonly ref: string;
 }
 
+/** Reviewed package embedded in the assistant distribution. */
+export interface LocalPluginFetchSource {
+  readonly kind: "local";
+  readonly path: string;
+  readonly version: string;
+  readonly ref?: undefined;
+}
+
+export type PluginMaterializeSource =
+  | PluginFetchSource
+  | LocalPluginFetchSource;
+
+export function isLocalPluginSource(
+  source: PluginMaterializeSource,
+): source is LocalPluginFetchSource {
+  return "kind" in source && source.kind === "local";
+}
+
 /** Build the `owner/repo/path` label used in not-found errors. */
-function sourceLabel(source: PluginFetchSource): string {
+function sourceLabel(source: PluginMaterializeSource): string {
+  if (isLocalPluginSource(source)) {
+    return source.path;
+  }
   return source.rootPath
     ? `${source.owner}/${source.repo}/${source.rootPath}`
     : `${source.owner}/${source.repo}`;
 }
 
 /**
- * Resolve a plugin name to the concrete GitHub coordinates of its pinned
- * marketplace entry, or `null` when no entry claims the name.
- *
- * The marketplace is external-only by construction — a same-named
- * `plugins/<name>` directory is the plugin's optional *adapter stub* (a curated
- * `package.json` + postinstall script overlaid onto the clone to translate it
- * into Vellum's shape; see {@link applyAdapterStub}), not a standalone plugin.
+ * Resolve a plugin name to its exact marketplace source, or `null` when no
+ * entry claims the name. A GitHub entry may have a same-named adapter stub
+ * under `plugins/<name>` that is overlaid onto the clone. A local entry refers
+ * to a fully self-contained package embedded in the assistant distribution.
  *
  * A transient marketplace failure (rate-limit / 5xx) surfaces as a retryable
  * {@link PluginSourceUnavailableError}; a malformed manifest propagates as a
@@ -344,7 +357,7 @@ async function resolvePluginSource(
   name: string,
   marketplaceRef: string,
   fetchFn: FetchLike,
-): Promise<PluginFetchSource | null> {
+): Promise<PluginMaterializeSource | null> {
   let resolved: ResolvedPluginSource | null;
   try {
     const entries = await fetchMarketplaceEntries(
@@ -363,6 +376,14 @@ async function resolvePluginSource(
     return null;
   }
 
+  if (resolved.kind === "local") {
+    return {
+      kind: "local",
+      path: resolved.path,
+      version: resolved.version,
+    };
+  }
+
   return {
     owner: resolved.owner,
     repo: resolved.repo,
@@ -460,7 +481,7 @@ export async function installPlugin(
   // adapter stub). A trusted pre-resolved source (offline bundled-catalog
   // install) supplies its coordinates too but keeps the curated overlay.
   // Otherwise the name is resolved against the reviewed manifest.
-  let effectiveSource: PluginFetchSource;
+  let effectiveSource: PluginMaterializeSource;
   // Ref the curated adapter stub is fetched at, or `null` to skip the overlay.
   let stubRef: string | null;
   if (opts.directSource) {
@@ -474,7 +495,7 @@ export async function installPlugin(
     // recorded offline, the stub is fetched at `marketplaceRef` (its default,
     // DEFAULT_PLUGIN_REF).
     effectiveSource = opts.trustedSource;
-    stubRef = marketplaceRef;
+    stubRef = isLocalPluginSource(effectiveSource) ? null : marketplaceRef;
   } else {
     const source = await resolvePluginSource(name, marketplaceRef, deps.fetch);
     if (!source) {
@@ -487,12 +508,15 @@ export async function installPlugin(
     // A commit override installs a specific plugin revision while still taking
     // owner/repo/path (and the adapter stub, via `marketplaceRef`) from the
     // manifest; otherwise the reviewed pin from the manifest is materialized.
-    effectiveSource = opts.commitOverride
-      ? { ...source, ref: opts.commitOverride }
-      : source;
-    stubRef = marketplaceRef;
+    effectiveSource =
+      opts.commitOverride && !isLocalPluginSource(source)
+        ? { ...source, ref: opts.commitOverride }
+        : source;
+    stubRef = isLocalPluginSource(effectiveSource) ? null : marketplaceRef;
   }
-  const ref = effectiveSource.ref;
+  const ref = isLocalPluginSource(effectiveSource)
+    ? effectiveSource.version
+    : effectiveSource.ref;
 
   const pluginsDir = deps.workspacePluginsDir ?? getWorkspacePluginsDir();
   const target = join(pluginsDir, name);
@@ -595,7 +619,7 @@ export async function confirmStagedOrAbort(
 export interface FinalizeStagedInstallParams {
   readonly name: string;
   /** Source coordinates recorded in the provenance sidecar. */
-  readonly source: PluginFetchSource;
+  readonly source: PluginMaterializeSource;
   /** Ref recorded in the sidecar (the resolved commit SHA for marketplace installs). */
   readonly ref: string;
   readonly commit: string | null;
@@ -735,16 +759,22 @@ export const INSTALL_META_FILENAME = "install-meta.json";
 export type InstallOrigin = "vellum";
 
 /** Resolved source coordinates recorded in the provenance sidecar. */
-export interface InstallMetaSource {
-  /** Source kind. Only `github` is written today. */
-  readonly kind: string;
-  readonly owner: string;
-  readonly repo: string;
-  /** Repo-relative directory holding the plugin root; absent = repo root. */
-  readonly path?: string;
-  /** Ref the install resolved through (the pinned commit SHA for marketplace installs). */
-  readonly ref: string;
-}
+export type InstallMetaSource =
+  | {
+      readonly kind: "github";
+      readonly owner: string;
+      readonly repo: string;
+      readonly path?: string;
+      readonly ref: string;
+    }
+  | {
+      readonly kind: "local";
+      readonly path: string;
+      readonly version: string;
+      readonly owner?: undefined;
+      readonly repo?: undefined;
+      readonly ref?: undefined;
+    };
 
 /**
  * Parsed contents of the `install-meta.json` provenance sidecar — what was
@@ -839,7 +869,7 @@ export interface MaterializedTree {
 export async function materializePluginTree(
   opts: {
     /** Source coordinates; `source.ref` selects the commit to clone. */
-    readonly source: PluginFetchSource;
+    readonly source: PluginMaterializeSource;
     /** Install name, used to locate the curated adapter stub. */
     readonly name: string;
     /**
@@ -854,11 +884,19 @@ export async function materializePluginTree(
   },
   deps: InstallPluginDeps,
 ): Promise<MaterializedTree> {
-  const cloned = await copyExternalViaGit(
-    opts.source,
-    opts.destDir,
-    deps.runGit ?? defaultGitRunner,
-  );
+  const cloned = isLocalPluginSource(opts.source)
+    ? {
+        fileCount: (
+          deps.materializeLocalPackage ?? materializeBundledPluginPackage
+        )(opts.source.path, opts.source.version, opts.destDir),
+        commit: null,
+        committedAt: null,
+      }
+    : await copyExternalViaGit(
+        opts.source,
+        opts.destDir,
+        deps.runGit ?? defaultGitRunner,
+      );
   // An external clone is often a foreign-ecosystem plugin (e.g. a Claude Code
   // plugin) that the Vellum loader can't run as-is. When we curate an adapter
   // stub for it, overlay the stub and run its transform so the materialized
@@ -1551,7 +1589,7 @@ export async function resolveTreeRefPath(
 /** Inputs for {@link writeInstallMeta}, resolved during a fresh install. */
 interface WriteInstallMetaParams {
   readonly name: string;
-  readonly source: PluginFetchSource;
+  readonly source: PluginMaterializeSource;
   readonly ref: string;
   readonly commit: string | null;
   /** ISO-8601 committer timestamp of {@link WriteInstallMetaParams.commit} (UTC); null when unknown. */
@@ -1598,21 +1636,24 @@ function writeInstallMeta(
     contentHash,
   }: WriteInstallMetaParams,
 ): void {
+  const local = isLocalPluginSource(source);
   const meta: InstallMeta = {
     origin: "vellum",
     installedAt: new Date().toISOString(),
     version: readStagedManifestVersion(stagingDir),
-    sourceRepo: `${source.owner}/${source.repo}`,
+    sourceRepo: local ? undefined : `${source.owner}/${source.repo}`,
     contentHash,
     author: "user",
     name,
-    source: {
-      kind: "github",
-      owner: source.owner,
-      repo: source.repo,
-      path: source.rootPath || undefined,
-      ref,
-    },
+    source: local
+      ? { kind: "local", path: source.path, version: source.version }
+      : {
+          kind: "github",
+          owner: source.owner,
+          repo: source.repo,
+          path: source.rootPath || undefined,
+          ref,
+        },
     commit,
     committedAt,
     ...(etag ? { etag } : {}),
@@ -1656,15 +1697,37 @@ export function readInstallMeta(pluginDir: string): InstallMeta | null {
     return null;
   }
   const source = src as Record<string, unknown>;
-  if (
-    typeof obj.name !== "string" ||
-    typeof source.owner !== "string" ||
-    typeof source.repo !== "string" ||
-    typeof source.ref !== "string"
-  ) {
+  if (typeof obj.name !== "string") {
     return null;
   }
 
+  let parsedSource: InstallMetaSource;
+  if (source.kind === "local") {
+    if (typeof source.path !== "string" || typeof source.version !== "string") {
+      return null;
+    }
+    parsedSource = {
+      kind: "local",
+      path: source.path,
+      version: source.version,
+    };
+  } else {
+    if (
+      typeof source.owner !== "string" ||
+      typeof source.repo !== "string" ||
+      typeof source.ref !== "string"
+    ) {
+      return null;
+    }
+    parsedSource = {
+      kind: "github",
+      owner: source.owner,
+      repo: source.repo,
+      path: typeof source.path === "string" ? source.path : undefined,
+      ref: source.ref,
+    };
+  }
+
   const optionalString = (value: unknown): string | undefined =>
     typeof value === "string" ? value : undefined;
 
@@ -1682,13 +1745,7 @@ export function readInstallMeta(pluginDir: string): InstallMeta | null {
         ? obj.author
         : undefined,
     name: obj.name,
-    source: {
-      kind: typeof source.kind === "string" ? source.kind : "github",
-      owner: source.owner,
-      repo: source.repo,
-      path: typeof source.path === "string" ? source.path : undefined,
-      ref: source.ref,
-    },
+    source: parsedSource,
     commit: typeof obj.commit === "string" ? obj.commit : null,
     ...(typeof obj.etag === "string" ? { etag: obj.etag } : {}),
     committedAt: typeof obj.committedAt === "string" ? obj.committedAt : null,

package/src/cli/lib/plugin-catalog-cache.ts

@@ -9,7 +9,10 @@
  */
 
 import { arePlatformFeaturesEnabled } from "../../platform/feature-gate.js";
-import { readBundledPluginCatalog } from "./plugin-catalog-local.js";
+import {
+  readBundledLocalPluginCatalog,
+  readBundledPluginCatalog,
+} from "./plugin-catalog-local.js";
 import { fetchPluginCatalogFromPlatform } from "./plugin-catalog-platform.js";
 import type { PluginCatalog, SearchPluginsDeps } from "./search-plugins.js";
 
@@ -23,6 +26,21 @@ interface CacheEntry {
 
 const cache = new Map<string, CacheEntry>();
 
+/** Add bundled local packages without overriding platform-authoritative rows. */
+export function mergePlatformCatalogWithBundledLocals(
+  platform: PluginCatalog,
+  bundledLocal: PluginCatalog = readBundledLocalPluginCatalog(),
+): PluginCatalog {
+  const seen = new Set(platform.matches.map((match) => match.name));
+  return {
+    ref: platform.ref,
+    matches: [
+      ...platform.matches,
+      ...bundledLocal.matches.filter((match) => !seen.has(match.name)),
+    ].sort((a, b) => a.name.localeCompare(b.name)),
+  };
+}
+
 /**
  * Resolve the full plugin catalog at {@link ref}.
  *
@@ -46,8 +64,9 @@ export async function getPluginCatalog(
   }
 
   const catalog = await fetchPluginCatalogFromPlatform(deps, { ref });
-  cache.set(ref, { catalog, timestamp: Date.now() });
-  return catalog;
+  const merged = mergePlatformCatalogWithBundledLocals(catalog);
+  cache.set(ref, { catalog: merged, timestamp: Date.now() });
+  return merged;
 }
 
 /** Invalidate the cache (for testing or forced refresh). */

package/src/cli/lib/plugin-catalog-local.ts

@@ -61,10 +61,20 @@ export function readBundledPluginCatalog(): PluginCatalog {
   return memoized;
 }
 
+/** Local packages the current assistant release can materialize itself. */
+export function readBundledLocalPluginCatalog(): PluginCatalog {
+  return {
+    ref: "bundled",
+    matches: projectMarketplaceEntries(
+      bundledEntries().filter((entry) => entry.source.source === "local"),
+    ),
+  };
+}
+
 /**
- * Resolve an install name to its pinned GitHub source from the bundled manifest,
- * or `null` when no bundled entry claims the name. The offline analogue of
- * resolving against the remote-fetched marketplace — used when platform
+ * Resolve an install name to its exact source from the bundled manifest, or
+ * `null` when no bundled entry claims the name. The offline analogue of
+ * resolving against the remote-fetched marketplace, used when platform
  * features are disabled and `assistant plugins install <name>` must resolve the
  * pin without any network call.
  */

package/src/cli/lib/plugin-catalog-platform.ts

@@ -16,7 +16,10 @@
 import { z } from "zod";
 
 import { getPlatformBaseUrl } from "../../config/env.js";
-import type { MarketplaceEntry } from "./plugin-marketplace.js";
+import {
+  type MarketplaceEntry,
+  mcpIntegrationSchema,
+} from "./plugin-marketplace.js";
 import {
   type PluginCatalog,
   PluginCatalogUnavailableError,
@@ -38,6 +41,7 @@ const platformPluginRowSchema = z.object({
   category: z.string().nullable().optional(),
   homepage: z.string().nullable().optional(),
   license: z.string().nullable().optional(),
+  integration: mcpIntegrationSchema.nullable().optional(),
 });
 
 const platformCatalogSchema = z.object({
@@ -112,6 +116,7 @@ export async function fetchPluginCatalogFromPlatform(
       category: row.category ?? undefined,
       homepage: row.homepage ?? undefined,
       license: row.license ?? undefined,
+      integration: row.integration ?? undefined,
     });
   }
 

package/src/cli/lib/plugin-catalog-resolve.ts

@@ -12,6 +12,7 @@ import { getPluginCatalog } from "./plugin-catalog-cache.js";
 import { DEFAULT_PLUGIN_REF } from "./plugin-constants.js";
 import {
   githubSourceSchema,
+  localSourceSchema,
   type ResolvedPluginSource,
 } from "./plugin-marketplace.js";
 import type { PluginSearchMatch, SearchPluginsDeps } from "./search-plugins.js";
@@ -40,6 +41,24 @@ export async function findCatalogEntry(
 export function resolveSourceFromMatch(
   match: PluginSearchMatch,
 ): ResolvedPluginSource {
+  if (match.source.kind === "local") {
+    const parsed = localSourceSchema.safeParse({
+      source: "local",
+      path: match.source.path,
+      version: match.source.version,
+    });
+    if (!parsed.success) {
+      throw new Error(
+        `Catalog entry "${match.name}" (${match.source.path}) has an invalid source: ` +
+          parsed.error.issues.map((issue) => issue.message).join("; "),
+      );
+    }
+    return {
+      kind: "local",
+      path: parsed.data.path,
+      version: parsed.data.version,
+    };
+  }
   // Repo-root `""` maps to `undefined` (omitted = root) so the schema's
   // non-empty path refine does not reject a valid repo-root entry.
   const path = match.source.path || undefined;
@@ -57,6 +76,7 @@ export function resolveSourceFromMatch(
   }
   const [owner, repoName] = parsed.data.repo.split("/", 2) as [string, string];
   return {
+    kind: "github",
     owner,
     repo: repoName,
     path: match.source.path ?? "",

package/src/cli/lib/plugin-details.ts

@@ -34,6 +34,7 @@ import { join } from "node:path";
 
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 import { readPluginManifest } from "../../util/plugin-manifest.js";
+import { readBundledPluginFile } from "./bundled-plugin-packages.js";
 import type { FetchLike } from "./fetch-like.js";
 import { sanitizePluginName } from "./install-from-github.js";
 import {
@@ -300,6 +301,17 @@ async function readRemotePlugin(
   source: PluginMatchSource,
   fetchFn: FetchLike,
 ): Promise<RemotePlugin> {
+  if (source.kind === "local") {
+    const manifest = readBundledPluginFile(
+      source.path,
+      source.version,
+      "plugin.json",
+    );
+    return {
+      manifest: manifest ? safeParseManifest(manifest) : emptyManifest(),
+      readme: null,
+    };
+  }
   const [owner, repo] = source.repo.split("/", 2) as [string, string];
   const entries = await listDirSafe(
     owner,