@serviceme/devtools-cli 1.0.0 → 2.0.1

package/dist/cli.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,6 +30,193 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/bridge/CopilotContentBridgeHandler.ts
+var CopilotContentBridgeHandler_exports = {};
+__export(CopilotContentBridgeHandler_exports, {
+  CopilotContentBridgeHandler: () => CopilotContentBridgeHandler
+});
+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;
+}
+var fsp, path2, import_devtools_core2, CopilotContentBridgeHandler;
+var init_CopilotContentBridgeHandler = __esm({
+  "src/bridge/CopilotContentBridgeHandler.ts"() {
+    "use strict";
+    fsp = __toESM(require("fs/promises"));
+    path2 = __toESM(require("path"));
+    import_devtools_core2 = require("@serviceme/devtools-core");
+    CopilotContentBridgeHandler = class {
+      constructor(opts) {
+        this.repoManager = new import_devtools_core2.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_core2.getWorkspaceManifestSources)(
+          manifest ?? { version: 2, sources: [], plugins: [] }
+        )) {
+          if (source.type === "catalog") {
+            const localPath = path2.resolve((0, import_devtools_core2.getReposDir)(), source.id);
+            const stat4 = await fsp.stat(localPath).catch(() => null);
+            sources.set(
+              source.id,
+              stat4?.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_core2.DisabledContentStore().list();
+        } catch {
+        }
+        const matches = (0, import_devtools_core2.buildDisabledIdentityMatcher)(workspaceDir, marks);
+        return new import_devtools_core2.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_core2.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_core2.loadWorkspaceCopilotManifest)(params.workspaceDir);
+        if (!manifest) {
+          return { entries: [] };
+        }
+        const plan = await (0, import_devtools_core2.resolveWorkspaceContentPlan)({
+          manifest,
+          reposDir: (0, import_devtools_core2.getReposDir)()
+        });
+        const materializer = new import_devtools_core2.CopilotLinkMaterializer();
+        const entries = [];
+        for (const entry of plan.entries) {
+          const legacy = await materializer.inspectLegacyUserLink({
+            homeDir: (0, import_devtools_core2.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_core2.WorkspaceContentStateStore({
+          workspaceDir: params.workspaceDir
+        }).read();
+        const mcp = await readOwnershipConfig(
+          path2.join(params.workspaceDir, ".vscode", "mcp.serviceme.json")
+        );
+        const hooks = await readOwnershipConfig(
+          path2.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 };
+      }
+    };
+  }
+});
+
 // ../../packages/serviceme-protocol/src/auth.ts
 var AUTH_PROVIDERS = ["github", "microsoft"];
 function isAuthProvider(value) {
@@ -31,7 +225,7 @@ function isAuthProvider(value) {
 
 // ../../packages/serviceme-protocol/src/toolbox.ts
 var TOOLBOX_SCOPES = ["user", "workspace"];
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function isStringOrUndefined(value) {
@@ -44,7 +238,7 @@ function isToolboxScope(value) {
   return value === "user" || value === "workspace";
 }
 function isExternalTool(value) {
-  if (!isRecord(value)) return false;
+  if (!isRecord2(value)) return false;
   if (typeof value.id !== "string") return false;
   if (value.id.length === 0) return false;
   if (typeof value.name !== "string") return false;
@@ -62,7 +256,7 @@ function isExternalTool(value) {
   return true;
 }
 function isExternalToolPatch(value) {
-  if (!isRecord(value)) return false;
+  if (!isRecord2(value)) return false;
   if (value.name !== void 0) {
     if (typeof value.name !== "string" || value.name.length === 0) return false;
   }
@@ -84,7 +278,7 @@ function isExternalToolPatch(value) {
 
 // ../../packages/serviceme-protocol/src/bridge.ts
 var SERVICEME_PROTOCOL_VERSION = 2;
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function isValidProtocolVersion(value) {
@@ -97,11 +291,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",
@@ -115,6 +323,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",
@@ -132,7 +359,7 @@ function isBridgeMethod(value) {
   return typeof value === "string" && BRIDGE_METHODS.includes(value);
 }
 function isBridgeRequest(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return false;
   }
   return isValidProtocolVersion(value.protocolVersion) && value.kind === "request" && typeof value.id === "string" && isBridgeMethod(value.method) && "params" in value;
@@ -219,14 +446,14 @@ var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
   "executor_timeout",
   "internal_error"
 ]);
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function isServicemeErrorCode(value) {
   return typeof value === "string" && SERVICEME_ERROR_CODES.includes(value);
 }
 function isServicemeErrorDetails(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return false;
   }
   return isServicemeErrorCode(value.code) && typeof value.message === "string" && typeof value.retryable === "boolean";
@@ -266,7 +493,7 @@ function normalizeServicemeError(error, fallbackCode = "internal_error") {
   if (isServicemeErrorDetails(error)) {
     return error;
   }
-  if (isRecord3(error)) {
+  if (isRecord4(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);
@@ -489,22 +716,38 @@ async function handleUninstall(store, workspacePath, parsed) {
     throw createServicemeError("invalid_params", "Expected --id <remoteAgentId>.");
   }
   const agentId = normalizeAgentIdOrThrow(store, remoteId);
-  await fs.rm(path.join(workspacePath, ".github", "agents", `${agentId}.agent.md`), {
-    recursive: true,
-    force: true
-  });
-  await fs.rm(path.join(workspacePath, ".github", "agents", agentId), {
-    recursive: true,
-    force: true
-  });
-  await fs.rm(path.join(store.getUserAgentsRootPath(), `${agentId}.agent.md`), {
-    recursive: true,
-    force: true
-  });
-  await fs.rm(path.join(store.getUserAgentsRootPath(), agentId), {
-    recursive: true,
-    force: true
-  });
+  const workspaceRoot = path.resolve(workspacePath);
+  const targets = [
+    path.join(workspaceRoot, ".github", "agents", `${agentId}.agent.md`),
+    path.join(workspaceRoot, ".github", "agents", agentId)
+  ];
+  for (const target of targets) {
+    const resolvedTarget = path.resolve(target);
+    if (!resolvedTarget.startsWith(workspaceRoot + path.sep)) {
+      throw createServicemeError("invalid_params", `Agent link escapes the workspace: ${agentId}`);
+    }
+    await fs.rm(resolvedTarget, {
+      recursive: true,
+      force: true
+    });
+  }
+  const userAgentsRoot = path.resolve(store.getUserAgentsRootPath());
+  for (const userTarget of [
+    path.join(userAgentsRoot, `${agentId}.agent.md`),
+    path.join(userAgentsRoot, agentId)
+  ]) {
+    const resolvedUserTarget = path.resolve(userTarget);
+    if (!resolvedUserTarget.startsWith(userAgentsRoot + path.sep)) {
+      throw createServicemeError(
+        "invalid_params",
+        `Agent link escapes the agents root: ${agentId}`
+      );
+    }
+    await fs.rm(resolvedUserTarget, {
+      recursive: true,
+      force: true
+    });
+  }
   await store.removeInstalledAgent(remoteId);
   return {
     changed: true,
@@ -772,14 +1015,936 @@ async function handleSwitch(parsed) {
 }
 
 // src/commands/bridge.ts
-var import_devtools_core4 = require("@serviceme/devtools-core");
+var import_devtools_core7 = require("@serviceme/devtools-core");
 
 // src/bridge/BridgeServer.ts
 var readline = __toESM(require("readline"));
 
 // src/version.ts
 var SERVICEME_CLI_NAME = "serviceme";
-var SERVICEME_CLI_VERSION = "1.0.0";
+var SERVICEME_CLI_VERSION = "2.0.1";
+
+// src/bridge/BridgeServer.ts
+init_CopilotContentBridgeHandler();
+
+// src/bridge/CopilotCustomizationsBridgeHandler.ts
+var fsp2 = __toESM(require("fs/promises"));
+var path3 = __toESM(require("path"));
+var import_devtools_core3 = 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_core3.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_core3.CopilotPluginRegistrar({
+        copilotDir: path3.join((0, import_devtools_core3.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 = path3.resolve((0, import_devtools_core3.getReposDir)(), sourceId);
+  const stat4 = await fsp2.stat(repoRoot).catch(() => null);
+  if (!stat4?.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_core3.resolveWorkspaceContentPlan)({
+    manifest,
+    reposDir: (0, import_devtools_core3.getReposDir)()
+  }).catch(() => ({ entries: [] }));
+  return resolved.entries;
+}
+function createAvailablePackagesEnumerator(store) {
+  const catalog = (0, import_devtools_core3.createPluginCatalogService)();
+  const personalStore = new import_devtools_core3.PersonalInstallationStore({});
+  const pluginRegistrar = new import_devtools_core3.CopilotPluginRegistrar({
+    copilotDir: path3.join((0, import_devtools_core3.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_core3.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_core3.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_core3.getWorkspaceManifestPluginSourceId)(manifest, plugin)}::${plugin.id}`,
+        plugin
+      ])
+    );
+    const machineMarks = await new import_devtools_core3.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_core3.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_core3.PersonalInstallationStore({});
+  const loadManifest = async (workspaceDir) => {
+    return (0, import_devtools_core3.loadWorkspaceCopilotManifest)(workspaceDir).catch(() => void 0);
+  };
+  return new import_devtools_core3.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 = path3.resolve((0, import_devtools_core3.getReposDir)(), sourceId);
+      const head = await new import_devtools_core3.GitClient({ serverProxyBase: "" }).revParseHead(repoDir).catch(() => void 0);
+      return head;
+    },
+    listWorkspaceSources: async (workspaceDir) => {
+      const manifest = await loadManifest(workspaceDir);
+      if (!manifest) return [];
+      return (0, import_devtools_core3.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_core3.getWorkspaceManifestPluginSourceId)(manifest, plugin);
+        const source = (0, import_devtools_core3.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_core3.RepoManager({
+        store,
+        gitClient: new import_devtools_core3.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_core3.getWorkspaceManifestSources)(declared).find((s) => s.id === sourceId) : void 0;
+      return source?.type === "catalog";
+    },
+    hasCatalogPayload: async (localPath) => {
+      const pluginsDir = path3.join(localPath, "plugins");
+      const entries = await fsp2.readdir(pluginsDir).catch(() => []);
+      if (entries.length === 0) return false;
+      for (const entry of entries) {
+        const stat4 = await fsp2.stat(path3.join(pluginsDir, entry)).catch(() => null);
+        if (stat4?.isDirectory()) {
+          const manifest = await fsp2.stat(path3.join(pluginsDir, entry, "plugin.json")).catch(() => null);
+          if (manifest?.isFile()) return true;
+        }
+      }
+      return false;
+    }
+  });
+}
+async function createPackageInstallationService(store) {
+  const personalStore = new import_devtools_core3.PersonalInstallationStore({});
+  const personalReconciler = new import_devtools_core3.PersonalCopilotContentReconciler({
+    capabilities: await (0, import_devtools_core3.createDefaultCopilotHostCapabilities)(),
+    resolvePackage: (packageId) => resolvePersonalPackageFromRepos(packageId, store)
+  });
+  return new import_devtools_core3.PackageInstallationService({
+    personalStore,
+    personalReconciler,
+    userHomeDir: (0, import_devtools_core3.getHomeDir)(),
+    resolvePackage: (packageId) => resolvePersonalPackageFromRepos(packageId, store),
+    resolveWorkspaceSource: async (sourceId) => {
+      const repo = store.get(sourceId);
+      if (!repo) return void 0;
+      const repoDir = path3.resolve((0, import_devtools_core3.getReposDir)(), sourceId);
+      const stat4 = await fsp2.stat(repoDir).catch(() => null);
+      if (!stat4?.isDirectory()) return void 0;
+      return {
+        id: sourceId,
+        url: repo.url,
+        commit: repo.lastSyncCommitSha ?? "0".repeat(40)
+      };
+    },
+    createWorkspaceReconciler: (workspaceDir) => new import_devtools_core3.WorkspaceCopilotContentReconciler({ workspaceDir }),
+    readWorkspaceView: async (workspaceDir) => {
+      const snapshot = await createWorkspaceSnapshot(
+        (repoId) => store.get(repoId)?.name,
+        createDefaultProductionReaders(),
+        workspaceDir
+      );
+      return (0, import_devtools_core3.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_core3.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_core3.CopilotPluginRegistrar({
+    copilotDir: path3.join((0, import_devtools_core3.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 = path3.join(reg.pluginDir, "plugin.json");
+    let definition;
+    try {
+      const raw = JSON.parse(await fsp2.readFile(pluginJsonPath, "utf8"));
+      const repoRoot = path3.basename(path3.dirname(reg.pluginDir)) === "plugins" ? path3.dirname(path3.dirname(reg.pluginDir)) : reg.pluginDir;
+      const entries = await (0, import_devtools_core3.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_core3.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_core3.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_core3.DisabledContentStore().list();
+    isDisabled = (0, import_devtools_core3.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_core3.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_core3.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_core3.createDefaultCopilotHostCapabilities)();
+  const homeDir = options.personal?.homeDir;
+  const store = new import_devtools_core3.PersonalInstallationStore(homeDir !== void 0 ? { homeDir } : {});
+  const reconciler = new import_devtools_core3.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_core3.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_core3.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_core3.loadWorkspaceCopilotManifest,
+    readWorkspaceState: async (workspaceDir) => new import_devtools_core3.WorkspaceContentStateStore({ workspaceDir }).read(),
+    isSourceAvailable: async (sourceId) => {
+      const stat4 = await fsp2.stat(path3.join((0, import_devtools_core3.getReposDir)(), sourceId)).catch(() => void 0);
+      return stat4?.isDirectory() === true;
+    },
+    resolveWorkspacePlugin: async ({ manifest, plugin }) => {
+      const scopedManifest = manifest.version === 1 ? { ...manifest, plugins: [plugin] } : { ...manifest, plugins: [plugin] };
+      return (await (0, import_devtools_core3.resolveWorkspaceContentPlan)({
+        manifest: scopedManifest,
+        reposDir: (0, import_devtools_core3.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(`${path3.sep}.agents${path3.sep}`)
+      })),
+      ...(await (0, import_skill_linker.listLinkedSkills)("", "agent", "user")).map((link) => ({
+        repoId: link.repoId,
+        name: link.skillName,
+        kind: "agent",
+        legacy: link.linkPath.includes(`${path3.sep}.agents${path3.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 fs2 = __toESM(require("fs/promises"));
+var path4 = __toESM(require("path"));
+var import_devtools_core4 = require("@serviceme/devtools-core");
+async function readManifestInfo(pluginDir) {
+  try {
+    const raw = JSON.parse(await fs2.readFile(path4.join(pluginDir, "plugin.json"), "utf8"));
+    let mcpServers = [];
+    const mcpPath = path4.join(pluginDir, "mcp.json");
+    try {
+      const mcp = JSON.parse(await fs2.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_core4.getHomeDir)();
+    this.registrar = new import_devtools_core4.CopilotPluginRegistrar({
+      // copilotDir is the migration source only — projections live
+      // under the SERVICEME home, out of VS Code's ~/.copilot
+      // reconciliation reach.
+      copilotDir: path4.join(homeDir, ".copilot"),
+      pluginsDir: path4.join(homeDir, ".serviceme", "copilot-plugins")
+    });
+    this.reposDir = path4.join(homeDir, ".serviceme", "repos");
+  }
+  pluginDir(repoId, pluginId) {
+    return path4.join(this.reposDir, (0, import_devtools_core4.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_auth3 = require("@serviceme/devtools-core/auth");
@@ -894,12 +2059,12 @@ function writeBridgeMessage(message) {
 }
 
 // src/bridge/TaskBridgeHandler.ts
-var import_devtools_core2 = require("@serviceme/devtools-core");
+var import_devtools_core5 = require("@serviceme/devtools-core");
 var TaskBridgeHandler = class {
   constructor(logger, emitEvent) {
     this.logger = logger;
     this.emitEvent = emitEvent;
-    this.engine = new import_devtools_core2.TaskExecutionEngine((taskType) => (0, import_devtools_core2.getExecutor)(taskType));
+    this.engine = new import_devtools_core5.TaskExecutionEngine((taskType) => (0, import_devtools_core5.getExecutor)(taskType));
     this.engine.setListener({
       onStarted: (params) => this.emitEvent("task.started", params),
       onOutput: (params) => this.emitEvent("task.output", params),
@@ -942,6 +2107,7 @@ var CAPABILITIES = {
   tasks: 1,
   skillRepo: 1,
   repoMgmt: 1,
+  copilotContent: 1,
   auth: 1,
   device: 1,
   toolbox: 1
@@ -954,6 +2120,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();
@@ -963,12 +2132,12 @@ var BridgeServer = class {
       input: process.stdin,
       crlfDelay: Number.POSITIVE_INFINITY
     });
-    await new Promise((resolve) => {
+    await new Promise((resolve9) => {
       reader.on("line", (line) => {
         void this.handleLine(line);
       });
       reader.on("close", () => {
-        resolve();
+        resolve9();
       });
     });
   }
@@ -1054,134 +2223,300 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
-        case "task.list-running": {
-          const result = this.taskHandler.listRunning();
+        case "task.list-running": {
+          const result = this.taskHandler.listRunning();
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.list":
+        case "skillRepo.list": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.list(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.get":
+        case "skillRepo.get": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.get(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.install":
+        case "skillRepo.install": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.install(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.convertToSymlink":
+        case "skillRepo.convertToSymlink": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.convertToSymlink(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "copilotContent.uninstall":
+        case "skillRepo.uninstall": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.uninstall(r.params);
+          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);
+          const result = await this.skillRepoHandler.listLinked(r.params);
+          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);
+          const result = await this.skillRepoHandler.draftCreate(r.params);
+          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);
+          const result = await this.skillRepoHandler.draftCommit(r.params);
+          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);
+          const result = await this.skillRepoHandler.draftList(r.params);
+          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);
+          const result = await this.skillRepoHandler.draftDelete(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "repo.list": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.repoList(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "repo.add": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.repoAdd(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "repo.remove": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.repoRemove(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "repo.enable": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.repoEnable(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "repo.disable": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.repoDisable(r.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "repo.update": {
+          const r = request;
+          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
+          const result = await this.skillRepoHandler.repoUpdate(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "skillRepo.list": {
+        case "repo.sync": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.list(r.params);
+          const result = await this.skillRepoHandler.repoSync(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "skillRepo.get": {
+        case "repo.syncAll": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.get(r.params);
+          const result = await this.skillRepoHandler.repoSyncAll(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "skillRepo.install": {
+        case "repo.resetParseCache": {
           const r = request;
           if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.install(r.params);
+          const result = await this.skillRepoHandler.repoResetParseCache(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "skillRepo.convertToSymlink": {
+        case "copilotPlugin.list": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.convertToSymlink(r.params);
+          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 "skillRepo.uninstall": {
+        case "copilotContent.restore": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.uninstall(r.params);
+          if (!this.copilotContentHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotContentHandler.restore(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "skillRepo.listLinked": {
+        case "copilotContent.approve": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.listLinked(r.params);
+          if (!this.copilotContentHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotContentHandler.approve(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "skillRepo.draft.create": {
+        case "copilotContent.migrateLegacy": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.draftCreate(r.params);
+          if (!this.copilotContentHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotContentHandler.migrateLegacy(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "skillRepo.draft.commit": {
+        case "copilotContent.integrationStatus": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.draftCommit(r.params);
+          if (!this.copilotContentHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotContentHandler.integrationStatus(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "skillRepo.draft.list": {
+        case "copilotContent.customizations.list": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.draftList(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.list(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "skillRepo.draft.delete": {
+        case "copilotContent.package.install": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.draftDelete(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.install(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "repo.list": {
+        case "copilotContent.package.update": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.repoList(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.update(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "repo.add": {
+        case "copilotContent.package.uninstall": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.repoAdd(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.uninstall(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "repo.remove": {
+        case "copilotContent.package.move": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.repoRemove(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.move(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "repo.enable": {
+        case "copilotContent.legacy.preview": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.repoEnable(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.legacyPreview(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "repo.disable": {
+        case "copilotContent.legacy.migrate": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.repoDisable(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.legacyMigrate(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "repo.update": {
+        case "copilotContent.sources.list": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.repoUpdate(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.sources(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "repo.sync": {
+        case "copilotContent.sources.remove": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.repoSync(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.removeSource(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
-        case "repo.syncAll": {
+        case "copilotContent.package.previewUpdate": {
           const r = request;
-          if (!this.skillRepoHandler) return this.unsupportedV2(request.id);
-          const result = await this.skillRepoHandler.repoSyncAll(r.params);
+          if (!this.copilotCustomizationsHandler) return this.unsupportedCopilotContent(request.id);
+          const result = await this.copilotCustomizationsHandler.previewUpdate(r.params);
           this.writeSuccess(request.id, result);
           return;
         }
@@ -1288,6 +2623,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,
@@ -1308,16 +2652,37 @@ var BridgeServer = class {
 };
 
 // src/bridge/SkillRepoBridgeHandler.ts
-var import_devtools_core3 = require("@serviceme/devtools-core");
-var import_skill_linker = require("@serviceme/devtools-core/skill-linker");
+var fs3 = __toESM(require("fs/promises"));
+var path5 = __toESM(require("path"));
+var import_devtools_core6 = require("@serviceme/devtools-core");
+var import_skill_linker2 = require("@serviceme/devtools-core/skill-linker");
 var import_skill_store = require("@serviceme/devtools-core/skill-store");
 var import_submit = require("@serviceme/devtools-core/submit");
+var DEFAULT_SKILL_STORE_CACHE_TTL_MS = 5e3;
 var SkillRepoBridgeHandler = class {
   constructor(opts) {
     this.reposStore = opts.reposStore;
     this.gitClient = opts.gitClient;
     this.draftsStore = opts.draftsStore;
     this.submitClient = opts.submitClient;
+    this.skillStoreCacheTtlMs = opts.skillStoreCacheTtlMs ?? DEFAULT_SKILL_STORE_CACHE_TTL_MS;
+  }
+  /** Shared deps for sibling handlers (copilotContent.*). */
+  get dependencies() {
+    return {
+      reposStore: this.reposStore,
+      gitClient: this.gitClient,
+      draftsStore: this.draftsStore,
+      submitClient: this.submitClient
+    };
+  }
+  /** Narrowed deps for CopilotContentBridgeHandler construction. */
+  get copilotContentDependencies() {
+    return {
+      store: this.reposStore,
+      gitClient: this.gitClient,
+      skipClone: true
+    };
   }
   // ─────────────────────────────────────────────────────────────────
   // skillRepo.*
@@ -1327,11 +2692,35 @@ var SkillRepoBridgeHandler = class {
    * filter by `repoId` or `kind`. Local-only — no git, no network.
    */
   async list(params) {
-    const store = this.buildSkillStore(params.repoId);
+    const store = this.buildSkillStore();
     const entries = params.repoId ? await store.listByRepo(params.repoId) : await store.listAll();
     const filtered = params.kind ? entries.filter((e) => e.kind === params.kind) : entries;
+    let marks = [];
+    try {
+      marks = await new import_devtools_core6.DisabledContentStore().list();
+    } catch {
+    }
+    const declaredDisabled = /* @__PURE__ */ new Set();
+    if (params.workspaceDir) {
+      const manifest = await (0, import_devtools_core6.loadWorkspaceCopilotManifest)(params.workspaceDir).catch(
+        () => void 0
+      );
+      if (manifest) {
+        for (const plugin of manifest.plugins) {
+          for (const target of plugin.disabledArtifacts ?? []) {
+            declaredDisabled.add(
+              `${(0, import_devtools_core6.getWorkspaceManifestPluginSourceId)(manifest, plugin)}|${target}`
+            );
+          }
+        }
+      }
+    }
+    const isDisabled = (entry) => marks.some((mark) => disabledMarkApplies(mark, entry, params.workspaceDir)) || declaredDisabled.has(`${entry.repoId}|${entry.kind}:${entry.name}`);
     return {
-      entries: filtered.map(toBridgeEntry)
+      entries: filtered.map((entry) => ({
+        ...toBridgeEntry(entry),
+        disabled: isDisabled(entry)
+      }))
     };
   }
   /**
@@ -1339,7 +2728,7 @@ var SkillRepoBridgeHandler = class {
    * Throws `skill_not_found` when the entry doesn't exist.
    */
   async get(params) {
-    const store = this.buildSkillStore(params.repoId);
+    const store = this.buildSkillStore();
     let detail;
     try {
       detail = await store.get(params.repoId, params.name);
@@ -1368,31 +2757,128 @@ var SkillRepoBridgeHandler = class {
   async install(params) {
     const kind = params.kind ?? "skill";
     const source = await this.resolveEntrySource(params.repoId, params.name, kind);
-    try {
-      const result = await (0, import_skill_linker.installSkillToWorkspace)({
-        repoId: params.repoId,
-        skillName: params.name,
+    const scope = (params.scope ?? "workspace") === "workspace" ? "workspace" : "user";
+    const store = new import_devtools_core6.DisabledContentStore();
+    await store.removeForArtifact({
+      repoId: params.repoId,
+      name: params.name,
+      kind,
+      scope: "user"
+    });
+    await store.removeForArtifact({
+      repoId: params.repoId,
+      name: params.name,
+      kind,
+      scope,
+      ...scope === "workspace" ? { workspaceDir: params.workspaceDir } : {}
+    });
+    return scope === "workspace" ? this.installThroughDeclaration(params, kind, source) : this.installUserScope(params, kind, source);
+  }
+  /**
+   * Workspace installs go through the shared declaration: pin the
+   * repository at its current commit, add the selection to
+   * .github/serviceme-plugins.json, then let the reconciler create
+   * the owned link. This keeps the manifest the single source of
+   * truth teammates restore from.
+   */
+  async installThroughDeclaration(params, kind, source) {
+    const repoRoot = (0, import_devtools_core6.getRepoDir)(params.repoId);
+    const repo = this.reposStore.get(params.repoId);
+    if (!repo) {
+      throw createServicemeError("not_found", `Repository ${params.repoId} not found`);
+    }
+    const commit = await this.resolvePinnedCommit(params.workspaceDir, repoRoot, params.repoId);
+    if (!/^[0-9a-f]{40}$/.test(commit)) {
+      throw createServicemeError(
+        "internal_error",
+        `Cannot pin repository ${params.repoId}: git returned an invalid commit '${commit}'`
+      );
+    }
+    const coveringPlugin = await (0, import_devtools_core6.findPluginCoveringArtifact)(repoRoot, kind, params.name);
+    await (0, import_devtools_core6.upsertWorkspaceContentSelection)({
+      workspaceDir: params.workspaceDir,
+      repository: { id: repo.id, url: repo.url, commit },
+      pluginId: coveringPlugin ?? params.name,
+      kind
+    });
+    await this.setDeclaredArtifactDisabled(params, kind, false);
+    if (coveringPlugin && coveringPlugin !== params.name) {
+      await (0, import_devtools_core6.removeWorkspaceContentSelection)({
         workspaceDir: params.workspaceDir,
-        mode: params.mode,
-        kind,
-        scope: params.scope,
-        sourcePath: source.sourcePath,
-        sourceIsFile: source.sourceIsFile
+        repositoryId: params.repoId,
+        pluginId: params.name,
+        kind
       });
-      return {
-        mode: result.mode,
-        linkPath: result.linkPath,
-        targetPath: result.targetPath
-      };
-    } catch (err) {
-      if (err instanceof import_skill_linker.LinkError) {
-        throw createServicemeError(
-          "internal_error",
-          `Failed to link ${params.repoId}/${params.name}: ${err.message}`
-        );
+    }
+    const restored = await this.reconcileInstalledContent(params.workspaceDir);
+    const linkBasename = source.sourceIsFile ? path5.basename(source.sourcePath) : params.name;
+    const declaringPlugin = coveringPlugin ?? params.name;
+    const expectedIdentity = (0, import_devtools_core6.buildContentIdentity)({
+      repoId: params.repoId,
+      pluginId: declaringPlugin,
+      kind,
+      name: stripAgentSuffix(linkBasename)
+    });
+    const entry = restored.entries.find((candidate) => candidate.identity === expectedIdentity);
+    if (!entry || entry.status !== "restored" && entry.status !== "adopted") {
+      throw createServicemeError(
+        "internal_error",
+        `Copilot content ${expectedIdentity} failed to activate: ${entry?.message ?? "no matching entry after reconcile"}`
+      );
+    }
+    const linkPath = path5.join(
+      params.workspaceDir,
+      ".github",
+      kind === "agent" ? "agents" : "skills",
+      linkBasename
+    );
+    const targetStat = await fs3.lstat(linkPath);
+    if (!targetStat.isSymbolicLink() && !targetStat.isDirectory()) {
+      throw createServicemeError(
+        "internal_error",
+        `Copilot content link at ${linkPath} was not created by reconcile`
+      );
+    }
+    const target = await fs3.readlink(linkPath).catch(() => linkPath);
+    return { mode: "symlink", linkPath, targetPath: target };
+  }
+  /**
+   * User installs create a local ~/.copilot link without touching the shared
+   * declaration. Idempotent: an already-correct link is a no-op, any other
+   * stale entry at the path is replaced. No copy fallback.
+   */
+  async installUserScope(params, kind, source) {
+    const userRoot = path5.join((0, import_devtools_core6.getHomeDir)(), ".copilot", kind === "agent" ? "agents" : "skills");
+    const linkPath = path5.join(
+      userRoot,
+      source.sourceIsFile ? path5.basename(source.sourcePath) : params.name
+    );
+    await fs3.mkdir(path5.dirname(linkPath), { recursive: true });
+    const existingTarget = await fs3.readlink(linkPath).catch(() => void 0);
+    if (existingTarget !== void 0) {
+      const normalizedExisting = path5.resolve(path5.dirname(linkPath), existingTarget);
+      if (normalizedExisting === path5.resolve(source.sourcePath)) {
+        return { mode: "symlink", linkPath, targetPath: source.sourcePath };
       }
-      throw err;
+      await fs3.rm(linkPath, { recursive: true, force: true });
+    }
+    await fs3.symlink(source.sourcePath, linkPath, source.sourceIsFile ? "file" : "dir");
+    return { mode: "symlink", linkPath, targetPath: source.sourcePath };
+  }
+  async resolvePinnedCommit(workspaceDir, repoRoot, repoId) {
+    const existing = await (0, import_devtools_core6.loadWorkspaceCopilotManifest)(workspaceDir);
+    if (existing) {
+      const declared = (0, import_devtools_core6.getWorkspaceManifestSources)(existing).find(
+        (source) => source.id === repoId && source.type === "git"
+      );
+      if (declared) return declared.commit;
     }
+    return this.gitClient.revParseHead(repoRoot);
+  }
+  async reconcileInstalledContent(workspaceDir) {
+    const { CopilotContentBridgeHandler: CopilotContentBridgeHandler2 } = await Promise.resolve().then(() => (init_CopilotContentBridgeHandler(), CopilotContentBridgeHandler_exports));
+    const handler = new CopilotContentBridgeHandler2(this.copilotContentDependencies);
+    return handler.restore({ workspaceDir });
   }
   /**
    * Replace an existing, real (non-symlink) skill/agent directory at
@@ -1404,7 +2890,7 @@ var SkillRepoBridgeHandler = class {
     const kind = params.kind ?? "skill";
     const source = await this.resolveEntrySource(params.repoId, params.name, kind);
     try {
-      const result = await (0, import_skill_linker.convertToSymlink)({
+      const result = await (0, import_skill_linker2.convertToSymlink)({
         repoId: params.repoId,
         skillName: params.name,
         workspaceDir: params.workspaceDir,
@@ -1420,7 +2906,7 @@ var SkillRepoBridgeHandler = class {
         targetPath: result.targetPath
       };
     } catch (err) {
-      if (err instanceof import_skill_linker.LinkError) {
+      if (err instanceof import_skill_linker2.LinkError) {
         throw createServicemeError(
           "internal_error",
           `Failed to link ${params.repoId}/${params.name}: ${err.message}`
@@ -1434,12 +2920,36 @@ var SkillRepoBridgeHandler = class {
   }
   /** Inverse of `install`. Throws when no link exists. */
   async uninstall(params) {
+    const kind = params.kind ?? "skill";
+    if ((params.scope ?? "workspace") === "workspace") {
+      const coveringPlugin = await (0, import_devtools_core6.findPluginCoveringArtifact)(
+        (0, import_devtools_core6.getRepoDir)(params.repoId),
+        kind,
+        params.name
+      );
+      await (0, import_devtools_core6.removeWorkspaceContentSelection)({
+        workspaceDir: params.workspaceDir,
+        repositoryId: params.repoId,
+        pluginId: coveringPlugin ?? params.name,
+        kind
+      });
+      if (coveringPlugin) {
+        await (0, import_devtools_core6.removeWorkspaceContentSelection)({
+          workspaceDir: params.workspaceDir,
+          repositoryId: params.repoId,
+          pluginId: params.name,
+          kind
+        });
+      }
+      await this.setDeclaredArtifactDisabled(params, kind, false);
+      await this.reconcileInstalledContent(params.workspaceDir);
+    }
     try {
-      await (0, import_skill_linker.uninstallSkillFromWorkspace)({
+      await (0, import_skill_linker2.uninstallSkillFromWorkspace)({
         repoId: params.repoId,
         skillName: params.name,
         workspaceDir: params.workspaceDir,
-        kind: params.kind ?? "skill",
+        kind,
         scope: params.scope
       });
     } catch (err) {
@@ -1451,8 +2961,79 @@ var SkillRepoBridgeHandler = class {
       }
       throw err;
     }
+    await new import_devtools_core6.DisabledContentStore().removeForArtifact({
+      repoId: params.repoId,
+      name: params.name,
+      kind,
+      scope: (params.scope ?? "workspace") === "workspace" ? "workspace" : "user",
+      ...params.workspaceDir ? { workspaceDir: params.workspaceDir } : {}
+    });
     return { removed: true };
   }
+  /**
+   * Enable/disable a per-artifact skill/agent WITHOUT dropping its
+   * installation. Disable records the target in the shared declaration
+   * (`disabledArtifacts` — survives reloads and machine state loss) plus
+   * a machine-local mark, and removes the materialized link; the
+   * reconciler treats both as undeclared, so a restore never
+   * resurrects them. Enable clears both and re-links.
+   */
+  async setEntryEnabled(params) {
+    const kind = params.kind ?? "skill";
+    const scope = params.scope ?? "workspace";
+    if (scope === "workspace" && !params.workspaceDir) {
+      throw createServicemeError("invalid_params", "workspaceDir is required in workspace scope");
+    }
+    const store = new import_devtools_core6.DisabledContentStore();
+    const mark = {
+      scope,
+      repoId: params.repoId,
+      name: params.name,
+      kind,
+      ...scope === "workspace" && params.workspaceDir ? { workspaceDir: params.workspaceDir } : {}
+    };
+    if (params.enabled) {
+      await store.remove({ ...mark, scope: "user" });
+      await store.remove(mark);
+      if (scope === "workspace") {
+        await this.setDeclaredArtifactDisabled(params, kind, false);
+        await this.reconcileInstalledContent(params.workspaceDir);
+      } else {
+        const source = await this.resolveEntrySource(params.repoId, params.name, kind);
+        await this.installUserScope(
+          { ...params, workspaceDir: params.workspaceDir ?? "", scope: "user" },
+          kind,
+          source
+        );
+      }
+      return { enabled: true };
+    }
+    if (scope === "workspace") {
+      await store.add(mark);
+      await this.setDeclaredArtifactDisabled(params, kind, true);
+      await this.reconcileInstalledContent(params.workspaceDir);
+    } else {
+      let base = params.name;
+      try {
+        const source = await this.resolveEntrySource(params.repoId, params.name, kind);
+        base = source.sourceIsFile ? path5.basename(source.sourcePath) : params.name;
+      } catch {
+      }
+      const userRoot = path5.resolve(
+        path5.join((0, import_devtools_core6.getHomeDir)(), ".copilot", kind === "agent" ? "agents" : "skills")
+      );
+      const resolvedUserTarget = path5.resolve(path5.join(userRoot, base));
+      if (!resolvedUserTarget.startsWith(userRoot + path5.sep)) {
+        throw createServicemeError(
+          "invalid_params",
+          `User ${kind} link escapes the user root: ${params.name}`
+        );
+      }
+      await store.add(mark);
+      await fs3.rm(resolvedUserTarget, { force: true, recursive: true });
+    }
+    return { enabled: false };
+  }
   /**
    * List every skill currently linked into a workspace and/or the
    * global user scope. `scope` defaults to `"workspace"` for
@@ -1463,7 +3044,7 @@ var SkillRepoBridgeHandler = class {
     const kind = params.kind ?? "skill";
     const scope = params.scope ?? "workspace";
     const scopesToScan = scope === "all" ? ["workspace", "user"] : [scope];
-    const linked = (await Promise.all(scopesToScan.map((s) => (0, import_skill_linker.listLinkedSkills)(params.workspaceDir, kind, s)))).flat();
+    const linked = (await Promise.all(scopesToScan.map((s) => (0, import_skill_linker2.listLinkedSkills)(params.workspaceDir, kind, s)))).flat();
     return {
       links: linked.map((l) => ({
         repoId: l.repoId,
@@ -1475,6 +3056,136 @@ var SkillRepoBridgeHandler = class {
       }))
     };
   }
+  /**
+   * `copilotContent.detectUnmanaged` — read-only scan of a workspace
+   * that carries Copilot content without a declaration. Provenance
+   * rules live in the core detector (symlink targets, fingerprints,
+   * generated-config identity maps).
+   */
+  async detectUnmanaged(params) {
+    const catalog = await this.buildSkillStore().listAll();
+    return (0, import_devtools_core6.detectUnmanagedWorkspaceContent)({
+      workspaceDir: params.workspaceDir,
+      reposDir: (0, import_devtools_core6.getReposDir)(),
+      catalog: catalog.map((entry) => ({
+        repoId: entry.repoId,
+        name: entry.name,
+        kind: entry.kind,
+        dir: entry.dir,
+        manifestPath: entry.manifestPath
+      })),
+      knownRepoIds: new Set(
+        this.reposStore.list().filter((repo) => repo.enabled).map((repo) => repo.id)
+      )
+    });
+  }
+  /**
+   * `copilotContent.adoptUnmanaged` — initialize the declaration from
+   * detected content. Skill/agent entries reuse the install pipeline
+   * (pin commit → upsert selection → reconcile; the materializer
+   * adopts an already-matching link instead of rewriting it); real
+   * copies are converted to symlinks first when asked. Hook/MCP
+   * integrations are upserted by kind and surface through the normal
+   * approval gate on reconcile. Per-entry failures are reported as
+   * conflict statuses instead of aborting the batch.
+   */
+  async adoptUnmanaged(params) {
+    const failures = [];
+    const pluginManifests = /* @__PURE__ */ new Map();
+    for (const entry of params.entries) {
+      const key = `${entry.repoId}::${entry.name}`;
+      if (pluginManifests.has(key)) continue;
+      try {
+        const manifestPath = path5.join(
+          (0, import_devtools_core6.getRepoDir)(entry.repoId),
+          "plugins",
+          entry.name,
+          "plugin.json"
+        );
+        const raw = await fs3.readFile(manifestPath, "utf8");
+        pluginManifests.set(key, JSON.parse(raw));
+      } catch {
+      }
+    }
+    const { kept, dropped } = (0, import_devtools_core6.dedupeAdoptionsByPluginManifests)(params.entries, pluginManifests);
+    for (const { entry, coveredBy } of dropped) {
+      failures.push({
+        identity: (0, import_devtools_core6.buildContentIdentity)({
+          repoId: entry.repoId,
+          pluginId: entry.name,
+          kind: entry.kind,
+          name: entry.name
+        }),
+        status: "restored",
+        message: `Covered by the plugin ${coveredBy} selection`
+      });
+    }
+    for (const entry of kept) {
+      try {
+        if (entry.convertRealCopy === true) {
+          await this.convertToSymlink({
+            repoId: entry.repoId,
+            name: entry.name,
+            workspaceDir: params.workspaceDir,
+            kind: entry.kind,
+            scope: "workspace"
+          });
+        }
+        await this.install({
+          repoId: entry.repoId,
+          name: entry.name,
+          workspaceDir: params.workspaceDir,
+          kind: entry.kind,
+          scope: "workspace"
+        });
+      } catch (error) {
+        failures.push({
+          identity: (0, import_devtools_core6.buildContentIdentity)({
+            repoId: entry.repoId,
+            pluginId: entry.name,
+            kind: entry.kind,
+            name: entry.name
+          }),
+          status: "conflict",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    for (const integration of params.integrations ?? []) {
+      try {
+        const repo = this.reposStore.get(integration.repoId);
+        if (!repo) {
+          throw new Error(`Unknown repository ${integration.repoId}`);
+        }
+        const commit = await this.gitClient.revParseHead((0, import_devtools_core6.getRepoDir)(integration.repoId));
+        if (!/^[0-9a-f]{40}$/.test(commit)) {
+          throw new Error(`Cannot pin ${integration.repoId}: invalid commit '${commit}'`);
+        }
+        await (0, import_devtools_core6.upsertWorkspaceContentSelection)({
+          workspaceDir: params.workspaceDir,
+          repository: { id: repo.id, url: repo.url, commit },
+          pluginId: integration.pluginId,
+          kind: integration.kind
+        });
+      } catch (error) {
+        failures.push({
+          identity: (0, import_devtools_core6.buildContentIdentity)({
+            repoId: integration.repoId,
+            pluginId: integration.pluginId,
+            kind: integration.kind,
+            name: integration.pluginId
+          }),
+          status: "conflict",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    const restored = await this.reconcileInstalledContent(params.workspaceDir);
+    return {
+      changed: restored.changed,
+      entries: [...restored.entries, ...failures]
+    };
+  }
   // ─────────────────────────────────────────────────────────────────
   // skillRepo.draft.*
   // ─────────────────────────────────────────────────────────────────
@@ -1493,7 +3204,7 @@ var SkillRepoBridgeHandler = class {
       });
       return { id };
     } catch (err) {
-      if (err instanceof import_devtools_core3.InvalidDraftError) {
+      if (err instanceof import_devtools_core6.InvalidDraftError) {
         throw createServicemeError("invalid_params", err.message);
       }
       throw err;
@@ -1518,6 +3229,7 @@ var SkillRepoBridgeHandler = class {
         detail.files,
         { branch: params.branch, skipPush: params.skipPush }
       );
+      this.invalidateSkillStoreCache();
       return {
         repoId: result.repoId,
         skillName: result.skillName,
@@ -1639,6 +3351,7 @@ var SkillRepoBridgeHandler = class {
   async repoSync(params) {
     const repoManager = this.buildRepoManager();
     const result = await repoManager.pullOne(params.repoId);
+    this.invalidateSkillStoreCache();
     return {
       pulls: [
         {
@@ -1653,6 +3366,7 @@ var SkillRepoBridgeHandler = class {
   async repoSyncAll(_params) {
     const repoManager = this.buildRepoManager();
     const report = await repoManager.pullAll();
+    this.invalidateSkillStoreCache();
     return {
       pulls: report.pulls.map((p) => ({
         repoId: p.repoId,
@@ -1662,19 +3376,92 @@ var SkillRepoBridgeHandler = class {
       }))
     };
   }
+  /**
+   * `repo.resetParseCache` — recover from historical-parser drift.
+   * Deletes each enabled repo's local checkout so the follow-up
+   * pull re-clones it, then re-lists through the current SkillStore
+   * parsing rules. Fresh mtimes also invalidate the plugin-catalog
+   * mtime cache, so every downstream list rebuilds from scratch.
+   */
+  async repoResetParseCache(_params) {
+    const repoManager = this.buildRepoManager();
+    const pulls = [];
+    for (const repo of this.reposStore.list().filter((r) => r.enabled)) {
+      const checkout = (0, import_devtools_core6.getRepoDir)(repo.id);
+      await fs3.rm(checkout, { recursive: true, force: true });
+      try {
+        const result = await repoManager.pullOne(repo.id);
+        pulls.push({
+          repoId: repo.id,
+          status: "ok",
+          commitSha: result.commitSha || void 0
+        });
+      } catch (error) {
+        pulls.push({
+          repoId: repo.id,
+          status: "error",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    this.invalidateSkillStoreCache();
+    return { pulls };
+  }
   // ─────────────────────────────────────────────────────────────────
   // Internals
   // ─────────────────────────────────────────────────────────────────
   /**
-   * Build a fresh SkillStore from the current repos.json state. The
-   * SkillStore is read-only — it does not mutate the repos store —
-   * so per-call instantiation is safe and keeps us in sync with
-   * fs.watch-triggered writes from the CLI's `repos` subcommand.
+   * Return a SkillStore over the current enabled repos, reusing the
+   * previously built one while the enabled-repo set is unchanged and
+   * the reuse window hasn't elapsed. The store is read-only — it does
+   * not mutate the repos store — and its memoized catalog walk is the
+   * expensive part, so reuse is what keeps the webview's startup
+   * polling from rescanning every checkout. A `repoIdFilter` no longer
+   * narrows the constructed store: the shared store spans all enabled
+   * repos and the caller walks just the one it asked for, which keeps
+   * cache reuse across differently-filtered calls. Disabled repos are
+   * never in the store, so a filtered walk over one yields [] exactly
+   * as before.
    */
-  buildSkillStore(repoIdFilter) {
-    const all = this.reposStore.list();
-    const repos = all.filter((r) => r.enabled).filter((r) => !repoIdFilter || r.id === repoIdFilter).map((r) => ({ id: r.id, rootPath: (0, import_devtools_core3.getRepoDir)(r.id) }));
-    return new import_skill_store.SkillStore({ repos });
+  buildSkillStore() {
+    const enabled = this.reposStore.list().filter((r) => r.enabled);
+    const signature = enabled.map((r) => r.id).sort().join("\0");
+    const cached = this.skillStoreCache;
+    if (this.skillStoreCacheTtlMs > 0 && cached && cached.signature === signature && Date.now() - cached.computedAt < this.skillStoreCacheTtlMs) {
+      return cached.store;
+    }
+    const store = new import_skill_store.SkillStore({
+      repos: enabled.map((r) => ({ id: r.id, rootPath: (0, import_devtools_core6.getRepoDir)(r.id) }))
+    });
+    this.skillStoreCache = { signature, store, computedAt: Date.now() };
+    return store;
+  }
+  /** Drop the cached store so the next list/get re-walks from disk. */
+  invalidateSkillStoreCache() {
+    this.skillStoreCache = void 0;
+  }
+  /**
+   * Mirror an enable/disable toggle into the shared declaration's
+   * `disabledArtifacts` field (same covering-plugin rule the install
+   * pipeline uses). Best-effort for the REPO-side lookups: a missing
+   * repo/checkout must not fail the toggle — the machine-local mark
+   * still applies, and the declaration converges on the next install.
+   */
+  async setDeclaredArtifactDisabled(params, kind, disabled) {
+    const { workspaceDir } = params;
+    if (!workspaceDir) return;
+    let pluginId = params.name;
+    try {
+      pluginId = await (0, import_devtools_core6.findPluginCoveringArtifact)((0, import_devtools_core6.getRepoDir)(params.repoId), kind, params.name) ?? params.name;
+    } catch {
+    }
+    await (0, import_devtools_core6.setWorkspacePluginArtifactsDisabled)({
+      workspaceDir,
+      repositoryId: params.repoId,
+      pluginId,
+      target: `${kind}:${params.name}`,
+      disabled
+    }).catch(() => void 0);
   }
   /**
    * Resolve an entry's actual on-disk location via `SkillStore` for
@@ -1688,7 +3475,7 @@ var SkillRepoBridgeHandler = class {
    * for.
    */
   async resolveEntrySource(repoId, name, kind) {
-    const store = this.buildSkillStore(repoId);
+    const store = this.buildSkillStore();
     let entry;
     try {
       entry = await store.get(repoId, name);
@@ -1709,9 +3496,15 @@ var SkillRepoBridgeHandler = class {
       store: this.reposStore,
       gitClient: this.gitClient
     };
-    return new import_devtools_core3.RepoManager(opts);
+    return new import_devtools_core6.RepoManager(opts);
   }
 };
+function stripAgentSuffix(basename4) {
+  return basename4.replace(/\.agent\.md$/, "");
+}
+function disabledMarkApplies(mark, entry, workspaceDir) {
+  return mark.repoId === entry.repoId && mark.name === entry.name && mark.kind === entry.kind && (mark.scope === "user" || workspaceDir !== void 0 && mark.workspaceDir === workspaceDir);
+}
 function toBridgeEntry(e) {
   return {
     repoId: e.repoId,
@@ -1745,20 +3538,20 @@ function toBridgeRepoEntry(repo) {
 // src/commands/bridge.ts
 var DEFAULT_GIT_PROXY_BASE = "http://127.0.0.1:3000/git-proxy";
 async function runBridgeCommand() {
-  const logger = (0, import_devtools_core4.createConsoleLogger)("serviceme:bridge");
-  const configPath = (0, import_devtools_core4.getReposConfigPath)();
-  const reposStore = new import_devtools_core4.ReposStore({
-    loader: new import_devtools_core4.ReposLoader({ configPath })
+  const logger = (0, import_devtools_core7.createConsoleLogger)("serviceme:bridge");
+  const configPath = (0, import_devtools_core7.getReposConfigPath)();
+  const reposStore = new import_devtools_core7.ReposStore({
+    loader: new import_devtools_core7.ReposLoader({ configPath })
   });
   try {
-    await (0, import_devtools_core4.bootstrapDefaults)(reposStore);
+    await (0, import_devtools_core7.bootstrapDefaults)(reposStore);
   } catch (err) {
     logger.warn("repos.json bootstrap failed; continuing with empty config", err);
   }
   const serverProxyBase = process.env.SERVICEME_GIT_PROXY_BASE ?? DEFAULT_GIT_PROXY_BASE;
-  const gitClient = new import_devtools_core4.GitClient({ serverProxyBase });
-  const draftsStore = new import_devtools_core4.DraftsStore();
-  const submitClient = new import_devtools_core4.SubmitClient({ gitClient });
+  const gitClient = new import_devtools_core7.GitClient({ serverProxyBase });
+  const draftsStore = new import_devtools_core7.DraftsStore();
+  const submitClient = new import_devtools_core7.SubmitClient({ gitClient });
   const skillRepoHandler = new SkillRepoBridgeHandler({
     reposStore,
     gitClient,
@@ -1770,7 +3563,7 @@ async function runBridgeCommand() {
 }
 
 // src/commands/copilot.ts
-var import_devtools_core5 = require("@serviceme/devtools-core");
+var import_devtools_core8 = require("@serviceme/devtools-core");
 async function runCopilotCommand(parsed) {
   const action = parsed.positionals[1];
   switch (action) {
@@ -1785,12 +3578,12 @@ async function runCopilotCommand(parsed) {
   }
 }
 async function handleDoctor() {
-  const result = await (0, import_devtools_core5.copilotDoctor)();
+  const result = await (0, import_devtools_core8.copilotDoctor)();
   if (!result.installed) {
-    throw (0, import_devtools_core5.createCopilotNotInstalledError)();
+    throw (0, import_devtools_core8.createCopilotNotInstalledError)();
   }
   if (!result.authenticated) {
-    throw (0, import_devtools_core5.createCopilotAuthRequiredError)();
+    throw (0, import_devtools_core8.createCopilotAuthRequiredError)();
   }
   writeSuccess(result);
 }
@@ -1807,7 +3600,7 @@ async function handlePrompt(parsed) {
   const allowTools = allowToolRaw ? String(allowToolRaw).split(",") : void 0;
   const model = parsed.flags.get("model");
   const agent = parsed.flags.get("agent");
-  const result = await (0, import_devtools_core5.copilotPrompt)({
+  const result = await (0, import_devtools_core8.copilotPrompt)({
     prompt,
     workspace,
     autopilot,
@@ -1883,9 +3676,9 @@ async function handleRotateSecret(parsed) {
 }
 
 // src/commands/env.ts
-var import_devtools_core6 = require("@serviceme/devtools-core");
+var import_devtools_core9 = require("@serviceme/devtools-core");
 async function runEnvCommand(parsed) {
-  const inspector = new import_devtools_core6.EnvironmentInspector();
+  const inspector = new import_devtools_core9.EnvironmentInspector();
   const action = parsed.positionals[1];
   if (action !== "check") {
     throw new Error("Unsupported env command. Use check.");
@@ -1902,10 +3695,10 @@ async function runEnvCommand(parsed) {
 }
 
 // src/commands/image.ts
-var import_devtools_core7 = require("@serviceme/devtools-core");
+var import_devtools_core10 = require("@serviceme/devtools-core");
 var IMAGE_FORMATS = /* @__PURE__ */ new Set(["jpeg", "png", "webp"]);
 async function runImageCommand(parsed) {
-  const imageTools = (0, import_devtools_core7.createImageTools)();
+  const imageTools = (0, import_devtools_core10.createImageTools)();
   const action = parsed.positionals[1];
   const filePath = getStringFlag(parsed, "file");
   const sharpModulePath = getStringFlag(parsed, "sharpModulePath");
@@ -1940,13 +3733,24 @@ async function runImageCommand(parsed) {
 }
 
 // src/commands/json.ts
-var import_devtools_core8 = require("@serviceme/devtools-core");
+var import_devtools_core11 = require("@serviceme/devtools-core");
 
 // src/input.ts
-var fs2 = __toESM(require("fs/promises"));
+var fs4 = __toESM(require("fs/promises"));
+var path6 = __toESM(require("path"));
+function sanitizeCliFilePath(value) {
+  const hasControlCharacter = [...value].some((character) => {
+    const code = character.charCodeAt(0);
+    return code > 0 && code < 32;
+  });
+  if (hasControlCharacter) {
+    throw new Error("Invalid --file path: control characters are not allowed.");
+  }
+  return path6.resolve(value);
+}
 async function readCommandInput(options) {
   if (options.filePath) {
-    return fs2.readFile(options.filePath, "utf8");
+    return fs4.readFile(sanitizeCliFilePath(options.filePath), "utf8");
   }
   if (options.stdin) {
     return readStdin();
@@ -1963,7 +3767,7 @@ async function readStdin() {
 
 // src/commands/json.ts
 async function runJsonCommand(parsed) {
-  const jsonTools = (0, import_devtools_core8.createJsonTools)();
+  const jsonTools = (0, import_devtools_core11.createJsonTools)();
   const action = parsed.positionals[1];
   const input = await readCommandInput({
     stdin: getBooleanFlag(parsed, "stdin"),
@@ -1999,9 +3803,9 @@ async function runJsonCommand(parsed) {
 }
 
 // src/commands/project.ts
-var import_devtools_core9 = require("@serviceme/devtools-core");
+var import_devtools_core12 = require("@serviceme/devtools-core");
 async function runProjectCommand(parsed) {
-  const projectTools = (0, import_devtools_core9.createProjectTools)();
+  const projectTools = (0, import_devtools_core12.createProjectTools)();
   const action = parsed.positionals[1];
   const workspacePath = getStringFlag(parsed, "workspacePath");
   if (!workspacePath) {
@@ -2052,7 +3856,7 @@ async function runProjectCommand(parsed) {
 }
 
 // src/commands/repos.ts
-var import_devtools_core10 = require("@serviceme/devtools-core");
+var import_devtools_core13 = require("@serviceme/devtools-core");
 function requireRepoId(parsed) {
   const repoId = getStringFlag(parsed, "repo-id");
   if (!repoId) {
@@ -2062,10 +3866,10 @@ function requireRepoId(parsed) {
 }
 function newStoreAndManager(parsed) {
   const proxyBase = getStringFlag(parsed, "git-proxy-base") ?? "http://127.0.0.1:3000/git-proxy";
-  const loader = new import_devtools_core10.ReposLoader({ configPath: (0, import_devtools_core10.getReposConfigPath)() });
-  const store = new import_devtools_core10.ReposStore({ loader });
-  const gitClient = new import_devtools_core10.GitClient({ serverProxyBase: proxyBase });
-  const manager = new import_devtools_core10.RepoManager({ store, gitClient });
+  const loader = new import_devtools_core13.ReposLoader({ configPath: (0, import_devtools_core13.getReposConfigPath)() });
+  const store = new import_devtools_core13.ReposStore({ loader });
+  const gitClient = new import_devtools_core13.GitClient({ serverProxyBase: proxyBase });
+  const manager = new import_devtools_core13.RepoManager({ store, gitClient });
   return { store, manager };
 }
 async function ensureStore(store) {
@@ -2084,7 +3888,7 @@ async function handleList2(parsed) {
     enabled: r.enabled,
     writeEnabled: r.writeEnabled,
     source: r.source,
-    description: (0, import_devtools_core10.isDefaultRepo)(r) ? r.description : void 0,
+    description: (0, import_devtools_core13.isDefaultRepo)(r) ? r.description : void 0,
     addedAt: r.addedAt,
     lastSyncAt: r.lastSyncAt,
     lastSyncCommitSha: r.lastSyncCommitSha,
@@ -2137,7 +3941,7 @@ async function handleEnable(parsed) {
       enabled: repo.enabled,
       writeEnabled: repo.writeEnabled,
       source: repo.source,
-      description: (0, import_devtools_core10.isDefaultRepo)(repo) ? repo.description : void 0,
+      description: (0, import_devtools_core13.isDefaultRepo)(repo) ? repo.description : void 0,
       addedAt: repo.addedAt
     }
   };
@@ -2154,7 +3958,7 @@ async function handleDisable(parsed) {
       enabled: repo.enabled,
       writeEnabled: repo.writeEnabled,
       source: repo.source,
-      description: (0, import_devtools_core10.isDefaultRepo)(repo) ? repo.description : void 0,
+      description: (0, import_devtools_core13.isDefaultRepo)(repo) ? repo.description : void 0,
       addedAt: repo.addedAt
     }
   };
@@ -2223,9 +4027,9 @@ async function runReposCommand(parsed) {
 }
 
 // src/commands/schedule.ts
-var fs3 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
-var import_devtools_core11 = require("@serviceme/devtools-core");
+var fs5 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var import_devtools_core14 = require("@serviceme/devtools-core");
 async function runScheduleCommand(parsed) {
   const action = parsed.positionals[1];
   if (getBooleanFlag(parsed, "describe")) {
@@ -2269,7 +4073,7 @@ function requireWorkspace(parsed) {
   if (!wp) {
     throw createServicemeError("invalid_params", "Missing required flag: --workspacePath");
   }
-  if (!fs3.existsSync(wp)) {
+  if (!fs5.existsSync(wp)) {
     throw createServicemeError("workspace_not_found", `Workspace path does not exist: ${wp}`);
   }
   return wp;
@@ -2279,6 +4083,9 @@ function requireId(parsed) {
   if (!id) {
     throw createServicemeError("invalid_params", "Missing required flag: --id <task-id>");
   }
+  if (!/^[A-Za-z0-9._-]+$/.test(id)) {
+    throw createServicemeError("invalid_params", "Invalid --id: must match [A-Za-z0-9._-]");
+  }
   return id;
 }
 function requireConfirmation(parsed) {
@@ -2309,6 +4116,16 @@ function parsePayload(parsed, taskType) {
           "invalid_payload",
           "Missing --script for shell task (or use --payload-json)"
         );
+      const hasControlCharacter = [...script].some((character) => {
+        const code = character.charCodeAt(0);
+        return code > 0 && code < 32 && character !== "	";
+      });
+      if (hasControlCharacter) {
+        throw createServicemeError(
+          "invalid_payload",
+          "Invalid --script: control characters are not allowed"
+        );
+      }
       return {
         script,
         cwd: getStringFlag(parsed, "cwd"),
@@ -2408,7 +4225,7 @@ async function handleCreate(parsed) {
   const payload = parsePayload(parsed, taskType);
   const description = getStringFlag(parsed, "description");
   const enabled = getStringFlag(parsed, "enabled") !== "false";
-  const mgr = new import_devtools_core11.TaskConfigManager();
+  const mgr = new import_devtools_core14.TaskConfigManager();
   const existing = mgr.getTaskByName(name);
   if (existing) {
     throw createServicemeError(
@@ -2425,7 +4242,7 @@ async function handleCreate(parsed) {
     payload,
     workspace: {
       path: wp,
-      name: path2.basename(wp) || wp
+      name: path7.basename(wp) || wp
     },
     enabled
   };
@@ -2450,7 +4267,7 @@ async function handleCreate(parsed) {
 }
 function handleList3(parsed) {
   requireWorkspace(parsed);
-  const mgr = new import_devtools_core11.TaskConfigManager();
+  const mgr = new import_devtools_core14.TaskConfigManager();
   const tasks = mgr.listTasks();
   const fields = getStringFlag(parsed, "fields");
   const limitStr = getStringFlag(parsed, "limit");
@@ -2466,7 +4283,7 @@ function handleList3(parsed) {
 function handleGet(parsed) {
   requireWorkspace(parsed);
   const id = requireId(parsed);
-  const mgr = new import_devtools_core11.TaskConfigManager();
+  const mgr = new import_devtools_core14.TaskConfigManager();
   const task = mgr.getTask(id);
   if (!task) {
     throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
@@ -2478,7 +4295,7 @@ function handleGet(parsed) {
 async function handleEdit(parsed) {
   requireWorkspace(parsed);
   const id = requireId(parsed);
-  const mgr = new import_devtools_core11.TaskConfigManager();
+  const mgr = new import_devtools_core14.TaskConfigManager();
   const existing = mgr.getTask(id);
   if (!existing) {
     throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
@@ -2523,7 +4340,7 @@ function handleDelete(parsed) {
   requireWorkspace(parsed);
   const id = requireId(parsed);
   requireConfirmation(parsed);
-  const mgr = new import_devtools_core11.TaskConfigManager();
+  const mgr = new import_devtools_core14.TaskConfigManager();
   const existing = mgr.getTask(id);
   if (!existing) {
     throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
@@ -2543,7 +4360,7 @@ function handleToggle(parsed) {
     throw createServicemeError("invalid_params", "Missing required flag: --enabled <true|false>");
   }
   const enabled = enabledStr !== "false";
-  const mgr = new import_devtools_core11.TaskConfigManager();
+  const mgr = new import_devtools_core14.TaskConfigManager();
   const existing = mgr.getTask(id);
   if (!existing) {
     throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
@@ -2554,22 +4371,22 @@ function handleToggle(parsed) {
 async function handleTrigger(parsed) {
   requireWorkspace(parsed);
   const id = requireId(parsed);
-  const mgr = new import_devtools_core11.TaskConfigManager();
+  const mgr = new import_devtools_core14.TaskConfigManager();
   const task = mgr.getTask(id);
   if (!task) {
     throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
   }
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const executionPayload = (0, import_devtools_core11.resolveTaskExecutionPayload)(
+  const executionPayload = (0, import_devtools_core14.resolveTaskExecutionPayload)(
     task.taskType,
     task.payload,
     task.workspace.path
   );
-  (0, import_devtools_core11.validateTaskPayload)(task.taskType, executionPayload);
-  const executor = (0, import_devtools_core11.getExecutor)(task.taskType);
+  (0, import_devtools_core14.validateTaskPayload)(task.taskType, executionPayload);
+  const executor = (0, import_devtools_core14.getExecutor)(task.taskType);
   const result = await executor.execute(executionPayload);
   const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const logMgr = new import_devtools_core11.TaskLogManager();
+  const logMgr = new import_devtools_core14.TaskLogManager();
   const log = logMgr.appendLog({
     taskId: task.id,
     taskName: task.name,
@@ -2587,7 +4404,7 @@ function handleLogs(parsed) {
   const limitStr = getStringFlag(parsed, "limit");
   const limit = limitStr ? Math.min(Number(limitStr), 200) : 20;
   const fields = getStringFlag(parsed, "fields");
-  const logMgr = new import_devtools_core11.TaskLogManager();
+  const logMgr = new import_devtools_core14.TaskLogManager();
   const { logs, total } = logMgr.getLogs({ taskId, limit });
   const result = logs.map((l) => filterFields(l, fields));
   writeSuccess({ logs: result, total });
@@ -2759,9 +4576,9 @@ function writeDescribe(action) {
 
 // src/commands/scheduler.ts
 var import_node_child_process = require("child_process");
-var fs4 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
-var import_devtools_core12 = require("@serviceme/devtools-core");
+var fs6 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+var import_devtools_core15 = require("@serviceme/devtools-core");
 var REPO_SYNC_INTERVAL_MS = 5 * 60 * 1e3;
 async function runSchedulerCommand(parsed) {
   const action = parsed.positionals[1];
@@ -2799,25 +4616,25 @@ async function runSchedulerCommand(parsed) {
   }
 }
 function listTasks() {
-  const mgr = new import_devtools_core12.TaskConfigManager();
+  const mgr = new import_devtools_core15.TaskConfigManager();
   const tasks = mgr.listTasks();
   return [...tasks].sort((a, b) => a.name.localeCompare(b.name));
 }
 function readLogs(options = {}) {
-  const mgr = new import_devtools_core12.TaskLogManager();
+  const mgr = new import_devtools_core15.TaskLogManager();
   const limit = options.limit && options.limit > 0 ? Math.min(options.limit, 200) : 50;
   return mgr.getLogs({ taskId: options.taskId, limit });
 }
 function getSchedulerStatus() {
-  const pidMgr = new import_devtools_core12.PidManager("", { pidPath: (0, import_devtools_core12.getSchedulerPidPath)() });
-  const configMgr = new import_devtools_core12.TaskConfigManager();
+  const pidMgr = new import_devtools_core15.PidManager("", { pidPath: (0, import_devtools_core15.getSchedulerPidPath)() });
+  const configMgr = new import_devtools_core15.TaskConfigManager();
   const pid = pidMgr.getRunningPid();
   const config = configMgr.readConfig();
   let uptimeSeconds = null;
   if (pid !== null) {
     try {
-      const stat2 = fs4.statSync(pidMgr.getPidPath());
-      uptimeSeconds = Math.floor((Date.now() - stat2.mtimeMs) / 1e3);
+      const stat4 = fs6.statSync(pidMgr.getPidPath());
+      uptimeSeconds = Math.floor((Date.now() - stat4.mtimeMs) / 1e3);
     } catch {
       uptimeSeconds = null;
     }
@@ -2834,7 +4651,7 @@ function getSchedulerStatus() {
   };
 }
 function handleStart(_parsed) {
-  const pidMgr = new import_devtools_core12.PidManager("", { pidPath: (0, import_devtools_core12.getSchedulerPidPath)() });
+  const pidMgr = new import_devtools_core15.PidManager("", { pidPath: (0, import_devtools_core15.getSchedulerPidPath)() });
   const existingPid = pidMgr.getRunningPid();
   if (existingPid !== null) {
     writeSuccess({
@@ -2847,15 +4664,19 @@ function handleStart(_parsed) {
   if (!cliPath) {
     throw createServicemeError("internal_error", "Cannot determine CLI path for daemon spawn");
   }
-  const logPath = (0, import_devtools_core12.getSchedulerLogPath)();
-  const logDir = path3.dirname(logPath);
-  if (!fs4.existsSync(logDir)) {
-    fs4.mkdirSync(logDir, { recursive: true });
+  const logPath = (0, import_devtools_core15.getSchedulerLogPath)();
+  const homeRoot = path8.resolve((0, import_devtools_core15.getServicemeHome)());
+  if (!path8.resolve(logPath).startsWith(homeRoot + path8.sep)) {
+    throw createServicemeError("internal_error", "Scheduler log path escapes the SERVICEME home");
+  }
+  const logDir = path8.dirname(logPath);
+  if (!fs6.existsSync(logDir)) {
+    fs6.mkdirSync(logDir, { recursive: true });
   }
   const spawnCmd = process.execPath;
-  const spawnArgs = [cliPath, "scheduler", "__daemon", "--logPath", logPath];
+  const spawnArgs = [cliPath, "scheduler", "__daemon", `--logPath=${logPath}`];
   if (process.platform === "win32") {
-    fs4.appendFileSync(
+    fs6.appendFileSync(
       logPath,
       `[scheduler:start] spawning daemon via hidden PowerShell Start-Process: cmd=${spawnCmd}, args=${JSON.stringify(spawnArgs)}, platform=${process.platform}, windowsHide=true
 `
@@ -2865,9 +4686,9 @@ function handleStart(_parsed) {
     writeSuccess({ pid: pid2, status: "started" });
     return;
   }
-  const out = fs4.openSync(logPath, "a");
-  const err = fs4.openSync(logPath, "a");
-  fs4.appendFileSync(
+  const out = fs6.openSync(logPath, "a");
+  const err = fs6.openSync(logPath, "a");
+  fs6.appendFileSync(
     logPath,
     `[scheduler:start] spawning daemon: cmd=${spawnCmd}, args=${JSON.stringify(spawnArgs)}, platform=${process.platform}, detached=true, windowsHide=true
 `
@@ -2946,7 +4767,7 @@ function handleStop(parsed) {
       );
     }
   }
-  const pidMgr = new import_devtools_core12.PidManager("", { pidPath: (0, import_devtools_core12.getSchedulerPidPath)() });
+  const pidMgr = new import_devtools_core15.PidManager("", { pidPath: (0, import_devtools_core15.getSchedulerPidPath)() });
   const pid = pidMgr.getRunningPid();
   if (pid === null) {
     throw createServicemeError("daemon_not_running", "Scheduler daemon is not running");
@@ -2986,9 +4807,13 @@ function handleLogs2(parsed) {
 async function runDaemon(parsed) {
   const logPath = getStringFlag(parsed, "logPath");
   if (logPath) {
+    const homeRoot = path8.resolve((0, import_devtools_core15.getServicemeHome)());
+    if (!path8.resolve(logPath).startsWith(homeRoot + path8.sep)) {
+      throw createServicemeError("invalid_params", "--logPath must stay inside the SERVICEME home");
+    }
     process.env.SERVICEME_SCHEDULER_LOG_PATH = logPath;
   }
-  const pidMgr = new import_devtools_core12.PidManager("", { pidPath: (0, import_devtools_core12.getSchedulerPidPath)() });
+  const pidMgr = new import_devtools_core15.PidManager("", { pidPath: (0, import_devtools_core15.getSchedulerPidPath)() });
   const existingPid = pidMgr.getRunningPid();
   if (existingPid !== null && existingPid !== process.pid) {
     process.exit(0);
@@ -3013,11 +4838,11 @@ function startRepoSyncTick() {
 }
 async function runRepoSyncOnce() {
   const proxyBase = process.env.SERVICEME_GIT_PROXY_BASE ?? "http://127.0.0.1:3000/git-proxy";
-  const loader = new import_devtools_core12.ReposLoader({ configPath: (0, import_devtools_core12.getReposConfigPath)() });
-  const store = new import_devtools_core12.ReposStore({ loader });
+  const loader = new import_devtools_core15.ReposLoader({ configPath: (0, import_devtools_core15.getReposConfigPath)() });
+  const store = new import_devtools_core15.ReposStore({ loader });
   await store.ensureLoaded();
-  const gitClient = new import_devtools_core12.GitClient({ serverProxyBase: proxyBase });
-  const manager = new import_devtools_core12.RepoManager({ store, gitClient });
+  const gitClient = new import_devtools_core15.GitClient({ serverProxyBase: proxyBase });
+  const manager = new import_devtools_core15.RepoManager({ store, gitClient });
   const report = await manager.pullAll();
   const ok = report.pulls.filter((p) => p.status === "ok").length;
   const err = report.pulls.filter((p) => p.status === "error").length;
@@ -3027,8 +4852,8 @@ async function runRepoSyncOnce() {
 }
 function appendSchedulerLog(message) {
   try {
-    const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH ?? (0, import_devtools_core12.getSchedulerLogPath)();
-    fs4.appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
+    const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH ?? (0, import_devtools_core15.getSchedulerLogPath)();
+    fs6.appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
 `, "utf8");
   } catch {
   }
@@ -3087,10 +4912,10 @@ function writeDescribe2(action) {
 }
 
 // src/commands/skill.ts
-var fs5 = __toESM(require("fs/promises"));
+var fs7 = __toESM(require("fs/promises"));
 var os2 = __toESM(require("os"));
-var path4 = __toESM(require("path"));
-var import_devtools_core13 = require("@serviceme/devtools-core");
+var path9 = __toESM(require("path"));
+var import_devtools_core16 = require("@serviceme/devtools-core");
 function normalizeSkillIdOrThrow(store, remoteId) {
   try {
     return store.normalizeRemoteSkillId(remoteId);
@@ -3104,14 +4929,14 @@ async function runSkillCommand(parsed) {
   if (!workspacePath) {
     throw createServicemeError("invalid_params", "Expected --workspacePath <path>.");
   }
-  const store = new import_devtools_core13.SkillStore({
+  const store = new import_devtools_core16.SkillStore({
     workspacePath,
-    userSkillsRoot: path4.join(os2.homedir(), ".agents", "skills")
+    userSkillsRoot: path9.join(os2.homedir(), ".copilot", "skills")
   });
-  const catalogClient = new import_devtools_core13.SkillCatalogClient({
+  const catalogClient = new import_devtools_core16.SkillCatalogClient({
     baseUrl: getStringFlag(parsed, "baseUrl")
   });
-  const reconciler = new import_devtools_core13.SkillReconciler({
+  const reconciler = new import_devtools_core16.SkillReconciler({
     skillStore: store,
     catalogClient
   });
@@ -3220,11 +5045,24 @@ async function handleUninstall2(store, workspacePath, parsed) {
     throw createServicemeError("invalid_params", "Expected --id <remoteSkillId>.");
   }
   const skillId = normalizeSkillIdOrThrow(store, remoteId);
-  await fs5.rm(path4.join(workspacePath, store.getWorkspaceSkillPath(skillId)), {
+  const workspaceRoot = path9.resolve(workspacePath);
+  const workspaceLinkPath = path9.resolve(workspaceRoot, store.getWorkspaceSkillPath(skillId));
+  if (!workspaceLinkPath.startsWith(workspaceRoot + path9.sep)) {
+    throw createServicemeError("invalid_params", `Skill link escapes the workspace: ${skillId}`);
+  }
+  await fs7.rm(workspaceLinkPath, {
     recursive: true,
     force: true
   });
-  await fs5.rm(store.getUserSkillPath(skillId), {
+  const userSkillsRoot = path9.resolve(path9.join(os2.homedir(), ".copilot", "skills"));
+  const userSkillPath = path9.resolve(store.getUserSkillPath(skillId));
+  if (!userSkillPath.startsWith(userSkillsRoot + path9.sep)) {
+    throw createServicemeError(
+      "invalid_params",
+      `User skill link escapes the skills root: ${skillId}`
+    );
+  }
+  await fs7.rm(userSkillPath, {
     recursive: true,
     force: true
   });
@@ -3246,7 +5084,7 @@ async function handleMove2(store, workspacePath, parsed) {
     throw createServicemeError("invalid_params", "Expected --to value to be workspace or user.");
   }
   const skillId = normalizeSkillIdOrThrow(store, remoteId);
-  const workspacePathForSkill = path4.join(workspacePath, store.getWorkspaceSkillPath(skillId));
+  const workspacePathForSkill = path9.join(workspacePath, store.getWorkspaceSkillPath(skillId));
   const userPathForSkill = store.getUserSkillPath(skillId);
   if (to === "user") {
     await moveDirectory(workspacePathForSkill, userPathForSkill);
@@ -3267,12 +5105,12 @@ async function handleMove2(store, workspacePath, parsed) {
   };
 }
 async function moveDirectory(fromPath, toPath) {
-  await fs5.mkdir(path4.dirname(toPath), { recursive: true });
+  await fs7.mkdir(path9.dirname(toPath), { recursive: true });
   try {
-    await fs5.rename(fromPath, toPath);
+    await fs7.rename(fromPath, toPath);
   } catch {
-    await fs5.cp(fromPath, toPath, { recursive: true });
-    await fs5.rm(fromPath, { recursive: true, force: true });
+    await fs7.cp(fromPath, toPath, { recursive: true });
+    await fs7.rm(fromPath, { recursive: true, force: true });
   }
 }
 async function handleMarketplace2(store, catalogClient) {
@@ -3373,15 +5211,15 @@ async function handlePublishable(store, workspacePath) {
     skills: workspaceSkillIds.map((skillId) => ({
       id: skillId,
       displayName: skillId,
-      path: path4.join(workspacePath, store.getWorkspaceSkillPath(skillId))
+      path: path9.join(workspacePath, store.getWorkspaceSkillPath(skillId))
     }))
   };
 }
 
 // src/commands/skills.ts
-var fs6 = __toESM(require("fs/promises"));
-var path5 = __toESM(require("path"));
-var import_devtools_core14 = require("@serviceme/devtools-core");
+var fs8 = __toESM(require("fs/promises"));
+var path10 = __toESM(require("path"));
+var import_devtools_core17 = require("@serviceme/devtools-core");
 function requireFlag(parsed, name) {
   const value = getStringFlag(parsed, name);
   if (!value) {
@@ -3422,13 +5260,13 @@ function parseMode(raw) {
 }
 async function newSkillRepoHandler(parsed) {
   const proxyBase = getStringFlag(parsed, "git-proxy-base") ?? "http://127.0.0.1:3000/git-proxy";
-  const reposStore = new import_devtools_core14.ReposStore({
-    loader: new import_devtools_core14.ReposLoader({ configPath: (0, import_devtools_core14.getReposConfigPath)() })
+  const reposStore = new import_devtools_core17.ReposStore({
+    loader: new import_devtools_core17.ReposLoader({ configPath: (0, import_devtools_core17.getReposConfigPath)() })
   });
   await reposStore.ensureLoaded();
-  const gitClient = new import_devtools_core14.GitClient({ serverProxyBase: proxyBase });
-  const draftsStore = new import_devtools_core14.DraftsStore();
-  const submitClient = new import_devtools_core14.SubmitClient({ gitClient });
+  const gitClient = new import_devtools_core17.GitClient({ serverProxyBase: proxyBase });
+  const draftsStore = new import_devtools_core17.DraftsStore();
+  const submitClient = new import_devtools_core17.SubmitClient({ gitClient });
   return new SkillRepoBridgeHandler({
     reposStore,
     gitClient,
@@ -3437,9 +5275,9 @@ async function newSkillRepoHandler(parsed) {
   });
 }
 async function readDraftFilesFromDir(dirPath) {
-  let stat2;
+  let stat4;
   try {
-    stat2 = await fs6.stat(dirPath);
+    stat4 = await fs8.stat(dirPath);
   } catch (err) {
     const code = err.code;
     throw createServicemeError(
@@ -3447,17 +5285,19 @@ async function readDraftFilesFromDir(dirPath) {
       `--dir '${dirPath}' is not readable${code === "ENOENT" ? " (path does not exist)" : `: ${err.message}`}`
     );
   }
-  if (!stat2.isDirectory()) {
+  if (!stat4.isDirectory()) {
     throw createServicemeError("invalid_params", `--dir '${dirPath}' is not a directory`);
   }
   const files = [];
   let manifestFound = false;
+  const dirRoot = path10.resolve(dirPath);
   async function walk(currentAbs, currentRel) {
-    const entries = await fs6.readdir(currentAbs, { withFileTypes: true });
+    const entries = await fs8.readdir(currentAbs, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
       if (entry.name === "node_modules") continue;
-      const childAbs = path5.join(currentAbs, entry.name);
+      const childAbs = path10.resolve(currentAbs, entry.name);
+      if (!childAbs.startsWith(dirRoot + path10.sep)) continue;
       const childRel = currentRel ? `${currentRel}/${entry.name}` : entry.name;
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
@@ -3465,14 +5305,14 @@ async function readDraftFilesFromDir(dirPath) {
         continue;
       }
       if (!entry.isFile()) continue;
-      const content = await fs6.readFile(childAbs, "utf8");
+      const content = await fs8.readFile(childAbs, "utf8");
       if (childRel === "SKILL.md" || childRel === "AGENT.md") {
         manifestFound = true;
       }
       files.push({ path: childRel, content });
     }
   }
-  await walk(dirPath, "");
+  await walk(dirRoot, "");
   if (!manifestFound) {
     throw createServicemeError(
       "invalid_params",