@serviceme/devtools-cli 1.0.0 → 2.0.1

package/dist/bridgeServer.js

@@ -40,7 +40,7 @@ var readline = __toESM(require("readline"));
 
 // ../../packages/serviceme-protocol/src/bridge.ts
 var SERVICEME_PROTOCOL_VERSION = 2;
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function isValidProtocolVersion(value) {
@@ -53,11 +53,25 @@ var BRIDGE_METHODS = [
   "task.execute",
   "task.cancel",
   "task.list-running",
+  "copilotContent.list",
+  "copilotContent.get",
+  "copilotContent.install",
+  "copilotContent.convertToSymlink",
+  "copilotContent.uninstall",
+  "copilotContent.setEntryEnabled",
+  "copilotContent.detectUnmanaged",
+  "copilotContent.adoptUnmanaged",
+  "copilotContent.listLinked",
+  "copilotContent.draft.create",
+  "copilotContent.draft.commit",
+  "copilotContent.draft.list",
+  "copilotContent.draft.delete",
   "skillRepo.list",
   "skillRepo.get",
   "skillRepo.install",
   "skillRepo.convertToSymlink",
   "skillRepo.uninstall",
+  "skillRepo.setEntryEnabled",
   "skillRepo.listLinked",
   "skillRepo.draft.create",
   "skillRepo.draft.commit",
@@ -71,6 +85,25 @@ var BRIDGE_METHODS = [
   "repo.update",
   "repo.sync",
   "repo.syncAll",
+  "repo.resetParseCache",
+  "copilotContent.status",
+  "copilotContent.restore",
+  "copilotContent.approve",
+  "copilotContent.migrateLegacy",
+  "copilotContent.integrationStatus",
+  "copilotContent.customizations.list",
+  "copilotContent.package.install",
+  "copilotContent.package.update",
+  "copilotContent.package.uninstall",
+  "copilotContent.package.move",
+  "copilotPlugin.list",
+  "copilotPlugin.register",
+  "copilotPlugin.unregister",
+  "copilotContent.legacy.preview",
+  "copilotContent.legacy.migrate",
+  "copilotContent.sources.list",
+  "copilotContent.sources.remove",
+  "copilotContent.package.previewUpdate",
   "auth.status",
   "auth.login",
   "auth.logout",
@@ -88,7 +121,7 @@ function isBridgeMethod(value) {
   return typeof value === "string" && BRIDGE_METHODS.includes(value);
 }
 function isBridgeRequest(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return false;
   }
   return isValidProtocolVersion(value.protocolVersion) && value.kind === "request" && typeof value.id === "string" && isBridgeMethod(value.method) && "params" in value;
@@ -140,14 +173,14 @@ var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
   "executor_timeout",
   "internal_error"
 ]);
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function isServicemeErrorCode(value) {
   return typeof value === "string" && SERVICEME_ERROR_CODES.includes(value);
 }
 function isServicemeErrorDetails(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return false;
   }
   return isServicemeErrorCode(value.code) && typeof value.message === "string" && typeof value.retryable === "boolean";
@@ -187,7 +220,7 @@ function normalizeServicemeError(error, fallbackCode = "internal_error") {
   if (isServicemeErrorDetails(error)) {
     return error;
   }
-  if (isRecord2(error)) {
+  if (isRecord3(error)) {
     const code = isServicemeErrorCode(error.code) ? error.code : fallbackCode;
     const message = typeof error.message === "string" ? error.message : "Unexpected serviceme error.";
     const retryable = typeof error.retryable === "boolean" ? error.retryable : isRetryableErrorCode(code);
@@ -213,7 +246,1103 @@ function normalizeServicemeError(error, fallbackCode = "internal_error") {
 }
 
 // src/version.ts
-var SERVICEME_CLI_VERSION = "1.0.0";
+var SERVICEME_CLI_VERSION = "2.0.1";
+
+// src/bridge/CopilotContentBridgeHandler.ts
+var fsp = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+var import_devtools_core = require("@serviceme/devtools-core");
+var CopilotContentBridgeHandler = class {
+  constructor(opts) {
+    this.repoManager = new import_devtools_core.RepoManager({
+      store: opts.store,
+      gitClient: opts.gitClient,
+      skipClone: opts.skipClone ?? false
+    });
+  }
+  /** Ensure every declared repository is checked out at its pinned commit. */
+  async ensureRepositories(manifest) {
+    const sources = /* @__PURE__ */ new Map();
+    for (const source of (0, import_devtools_core.getWorkspaceManifestSources)(
+      manifest ?? { version: 2, sources: [], plugins: [] }
+    )) {
+      if (source.type === "catalog") {
+        const localPath = path.resolve((0, import_devtools_core.getReposDir)(), source.id);
+        const stat3 = await fsp.stat(localPath).catch(() => null);
+        sources.set(
+          source.id,
+          stat3?.isDirectory() ? { ready: true } : {
+            ready: false,
+            error: "Source not materialized under ~/.serviceme/repos"
+          }
+        );
+        continue;
+      }
+      try {
+        await this.repoManager.ensureAtCommit({
+          repository: {
+            id: source.id,
+            url: source.url,
+            useProxy: true
+          },
+          commit: source.commit
+        });
+        sources.set(source.id, { ready: true });
+      } catch (error) {
+        sources.set(source.id, {
+          ready: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return sources;
+  }
+  async reconcile(workspaceDir) {
+    const reconciler = await this.makeReconciler(workspaceDir);
+    return reconciler.reconcile();
+  }
+  /**
+   * Reconciler with machine-local disable marks applied: identities
+   * disabled for THIS workspace behave as if undeclared (links are
+   * removed and never resurrected) while the manifest stays intact.
+   */
+  async makeReconciler(workspaceDir) {
+    let marks = [];
+    try {
+      marks = await new import_devtools_core.DisabledContentStore().list();
+    } catch {
+    }
+    const matches = (0, import_devtools_core.buildDisabledIdentityMatcher)(workspaceDir, marks);
+    return new import_devtools_core.WorkspaceCopilotContentReconciler({
+      workspaceDir,
+      ensureRepository: (manifest) => this.ensureRepositories(manifest),
+      isDisabled: async (identity) => matches(identity)
+    });
+  }
+  /** `copilotContent.restore` — reconcile declared content now. */
+  async restore(params) {
+    return this.reconcile(params.workspaceDir);
+  }
+  /** `copilotContent.status` — declaration + current status without mutations. */
+  async status(params) {
+    const manifest = await (0, import_devtools_core.loadWorkspaceCopilotManifest)(params.workspaceDir);
+    if (!manifest) {
+      return { changed: false, entries: [] };
+    }
+    return this.reconcile(params.workspaceDir);
+  }
+  /** `copilotContent.approve` — record local approval, then re-reconcile. */
+  async approve(params) {
+    const reconciler = await this.makeReconciler(params.workspaceDir);
+    return reconciler.approve({ identities: params.identities });
+  }
+  /** `copilotContent.migrateLegacy` — report legacy ~/.agents links for migration. */
+  async migrateLegacy(params) {
+    const manifest = await (0, import_devtools_core.loadWorkspaceCopilotManifest)(params.workspaceDir);
+    if (!manifest) {
+      return { entries: [] };
+    }
+    const plan = await (0, import_devtools_core.resolveWorkspaceContentPlan)({
+      manifest,
+      reposDir: (0, import_devtools_core.getReposDir)()
+    });
+    const materializer = new import_devtools_core.CopilotLinkMaterializer();
+    const entries = [];
+    for (const entry of plan.entries) {
+      const legacy = await materializer.inspectLegacyUserLink({
+        homeDir: (0, import_devtools_core.getServicemeHome)(),
+        entry
+      });
+      entries.push({
+        identity: legacy.identity,
+        status: legacy.status,
+        message: legacy.message
+      });
+    }
+    return { entries };
+  }
+  /**
+   * `copilotContent.integrationStatus` — read-only diagnostics for the
+   * machine-local MCP / hook integrations of a declared workspace.
+   *
+   * The state store provides the declared identities and approval flags;
+   * the two generated config files and their `_serviceme` ownership maps
+   * prove which names are actually present on this machine. This method
+   * never mutates state or configuration.
+   */
+  async integrationStatus(params) {
+    const state = await new import_devtools_core.WorkspaceContentStateStore({
+      workspaceDir: params.workspaceDir
+    }).read();
+    const mcp = await readOwnershipConfig(
+      path.join(params.workspaceDir, ".vscode", "mcp.serviceme.json")
+    );
+    const hooks = await readOwnershipConfig(
+      path.join(params.workspaceDir, ".vscode", "hooks.serviceme.json")
+    );
+    const integrations = [];
+    for (const entry of state.entries) {
+      if (entry.kind !== "mcp" && entry.kind !== "hook") continue;
+      const config = entry.kind === "mcp" ? mcp : hooks;
+      const owned = config.ownership[entry.identity] ?? [];
+      const active = config.exists && owned.length > 0;
+      const status = active ? "active" : entry.approved ? "missing_local_configuration" : "pending_approval";
+      integrations.push({
+        identity: entry.identity,
+        kind: entry.kind,
+        configPath: config.configPath,
+        names: owned,
+        status
+      });
+    }
+    return { integrations };
+  }
+};
+async function readOwnershipConfig(configPath) {
+  try {
+    const raw = await fsp.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const ownershipNode = parsed._serviceme;
+    const ownership = ownershipNode && typeof ownershipNode === "object" ? normalizeOwnership(ownershipNode) ?? {} : {};
+    return { exists: true, configPath, ownership };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { exists: false, configPath, ownership: {} };
+    }
+    throw error;
+  }
+}
+function normalizeOwnership(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) {
+    return void 0;
+  }
+  const result = {};
+  for (const [identity, names] of Object.entries(node)) {
+    if (Array.isArray(names) && names.every((name) => typeof name === "string")) {
+      result[identity] = names;
+    }
+  }
+  return result;
+}
+
+// src/bridge/CopilotCustomizationsBridgeHandler.ts
+var fsp2 = __toESM(require("fs/promises"));
+var path2 = __toESM(require("path"));
+var import_devtools_core2 = require("@serviceme/devtools-core");
+var import_skill_linker = require("@serviceme/devtools-core/skill-linker");
+function createCopilotCustomizationsProductionDeps(options) {
+  return {
+    snapshot: async (params) => {
+      if (params.scope === "personal") {
+        return createFullPersonalSnapshot(options, await options.readers.listPersonalLinks());
+      }
+      return createWorkspaceSnapshot(
+        options.repoDisplayName,
+        options.readers,
+        params.workspaceDir ?? process.cwd()
+      );
+    }
+  };
+}
+var CopilotCustomizationsBridgeHandler = class {
+  constructor(deps) {
+    if ("snapshot" in deps && typeof deps.snapshot === "function") {
+      this.snapshot = deps.snapshot;
+      this.listAvailablePackages = deps.listAvailablePackages;
+      this.mutations = createUnimplementedMutations(
+        "Injected snapshot deps do not support package mutations"
+      );
+    } else if ("store" in deps && deps.store !== void 0) {
+      this.snapshot = createCopilotCustomizationsProductionDeps({
+        repoDisplayName: (repoId) => deps.store.get(repoId)?.name,
+        readers: createDefaultProductionReaders(),
+        personal: createDefaultPersonalSnapshotInput(deps.store)
+      }).snapshot;
+      this.mutations = createProductionMutations(deps.store);
+      this.listAvailablePackages = createAvailablePackagesEnumerator(deps.store);
+    } else {
+      this.snapshot = async () => emptySnapshot();
+      this.mutations = createUnimplementedMutations(
+        "Package mutations require production dependencies"
+      );
+    }
+  }
+  async list(params) {
+    const snapshot = await this.snapshot(params);
+    const shared = snapshot.workspaceManifest !== void 0 ? { workspaceManifest: snapshot.workspaceManifest } : {};
+    const availablePackages = await this.listAvailablePackages?.(params, shared).catch(
+      () => void 0
+    );
+    return {
+      view: (0, import_devtools_core2.buildCopilotCustomizationView)({
+        scope: params.scope,
+        sources: snapshot.sources.map(toPublicSource),
+        packages: snapshot.packages.map(toPublicPackage),
+        installations: snapshot.installations.map(toPublicInstallation),
+        statesByArtifactId: toPublicStates(snapshot.statesByArtifactId),
+        legacyCount: snapshot.legacyCount,
+        generatedAt: snapshot.generatedAt,
+        ...snapshot.disabledArtifactIds ? { disabledArtifactIds: snapshot.disabledArtifactIds } : {}
+      }),
+      ...availablePackages ? { availablePackages } : {}
+    };
+  }
+  async install(params) {
+    return this.mutations.install(params);
+  }
+  async update(params) {
+    return this.mutations.update(params);
+  }
+  async uninstall(params) {
+    const result = await this.mutations.uninstall(params);
+    try {
+      const registrar = new import_devtools_core2.CopilotPluginRegistrar({
+        copilotDir: path2.join((0, import_devtools_core2.getHomeDir)(), ".copilot")
+      });
+      await registrar.unregister({
+        registrationId: params.packageId.replace("::", ":"),
+        scope: params.scope
+      });
+      const otherScope = params.scope === "personal" ? "workspace" : "personal";
+      await registrar.unregister({
+        registrationId: params.packageId.replace("::", ":"),
+        scope: otherScope
+      });
+    } catch {
+    }
+    return result;
+  }
+  async move(params) {
+    return this.mutations.move(params);
+  }
+  async legacyPreview(params) {
+    return this.mutations.legacyPreview(params);
+  }
+  async legacyMigrate(params) {
+    return this.mutations.legacyMigrate(params);
+  }
+  async sources(params) {
+    return this.mutations.sources(params);
+  }
+  async removeSource(params) {
+    return this.mutations.removeSource(params);
+  }
+  async previewUpdate(params) {
+    return this.mutations.previewUpdate(params);
+  }
+};
+function createDefaultPersonalSnapshotInput(store) {
+  return {
+    // Capabilities are intentionally omitted: createFullPersonalSnapshot
+    // falls back to the real default host-capability provider, which
+    // claims the verified ~/.copilot agent/skill targets. Pinning an
+    // empty personalTargets map here regressed every link artifact to
+    // unsupported. The explicit package resolver is the part Task 8
+    // flagged as silently missing.
+    resolvePersonalPackage: (packageId) => resolvePersonalPackageFromRepos(packageId, store)
+  };
+}
+async function resolvePersonalPackageFromRepos(packageId, store) {
+  const [sourceId, pluginId] = packageId.split("::");
+  if (!sourceId || !pluginId) return [];
+  const repoRoot = path2.resolve((0, import_devtools_core2.getReposDir)(), sourceId);
+  const stat3 = await fsp2.stat(repoRoot).catch(() => null);
+  if (!stat3?.isDirectory()) return [];
+  const repo = store.get(sourceId);
+  const manifest = {
+    version: 1,
+    repositories: [
+      {
+        id: sourceId,
+        url: repo?.url ?? `https://serviceme.local/catalog/${encodeURIComponent(sourceId)}`,
+        commit: repo?.lastSyncCommitSha ?? "".padEnd(40, "0")
+      }
+    ],
+    plugins: [
+      {
+        repository: sourceId,
+        id: pluginId,
+        artifacts: {
+          agent: true,
+          skill: true,
+          instruction: true,
+          prompt: true,
+          hook: true,
+          mcp: true
+        }
+      }
+    ]
+  };
+  const resolved = await (0, import_devtools_core2.resolveWorkspaceContentPlan)({
+    manifest,
+    reposDir: (0, import_devtools_core2.getReposDir)()
+  }).catch(() => ({ entries: [] }));
+  return resolved.entries;
+}
+function createAvailablePackagesEnumerator(store) {
+  const catalog = (0, import_devtools_core2.createPluginCatalogService)();
+  const personalStore = new import_devtools_core2.PersonalInstallationStore({});
+  const pluginRegistrar = new import_devtools_core2.CopilotPluginRegistrar({
+    copilotDir: path2.join((0, import_devtools_core2.getHomeDir)(), ".copilot")
+  });
+  return async (params, shared) => {
+    const repos = store.list().filter((repo) => repo.enabled).map((repo) => ({ id: repo.id }));
+    if (repos.length === 0) return [];
+    const catalogPackages = await catalog.list({
+      reposDir: (0, import_devtools_core2.getReposDir)(),
+      repos
+    });
+    const [workspaceManifest, personalIntent, registrations] = await Promise.all([
+      // Shared read from the same list() call when provided; only a
+      // standalone enumerator invocation (personal scope, tests,
+      // direct calls) hits the disk here.
+      shared?.workspaceManifest !== void 0 ? Promise.resolve(shared.workspaceManifest) : params.workspaceDir ? (0, import_devtools_core2.loadWorkspaceCopilotManifest)(params.workspaceDir).catch(() => void 0) : Promise.resolve(void 0),
+      personalStore.read().catch(() => void 0),
+      // Whole-package registry — prune-on-list keeps it clean.
+      pluginRegistrar.list({}).catch(() => [])
+    ]);
+    const manifest = workspaceManifest ?? {
+      version: 1,
+      repositories: [],
+      plugins: []
+    };
+    const coversPackage = (pkg, selectedIds, selectedKinds) => pkg.artifacts.every(
+      (artifact) => selectedIds !== void 0 ? selectedIds.includes(artifact.id) : selectedKinds?.[artifact.kind] === true
+    );
+    const manifestSelections = new Map(
+      manifest.plugins.map((plugin) => [
+        `${(0, import_devtools_core2.getWorkspaceManifestPluginSourceId)(manifest, plugin)}::${plugin.id}`,
+        plugin
+      ])
+    );
+    const machineMarks = await new import_devtools_core2.DisabledContentStore().list().catch(() => []);
+    const disabledTargets = /* @__PURE__ */ new Map();
+    const addDisabledTarget = (packageKey, target) => {
+      const targets = disabledTargets.get(packageKey) ?? /* @__PURE__ */ new Set();
+      targets.add(target);
+      disabledTargets.set(packageKey, targets);
+    };
+    for (const plugin of manifest.plugins) {
+      const packageKey = `${(0, import_devtools_core2.getWorkspaceManifestPluginSourceId)(manifest, plugin)}::${plugin.id}`;
+      for (const target of plugin.disabledArtifacts ?? []) {
+        addDisabledTarget(packageKey, target);
+      }
+    }
+    for (const mark of machineMarks) {
+      if (mark.scope === "user" || mark.workspaceDir === params.workspaceDir) {
+        addDisabledTarget(`${mark.repoId}::*`, `${mark.kind}:${mark.name}`);
+      }
+    }
+    const personalSelections = new Map(
+      (personalIntent?.installations ?? []).filter((installation) => installation.scope === "personal").map((installation) => [installation.packageId, installation])
+    );
+    const registeredScopes = /* @__PURE__ */ new Map();
+    for (const reg of registrations) {
+      const packageId = `${reg.repoId}::${reg.pluginId}`;
+      const scopes = registeredScopes.get(packageId) ?? /* @__PURE__ */ new Set();
+      for (const scope of reg.scopes) scopes.add(scope);
+      registeredScopes.set(packageId, scopes);
+    }
+    return catalogPackages.map((pkg) => {
+      const manifestPlugin = manifestSelections.get(pkg.packageId);
+      const personalInstallation = personalSelections.get(pkg.packageId);
+      const disabledTargetsForPkg = /* @__PURE__ */ new Set([
+        ...disabledTargets.get(pkg.packageId) ?? [],
+        ...disabledTargets.get(`${pkg.sourceId}::*`) ?? []
+      ]);
+      const hasDisabledArtifact = pkg.artifacts.find(
+        (artifact) => disabledTargetsForPkg.has(`${artifact.kind}:${artifact.displayName}`)
+      ) !== void 0;
+      const installed = registeredScopes.get(pkg.packageId) !== void 0 || hasDisabledArtifact || manifestPlugin !== void 0 && coversPackage(
+        pkg,
+        manifestPlugin.artifactIds,
+        manifestPlugin.artifactIds === void 0 ? manifestPlugin.artifacts : void 0
+      ) || personalInstallation !== void 0 && coversPackage(pkg, personalInstallation.selectedArtifactIds, void 0);
+      return {
+        ...pkg,
+        installedScopes: installed ? ["personal"] : []
+      };
+    });
+  };
+}
+function createProductionMutations(store) {
+  let servicePromise;
+  let sourceCatalogPromise;
+  const service = () => servicePromise ??= createPackageInstallationService(store);
+  const sourceCatalog = () => sourceCatalogPromise ??= createSourceCatalogService(store);
+  return {
+    install: async (params) => toResult(await (await service()).install(params)),
+    update: async (params) => toResult(await (await service()).update(params)),
+    uninstall: async (params) => toResult(await (await service()).uninstall(params)),
+    move: async (params) => toResult(await (await service()).move(params)),
+    legacyPreview: async () => {
+      const preview = await (await service()).previewLegacy();
+      return {
+        sourceLabel: preview.sourceLabel,
+        count: preview.entries.length,
+        artifacts: preview.entries.map((entry) => ({
+          id: entry.artifactId,
+          packageId: "legacy",
+          kind: entry.kind,
+          displayName: entry.name,
+          installStrategy: "link",
+          risk: "none"
+        }))
+      };
+    },
+    legacyMigrate: async (params) => toResult(await (await service()).migrateLegacy(params)),
+    sources: async (params) => {
+      const records = await (await sourceCatalog()).listSources({
+        scope: params.scope,
+        ...params.workspaceDir ? { workspaceDir: params.workspaceDir } : {}
+      });
+      return {
+        sources: records.map((record) => ({
+          id: record.id,
+          type: record.type,
+          displayName: record.displayName,
+          updateCapability: record.updateCapability,
+          available: record.available,
+          declaredIn: [...record.declaredIn]
+        }))
+      };
+    },
+    removeSource: async (params) => {
+      await (await sourceCatalog()).removeSource(params.sourceId, params.workspaceDir);
+      return { removed: true };
+    },
+    previewUpdate: async (params) => ({
+      preview: await (await sourceCatalog()).previewUpdate(params)
+    })
+  };
+}
+async function createSourceCatalogService(store) {
+  const personalStore = new import_devtools_core2.PersonalInstallationStore({});
+  const loadManifest = async (workspaceDir) => {
+    return (0, import_devtools_core2.loadWorkspaceCopilotManifest)(workspaceDir).catch(() => void 0);
+  };
+  return new import_devtools_core2.CopilotSourceCatalogService({
+    personalStore,
+    // The source manager is the single repository management surface;
+    // surface every ReposStore entry (built-in defaults + user git
+    // repos) so they can be synced / toggled / edited from there even
+    // when no installation or workspace declaration references them.
+    // Read per call: repos.json can change under the long-lived bridge.
+    listStoreSources: async () => store.list().map((repo) => ({
+      id: repo.id,
+      name: repo.name,
+      enabled: repo.enabled
+    })),
+    resolvePackage: (packageId) => resolvePersonalPackageFromRepos(packageId, store),
+    resolveActualRevision: async (packageId) => {
+      const [sourceId] = packageId.split("::");
+      if (!sourceId) return void 0;
+      const repo = store.get(sourceId);
+      if (repo?.lastSyncCommitSha) return repo.lastSyncCommitSha;
+      const repoDir = path2.resolve((0, import_devtools_core2.getReposDir)(), sourceId);
+      const head = await new import_devtools_core2.GitClient({ serverProxyBase: "" }).revParseHead(repoDir).catch(() => void 0);
+      return head;
+    },
+    listWorkspaceSources: async (workspaceDir) => {
+      const manifest = await loadManifest(workspaceDir);
+      if (!manifest) return [];
+      return (0, import_devtools_core2.getWorkspaceManifestSources)(manifest).map((source) => source.id);
+    },
+    readWorkspaceInstallations: async (workspaceDir) => {
+      const manifest = await loadManifest(workspaceDir);
+      if (!manifest) return [];
+      return manifest.plugins.map((plugin) => {
+        const sourceId = (0, import_devtools_core2.getWorkspaceManifestPluginSourceId)(manifest, plugin);
+        const source = (0, import_devtools_core2.getWorkspaceManifestSources)(manifest).find((s) => s.id === sourceId);
+        return {
+          packageId: `${sourceId}::${plugin.id}`,
+          scope: "workspace",
+          selectedArtifactIds: Object.entries(plugin.artifacts).filter(([, enabled]) => enabled !== false).map(([kind]) => `${sourceId}::${plugin.id}::${kind}:`),
+          pinnedVersion: source?.type === "git" ? source.commit : void 0
+        };
+      });
+    },
+    artifactSelected: (marker, artifactId) => artifactId.startsWith(marker),
+    ensureCatalogSource: async (sourceId) => {
+      const mgr = new import_devtools_core2.RepoManager({
+        store,
+        gitClient: new import_devtools_core2.GitClient({ serverProxyBase: "" })
+      });
+      return mgr.ensureCatalogSource({
+        sourceId,
+        provider: {
+          // Placeholder staging: the marketplace catalog client is
+          // not yet wired to per-source payloads, so the first
+          // materialization establishes the directory contract.
+          // Real payload extraction lands with the catalog client.
+          materialize: async (targetDir) => {
+            await fsp2.mkdir(targetDir, { recursive: true });
+          }
+        }
+      });
+    },
+    isCatalogSource: async (sourceId, workspaceDir) => {
+      if (!workspaceDir) return false;
+      const declared = await loadManifest(workspaceDir);
+      const source = declared ? (0, import_devtools_core2.getWorkspaceManifestSources)(declared).find((s) => s.id === sourceId) : void 0;
+      return source?.type === "catalog";
+    },
+    hasCatalogPayload: async (localPath) => {
+      const pluginsDir = path2.join(localPath, "plugins");
+      const entries = await fsp2.readdir(pluginsDir).catch(() => []);
+      if (entries.length === 0) return false;
+      for (const entry of entries) {
+        const stat3 = await fsp2.stat(path2.join(pluginsDir, entry)).catch(() => null);
+        if (stat3?.isDirectory()) {
+          const manifest = await fsp2.stat(path2.join(pluginsDir, entry, "plugin.json")).catch(() => null);
+          if (manifest?.isFile()) return true;
+        }
+      }
+      return false;
+    }
+  });
+}
+async function createPackageInstallationService(store) {
+  const personalStore = new import_devtools_core2.PersonalInstallationStore({});
+  const personalReconciler = new import_devtools_core2.PersonalCopilotContentReconciler({
+    capabilities: await (0, import_devtools_core2.createDefaultCopilotHostCapabilities)(),
+    resolvePackage: (packageId) => resolvePersonalPackageFromRepos(packageId, store)
+  });
+  return new import_devtools_core2.PackageInstallationService({
+    personalStore,
+    personalReconciler,
+    userHomeDir: (0, import_devtools_core2.getHomeDir)(),
+    resolvePackage: (packageId) => resolvePersonalPackageFromRepos(packageId, store),
+    resolveWorkspaceSource: async (sourceId) => {
+      const repo = store.get(sourceId);
+      if (!repo) return void 0;
+      const repoDir = path2.resolve((0, import_devtools_core2.getReposDir)(), sourceId);
+      const stat3 = await fsp2.stat(repoDir).catch(() => null);
+      if (!stat3?.isDirectory()) return void 0;
+      return {
+        id: sourceId,
+        url: repo.url,
+        commit: repo.lastSyncCommitSha ?? "0".repeat(40)
+      };
+    },
+    createWorkspaceReconciler: (workspaceDir) => new import_devtools_core2.WorkspaceCopilotContentReconciler({ workspaceDir }),
+    readWorkspaceView: async (workspaceDir) => {
+      const snapshot = await createWorkspaceSnapshot(
+        (repoId) => store.get(repoId)?.name,
+        createDefaultProductionReaders(),
+        workspaceDir
+      );
+      return (0, import_devtools_core2.buildCopilotCustomizationView)({
+        scope: "workspace",
+        sources: snapshot.sources,
+        packages: snapshot.packages,
+        installations: snapshot.installations,
+        statesByArtifactId: snapshot.statesByArtifactId,
+        generatedAt: snapshot.generatedAt,
+        ...snapshot.disabledArtifactIds ? { disabledArtifactIds: snapshot.disabledArtifactIds } : {}
+      });
+    },
+    readWorkspaceInstallations: import_devtools_core2.readDeclaredWorkspaceInstallations
+  });
+}
+function toResult(view) {
+  return { view: toPublicView(view) };
+}
+function toPublicView(view) {
+  return {
+    scope: view.scope,
+    generatedAt: view.generatedAt,
+    sources: view.sources.map((source) => ({
+      ...toPublicSource(source),
+      packages: source.packages.map((pkg) => toPublicPackageView(pkg))
+    })),
+    packages: view.packages.map((pkg) => ({
+      ...toPublicPackageView(pkg)
+    })),
+    attention: view.attention.map(({ artifact, state }) => ({
+      artifact,
+      state
+    })),
+    summary: view.summary,
+    ...view.legacyMigration ? { legacyMigration: view.legacyMigration } : {}
+  };
+}
+function toPublicPackageView(pkg) {
+  return {
+    definition: toPublicPackage(pkg.definition),
+    installation: toPublicInstallation(pkg.installation),
+    artifacts: pkg.artifacts.map(({ artifact, state }) => ({
+      artifact,
+      state
+    })),
+    selectedArtifactCount: pkg.selectedArtifactCount,
+    status: pkg.status
+  };
+}
+function createUnimplementedMutations(reason) {
+  const reject = async () => {
+    throw new Error(reason);
+  };
+  return {
+    install: reject,
+    update: reject,
+    uninstall: reject,
+    move: reject,
+    legacyPreview: reject,
+    legacyMigrate: reject,
+    sources: reject,
+    removeSource: reject,
+    previewUpdate: reject
+  };
+}
+async function mergeRegistrarPackages(sources, packages, installations, statesByArtifactId) {
+  const registrar = new import_devtools_core2.CopilotPluginRegistrar({
+    copilotDir: path2.join((0, import_devtools_core2.getHomeDir)(), ".copilot")
+  });
+  const registrations = await registrar.list({}).catch(() => []);
+  if (registrations.length === 0) return;
+  const asMap = packages instanceof Map ? packages : new Map(packages.map((p) => [p.id, p]));
+  const knownIds = new Set(asMap.keys());
+  const pushed = packages instanceof Map ? void 0 : packages;
+  for (const reg of registrations) {
+    const packageId = `${reg.repoId}::${reg.pluginId}`;
+    if (knownIds.has(packageId)) continue;
+    const pluginJsonPath = path2.join(reg.pluginDir, "plugin.json");
+    let definition;
+    try {
+      const raw = JSON.parse(await fsp2.readFile(pluginJsonPath, "utf8"));
+      const repoRoot = path2.basename(path2.dirname(reg.pluginDir)) === "plugins" ? path2.dirname(path2.dirname(reg.pluginDir)) : reg.pluginDir;
+      const entries = await (0, import_devtools_core2.resolvePluginEntriesLenient)({
+        repoRoot,
+        repositoryId: reg.repoId,
+        pluginId: reg.pluginId,
+        manifest: {
+          name: typeof raw.name === "string" && raw.name.trim() !== "" ? raw.name : reg.pluginId,
+          ...typeof raw.description === "string" ? { description: raw.description } : {},
+          ...typeof raw.version === "string" ? { version: raw.version } : {},
+          extensions: raw.extensions ?? {}
+        }
+      }).catch(() => []);
+      const artifacts = entries.map(import_devtools_core2.toArtifactSummary);
+      if (artifacts.length > 0) {
+        definition = {
+          id: packageId,
+          sourceId: reg.repoId,
+          displayName: typeof raw.name === "string" && raw.name || reg.displayName || reg.pluginId,
+          ...typeof raw.description === "string" ? { description: raw.description } : {},
+          ...typeof raw.version === "string" ? { version: raw.version } : {},
+          artifacts,
+          wholePackage: true
+        };
+        for (const artifact of artifacts) {
+          statesByArtifactId[artifact.id] = {
+            intent: "selected",
+            health: "healthy",
+            gate: "ready"
+          };
+        }
+      } else {
+        const artifact = {
+          id: `${packageId}::package:${reg.pluginId}`,
+          packageId,
+          kind: "skill",
+          displayName: reg.pluginId,
+          installStrategy: "link",
+          risk: "none"
+        };
+        definition = {
+          id: packageId,
+          sourceId: reg.repoId,
+          displayName: typeof raw.name === "string" && raw.name || reg.displayName || reg.pluginId,
+          ...typeof raw.description === "string" ? { description: raw.description } : {},
+          ...typeof raw.version === "string" ? { version: raw.version } : {},
+          artifacts: [artifact],
+          wholePackage: true
+        };
+        statesByArtifactId[artifact.id] = {
+          intent: "selected",
+          health: "healthy",
+          gate: "ready"
+        };
+      }
+    } catch {
+      definition = {
+        id: packageId,
+        sourceId: reg.repoId,
+        displayName: reg.displayName || reg.pluginId,
+        ...reg.version !== void 0 ? { version: reg.version } : {},
+        artifacts: [],
+        wholePackage: true
+      };
+    }
+    if (pushed) {
+      pushed.push(definition);
+    } else {
+      asMap.set(packageId, definition);
+    }
+    if (!sources.some((source) => source.id === reg.repoId)) {
+      sources.push({
+        id: reg.repoId,
+        type: "git",
+        displayName: reg.repoId,
+        updateCapability: "pinned"
+      });
+    }
+    installations.push({
+      packageId,
+      scope: "personal",
+      selectedArtifactIds: definition.artifacts.map((artifact) => artifact.id)
+    });
+  }
+}
+async function createWorkspaceSnapshot(repoDisplayName, readers, workspaceDir) {
+  const manifest = await readers.loadWorkspaceManifest(workspaceDir);
+  if (!manifest) return emptySnapshot();
+  const sources = (0, import_devtools_core2.getWorkspaceManifestSources)(manifest).map(
+    (source) => ({
+      id: source.id,
+      type: source.type === "catalog" ? "marketplace" : "git",
+      displayName: source.type === "catalog" ? source.catalogId : repoDisplayName(source.id) ?? source.id,
+      updateCapability: "pinned"
+    })
+  );
+  const state = await readers.readWorkspaceState(workspaceDir);
+  let isDisabled = () => false;
+  try {
+    const marks = await new import_devtools_core2.DisabledContentStore().list();
+    isDisabled = (0, import_devtools_core2.buildDisabledIdentityMatcher)(workspaceDir, marks);
+  } catch {
+  }
+  const packages = [];
+  const installations = [];
+  const statesByArtifactId = {};
+  const disabledArtifactIds = [];
+  const resolvedPlugins = await Promise.all(
+    manifest.plugins.map(async (plugin) => {
+      const sourceId = (0, import_devtools_core2.getWorkspaceManifestPluginSourceId)(manifest, plugin);
+      const packageId = `${sourceId}::${plugin.id}`;
+      let fallbackHealth;
+      let entries;
+      if (!await readers.isSourceAvailable(sourceId)) {
+        fallbackHealth = "source-unavailable";
+        entries = fallbackEntries(plugin, packageId);
+      } else {
+        try {
+          entries = await readers.resolveWorkspacePlugin({ manifest, plugin });
+        } catch {
+          fallbackHealth = "conflict";
+          entries = fallbackEntries(plugin, packageId);
+        }
+      }
+      return { plugin, sourceId, packageId, entries, fallbackHealth };
+    })
+  );
+  for (const resolved of resolvedPlugins) {
+    const { plugin, sourceId, packageId, entries, fallbackHealth } = resolved;
+    const artifacts = entries.map(import_devtools_core2.toArtifactSummary);
+    packages.push({
+      id: packageId,
+      sourceId,
+      displayName: entries[0]?.packageDisplayName ?? plugin.id,
+      ...entries[0]?.packageDescription ? { description: entries[0].packageDescription } : {},
+      ...entries[0]?.packageVersion ? { version: entries[0].packageVersion } : {},
+      artifacts
+    });
+    installations.push({
+      packageId,
+      scope: "workspace",
+      selectedArtifactIds: artifacts.map((artifact) => artifact.id)
+    });
+    for (const entry of entries) {
+      const previous = state.entries.find((candidate) => candidate.identity === entry.artifactId);
+      if (isDisabled(entry.artifactId)) {
+        disabledArtifactIds.push(entry.artifactId);
+        statesByArtifactId[entry.artifactId] = {
+          intent: "selected",
+          health: "healthy",
+          gate: "ready"
+        };
+      } else {
+        statesByArtifactId[entry.artifactId] = fallbackHealth ? { intent: "selected", health: fallbackHealth, gate: "ready" } : toArtifactState(entry, previous);
+      }
+    }
+  }
+  await mergeRegistrarPackages(sources, packages, installations, statesByArtifactId);
+  return {
+    sources,
+    packages,
+    installations,
+    statesByArtifactId,
+    disabledArtifactIds,
+    workspaceManifest: manifest
+  };
+}
+async function createFullPersonalSnapshot(options, legacyLinks) {
+  const capabilities = options.personal?.capabilities ?? await (0, import_devtools_core2.createDefaultCopilotHostCapabilities)();
+  const homeDir = options.personal?.homeDir;
+  const store = new import_devtools_core2.PersonalInstallationStore(homeDir !== void 0 ? { homeDir } : {});
+  const reconciler = new import_devtools_core2.PersonalCopilotContentReconciler({
+    capabilities,
+    ...homeDir ? { homeDir } : {},
+    ...options.personal?.resolvePersonalPackage ? { resolvePackage: options.personal.resolvePersonalPackage } : {}
+  });
+  const intent = await store.read();
+  const inspection = await reconciler.inspect();
+  const sources = [];
+  const sourceIds = /* @__PURE__ */ new Set();
+  const packages = /* @__PURE__ */ new Map();
+  const statesByArtifactId = {
+    ...inspection.statesByArtifactId
+  };
+  let legacyCount = 0;
+  for (const link of legacyLinks) {
+    if (link.legacy) legacyCount += 1;
+  }
+  for (const installation of intent.installations) {
+    if (installation.scope !== "personal") continue;
+    const resolved = options.personal ? await options.personal.resolvePersonalPackage(installation.packageId) : [];
+    const artifacts = resolved.filter((entry) => installation.selectedArtifactIds.includes(entry.artifactId)).map(import_devtools_core2.toArtifactSummary);
+    const [sourceId] = installation.packageId.split("::");
+    if (sourceId && !sourceIds.has(sourceId)) {
+      sourceIds.add(sourceId);
+      sources.push({
+        id: sourceId,
+        type: "git",
+        displayName: options.repoDisplayName(sourceId) ?? sourceId,
+        updateCapability: "pinned"
+      });
+    }
+    if (!packages.has(installation.packageId) && artifacts.length > 0) {
+      packages.set(installation.packageId, {
+        id: installation.packageId,
+        sourceId: sourceId ?? "personal-local",
+        displayName: resolved[0]?.packageDisplayName ?? installation.packageId,
+        ...resolved[0]?.packageDescription ? { description: resolved[0].packageDescription } : {},
+        ...resolved[0]?.packageVersion ? { version: resolved[0].packageVersion } : {},
+        artifacts
+      });
+    }
+  }
+  await mergeRegistrarPackages(sources, packages, intent.installations, statesByArtifactId);
+  return {
+    sources,
+    packages: [...packages.values()],
+    installations: intent.installations.filter((installation) => installation.scope === "personal"),
+    statesByArtifactId,
+    ...legacyCount > 0 ? { legacyCount } : {}
+  };
+}
+function fallbackEntries(plugin, packageId) {
+  const kinds = Object.keys(plugin.artifacts);
+  return kinds.filter((kind) => plugin.artifacts[kind] !== false).map((kind) => {
+    const repoId = packageId.split("::")[0] ?? packageId;
+    const identity = (0, import_devtools_core2.buildContentIdentity)({
+      repoId,
+      pluginId: plugin.id,
+      kind,
+      name: plugin.id
+    });
+    return {
+      identity,
+      artifactId: identity,
+      packageId,
+      packageDisplayName: plugin.id,
+      repositoryId: repoId,
+      pluginId: plugin.id,
+      kind,
+      sourcePath: "",
+      sourceIsFile: false,
+      name: plugin.id,
+      digest: "",
+      requiresApproval: kind === "hook" || kind === "mcp"
+    };
+  });
+}
+function toArtifactState(entry, previous) {
+  if (!previous) {
+    return {
+      intent: "selected",
+      health: "missing",
+      gate: entry.requiresApproval ? "approval-required" : "ready"
+    };
+  }
+  return {
+    intent: "selected",
+    health: previous.digest === entry.digest ? "healthy" : "drifted",
+    gate: entry.requiresApproval && !previous.approved ? "approval-required" : "ready"
+  };
+}
+function createDefaultProductionReaders() {
+  return {
+    loadWorkspaceManifest: import_devtools_core2.loadWorkspaceCopilotManifest,
+    readWorkspaceState: async (workspaceDir) => new import_devtools_core2.WorkspaceContentStateStore({ workspaceDir }).read(),
+    isSourceAvailable: async (sourceId) => {
+      const stat3 = await fsp2.stat(path2.join((0, import_devtools_core2.getReposDir)(), sourceId)).catch(() => void 0);
+      return stat3?.isDirectory() === true;
+    },
+    resolveWorkspacePlugin: async ({ manifest, plugin }) => {
+      const scopedManifest = manifest.version === 1 ? { ...manifest, plugins: [plugin] } : { ...manifest, plugins: [plugin] };
+      return (await (0, import_devtools_core2.resolveWorkspaceContentPlan)({
+        manifest: scopedManifest,
+        reposDir: (0, import_devtools_core2.getReposDir)()
+      })).entries;
+    },
+    listPersonalLinks: async () => [
+      ...(await (0, import_skill_linker.listLinkedSkills)("", "skill", "user")).map((link) => ({
+        repoId: link.repoId,
+        name: link.skillName,
+        kind: "skill",
+        legacy: link.linkPath.includes(`${path2.sep}.agents${path2.sep}`)
+      })),
+      ...(await (0, import_skill_linker.listLinkedSkills)("", "agent", "user")).map((link) => ({
+        repoId: link.repoId,
+        name: link.skillName,
+        kind: "agent",
+        legacy: link.linkPath.includes(`${path2.sep}.agents${path2.sep}`)
+      }))
+    ]
+  };
+}
+function emptySnapshot() {
+  return {
+    sources: [],
+    packages: [],
+    installations: [],
+    statesByArtifactId: {}
+  };
+}
+function toPublicSource(source) {
+  return {
+    id: source.id,
+    type: source.type,
+    displayName: source.displayName,
+    updateCapability: source.updateCapability
+  };
+}
+function toPublicPackage(pkg) {
+  return {
+    id: pkg.id,
+    sourceId: pkg.sourceId,
+    displayName: pkg.displayName,
+    ...pkg.description !== void 0 ? { description: pkg.description } : {},
+    ...pkg.version !== void 0 ? { version: pkg.version } : {},
+    artifacts: pkg.artifacts.map((artifact) => ({
+      id: artifact.id,
+      packageId: artifact.packageId,
+      kind: artifact.kind,
+      displayName: artifact.displayName,
+      ...artifact.description !== void 0 ? { description: artifact.description } : {},
+      installStrategy: artifact.installStrategy,
+      risk: artifact.risk
+    })),
+    ...pkg.wholePackage === true ? { wholePackage: true } : {}
+  };
+}
+function toPublicInstallation(installation) {
+  return {
+    packageId: installation.packageId,
+    scope: installation.scope,
+    selectedArtifactIds: [...installation.selectedArtifactIds],
+    ...installation.pinnedVersion !== void 0 ? { pinnedVersion: installation.pinnedVersion } : {}
+  };
+}
+function toPublicStates(states) {
+  return Object.fromEntries(
+    Object.entries(states).map(([artifactId, state]) => [artifactId, { ...state }])
+  );
+}
+
+// src/bridge/CopilotPluginBridgeHandler.ts
+var fs = __toESM(require("fs/promises"));
+var path3 = __toESM(require("path"));
+var import_devtools_core3 = require("@serviceme/devtools-core");
+async function readManifestInfo(pluginDir) {
+  try {
+    const raw = JSON.parse(await fs.readFile(path3.join(pluginDir, "plugin.json"), "utf8"));
+    let mcpServers = [];
+    const mcpPath = path3.join(pluginDir, "mcp.json");
+    try {
+      const mcp = JSON.parse(await fs.readFile(mcpPath, "utf8"));
+      mcpServers = Object.keys(mcp.mcpServers ?? {});
+    } catch {
+    }
+    return {
+      ...typeof raw.name === "string" ? { displayName: raw.name } : {},
+      ...typeof raw.version === "string" ? { version: raw.version } : {},
+      mcpServers,
+      hasExtensions: Boolean(raw.extensions?.["com.github.copilot"])
+    };
+  } catch {
+    return { mcpServers: [], hasExtensions: false };
+  }
+}
+function toPayload(reg, info) {
+  return {
+    registrationId: reg.registrationId,
+    repoId: reg.repoId,
+    pluginId: reg.pluginId,
+    ...reg.displayName ?? info.displayName ? { displayName: reg.displayName ?? info.displayName } : {},
+    ...reg.version ?? info.version ? { version: reg.version ?? info.version } : {},
+    scopes: reg.scopes,
+    mcpServers: info.mcpServers,
+    hasExtensions: info.hasExtensions
+  };
+}
+var CopilotPluginBridgeHandler = class {
+  constructor(options = {}) {
+    const homeDir = options.homeDir ?? (0, import_devtools_core3.getHomeDir)();
+    this.registrar = new import_devtools_core3.CopilotPluginRegistrar({
+      // copilotDir is the migration source only — projections live
+      // under the SERVICEME home, out of VS Code's ~/.copilot
+      // reconciliation reach.
+      copilotDir: path3.join(homeDir, ".copilot"),
+      pluginsDir: path3.join(homeDir, ".serviceme", "copilot-plugins")
+    });
+    this.reposDir = path3.join(homeDir, ".serviceme", "repos");
+  }
+  pluginDir(repoId, pluginId) {
+    return path3.join(this.reposDir, (0, import_devtools_core3.assertSafeRepoId)(repoId), "plugins", pluginId);
+  }
+  async list(_params) {
+    const registrations = await this.registrar.list({});
+    const plugins = await Promise.all(
+      registrations.map(async (reg) => toPayload(reg, await readManifestInfo(reg.pluginDir)))
+    );
+    return { plugins };
+  }
+  async register(params) {
+    const pluginDir = this.pluginDir(params.repoId, params.pluginId);
+    const info = await readManifestInfo(pluginDir);
+    await this.registrar.register({
+      repoId: params.repoId,
+      pluginId: params.pluginId,
+      pluginDir,
+      scope: params.scope,
+      ...info.displayName !== void 0 ? { displayName: info.displayName } : {},
+      ...info.version !== void 0 ? { version: info.version } : {}
+    });
+    return this.list({});
+  }
+  async unregister(params) {
+    const normalized = params.registrationId.replace("::", ":");
+    await this.registrar.unregister({
+      registrationId: normalized,
+      scope: params.scope
+    });
+    if (normalized !== params.registrationId) {
+      await this.registrar.unregister({
+        registrationId: params.registrationId,
+        scope: params.scope
+      });
+    }
+    const otherScope = params.scope === "personal" ? "workspace" : "personal";
+    await this.registrar.unregister({
+      registrationId: normalized,
+      scope: otherScope
+    });
+    return this.list({});
+  }
+};
 
 // src/bridge/handlers/AuthBridgeHandlers.ts
 var import_auth2 = require("@serviceme/devtools-core/auth");
@@ -328,12 +1457,12 @@ function writeBridgeMessage(message) {
 }
 
 // src/bridge/TaskBridgeHandler.ts
-var import_devtools_core = require("@serviceme/devtools-core");
+var import_devtools_core4 = require("@serviceme/devtools-core");
 var TaskBridgeHandler = class {
   constructor(logger, emitEvent) {
     this.logger = logger;
     this.emitEvent = emitEvent;
-    this.engine = new import_devtools_core.TaskExecutionEngine((taskType) => (0, import_devtools_core.getExecutor)(taskType));
+    this.engine = new import_devtools_core4.TaskExecutionEngine((taskType) => (0, import_devtools_core4.getExecutor)(taskType));
     this.engine.setListener({
       onStarted: (params) => this.emitEvent("task.started", params),
       onOutput: (params) => this.emitEvent("task.output", params),
@@ -376,6 +1505,7 @@ var CAPABILITIES = {
   tasks: 1,
   skillRepo: 1,
   repoMgmt: 1,
+  copilotContent: 1,
   auth: 1,
   device: 1,
   toolbox: 1
@@ -388,6 +1518,9 @@ var BridgeServer = class {
       this.writeEvent(event, params);
     });
     this.skillRepoHandler = opts.skillRepoHandler;
+    this.copilotContentHandler = opts.skillRepoHandler ? new CopilotContentBridgeHandler(opts.skillRepoHandler.copilotContentDependencies) : void 0;
+    this.copilotCustomizationsHandler = opts.skillRepoHandler ? new CopilotCustomizationsBridgeHandler(opts.skillRepoHandler.copilotContentDependencies) : void 0;
+    this.copilotPluginHandler = opts.skillRepoHandler ? new CopilotPluginBridgeHandler() : void 0;
     this.authHandler = new AuthBridgeHandlers();
     this.deviceHandler = new DeviceBridgeHandlers();
     this.toolboxHandler = new ToolboxBridgeHandlers();
@@ -397,12 +1530,12 @@ var BridgeServer = class {
       input: process.stdin,
       crlfDelay: Number.POSITIVE_INFINITY
     });
-    await new Promise((resolve) => {
+    await new Promise((resolve3) => {
       reader.on("line", (line) => {
         void this.handleLine(line);
       });
       reader.on("close", () => {
-        resolve();
+        resolve3();
       });
     });
   }
@@ -493,6 +1626,7 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.list":
         case "skillRepo.list": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -500,6 +1634,7 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.get":
         case "skillRepo.get": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -507,6 +1642,7 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.install":
         case "skillRepo.install": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -514,6 +1650,7 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.convertToSymlink":
         case "skillRepo.convertToSymlink": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -521,6 +1658,7 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.uninstall":
         case "skillRepo.uninstall": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -528,6 +1666,29 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.setEntryEnabled":
+        case "skillRepo.setEntryEnabled": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.setEntryEnabled(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.detectUnmanaged": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.detectUnmanaged(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.adoptUnmanaged": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.adoptUnmanaged(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.listLinked":
         case "skillRepo.listLinked": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -535,6 +1696,7 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.draft.create":
         case "skillRepo.draft.create": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -542,6 +1704,7 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.draft.commit":
         case "skillRepo.draft.commit": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -549,6 +1712,7 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.draft.list":
         case "skillRepo.draft.list": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -556,6 +1720,7 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "copilotContent.draft.delete":
         case "skillRepo.draft.delete": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
@@ -619,6 +1784,140 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "repo.resetParseCache": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.repoResetParseCache(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotPlugin.list": {
+          const r = request;
+          if (!this.copilotPluginHandler) return this.unsupportedV2(request.id);
+          const listResult = await this.copilotPluginHandler.list(r.params);
+          this.writeSuccess(request.id, listResult);
+          return;
+        }
+        case "copilotPlugin.register": {
+          const r = request;
+          if (!this.copilotPluginHandler) return this.unsupportedV2(request.id);
+          const regResult = await this.copilotPluginHandler.register(r.params);
+          this.writeSuccess(request.id, regResult);
+          return;
+        }
+        case "copilotPlugin.unregister": {
+          const r = request;
+          if (!this.copilotPluginHandler) return this.unsupportedV2(request.id);
+          const unregResult = await this.copilotPluginHandler.unregister(r.params);
+          this.writeSuccess(request.id, unregResult);
+          return;
+        }
+        // ── copilotContent.* (declarative reconciliation) ──────────────
+        case "copilotContent.status": {
+          const r = request;
+          if (!this.copilotContentHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotContentHandler.status(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.restore": {
+          const r = request;
+          if (!this.copilotContentHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotContentHandler.restore(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.approve": {
+          const r = request;
+          if (!this.copilotContentHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotContentHandler.approve(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.migrateLegacy": {
+          const r = request;
+          if (!this.copilotContentHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotContentHandler.migrateLegacy(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.integrationStatus": {
+          const r = request;
+          if (!this.copilotContentHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotContentHandler.integrationStatus(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.customizations.list": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.list(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.package.install": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.install(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.package.update": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.update(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.package.uninstall": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.uninstall(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.package.move": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.move(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.legacy.preview": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.legacyPreview(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.legacy.migrate": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.legacyMigrate(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.sources.list": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.sources(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.sources.remove": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.removeSource(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.package.previewUpdate": {
+          const r = request;
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.previewUpdate(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
         // ── auth.* (Phase 5.4) ─────────────────────────────────────────
         case "auth.status": {
           const r = request;
@@ -722,6 +2021,15 @@ var BridgeServer = class {
       )
     );
   }
+  unsupportedCopilotContent(id) {
+    this.writeError(
+      id,
+      createServicemeError(
+        "invalid_params",
+        "copilotContent.* methods require v2 CLI deps; the bridge was started without a CopilotContentBridgeHandler."
+      )
+    );
+  }
   writeError(id, error) {
     writeBridgeMessage({
       protocolVersion: SERVICEME_PROTOCOL_VERSION,