@serviceme/devtools-cli 2.0.0 → 2.0.1

package/dist/bridgeServer.js

@@ -59,6 +59,8 @@ var BRIDGE_METHODS = [
   "copilotContent.convertToSymlink",
   "copilotContent.uninstall",
   "copilotContent.setEntryEnabled",
+  "copilotContent.detectUnmanaged",
+  "copilotContent.adoptUnmanaged",
   "copilotContent.listLinked",
   "copilotContent.draft.create",
   "copilotContent.draft.commit",
@@ -244,7 +246,7 @@ function normalizeServicemeError(error, fallbackCode = "internal_error") {
 }
 
 // src/version.ts
-var SERVICEME_CLI_VERSION = "2.0.0";
+var SERVICEME_CLI_VERSION = "2.0.1";
 
 // src/bridge/CopilotContentBridgeHandler.ts
 var fsp = __toESM(require("fs/promises"));
@@ -305,16 +307,12 @@ var CopilotContentBridgeHandler = class {
    * removed and never resurrected) while the manifest stays intact.
    */
   async makeReconciler(workspaceDir) {
-    const disabledStore = new import_devtools_core.DisabledContentStore();
-    const marks = await disabledStore.list();
-    const matches = (identity) => {
-      const segments = identity.split("::");
-      if (segments.length < 3) return false;
-      const [repoId, pluginId, kindName] = segments;
-      return marks.some(
-        (mark) => mark.scope === "workspace" && mark.workspaceDir === workspaceDir && mark.repoId === repoId && mark.name === pluginId && kindName === mark.kind
-      );
-    };
+    let marks = [];
+    try {
+      marks = await new import_devtools_core.DisabledContentStore().list();
+    } catch {
+    }
+    const matches = (0, import_devtools_core.buildDisabledIdentityMatcher)(workspaceDir, marks);
     return new import_devtools_core.WorkspaceCopilotContentReconciler({
       workspaceDir,
       ensureRepository: (manifest) => this.ensureRepositories(manifest),
@@ -483,7 +481,8 @@ var CopilotCustomizationsBridgeHandler = class {
         installations: snapshot.installations.map(toPublicInstallation),
         statesByArtifactId: toPublicStates(snapshot.statesByArtifactId),
         legacyCount: snapshot.legacyCount,
-        generatedAt: snapshot.generatedAt
+        generatedAt: snapshot.generatedAt,
+        ...snapshot.disabledArtifactIds ? { disabledArtifactIds: snapshot.disabledArtifactIds } : {}
       }),
       ...availablePackages ? { availablePackages } : {}
     };
@@ -607,13 +606,35 @@ function createAvailablePackagesEnumerator(store) {
       repositories: [],
       plugins: []
     };
-    const workspaceInstalled = new Set(
-      manifest.plugins.map(
-        (plugin) => `${(0, import_devtools_core2.getWorkspaceManifestPluginSourceId)(manifest, plugin)}::${plugin.id}`
-      )
+    const coversPackage = (pkg, selectedIds, selectedKinds) => pkg.artifacts.every(
+      (artifact) => selectedIds !== void 0 ? selectedIds.includes(artifact.id) : selectedKinds?.[artifact.kind] === true
+    );
+    const manifestSelections = new Map(
+      manifest.plugins.map((plugin) => [
+        `${(0, import_devtools_core2.getWorkspaceManifestPluginSourceId)(manifest, plugin)}::${plugin.id}`,
+        plugin
+      ])
     );
-    const personalInstalled = new Set(
-      (personalIntent?.installations ?? []).filter((installation) => installation.scope === "personal").map((installation) => installation.packageId)
+    const machineMarks = await new import_devtools_core2.DisabledContentStore().list().catch(() => []);
+    const disabledTargets = /* @__PURE__ */ new Map();
+    const addDisabledTarget = (packageKey, target) => {
+      const targets = disabledTargets.get(packageKey) ?? /* @__PURE__ */ new Set();
+      targets.add(target);
+      disabledTargets.set(packageKey, targets);
+    };
+    for (const plugin of manifest.plugins) {
+      const packageKey = `${(0, import_devtools_core2.getWorkspaceManifestPluginSourceId)(manifest, plugin)}::${plugin.id}`;
+      for (const target of plugin.disabledArtifacts ?? []) {
+        addDisabledTarget(packageKey, target);
+      }
+    }
+    for (const mark of machineMarks) {
+      if (mark.scope === "user" || mark.workspaceDir === params.workspaceDir) {
+        addDisabledTarget(`${mark.repoId}::*`, `${mark.kind}:${mark.name}`);
+      }
+    }
+    const personalSelections = new Map(
+      (personalIntent?.installations ?? []).filter((installation) => installation.scope === "personal").map((installation) => [installation.packageId, installation])
     );
     const registeredScopes = /* @__PURE__ */ new Map();
     for (const reg of registrations) {
@@ -623,7 +644,20 @@ function createAvailablePackagesEnumerator(store) {
       registeredScopes.set(packageId, scopes);
     }
     return catalogPackages.map((pkg) => {
-      const installed = registeredScopes.get(pkg.packageId) !== void 0 || workspaceInstalled.has(pkg.packageId) || personalInstalled.has(pkg.packageId);
+      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"] : []
@@ -804,7 +838,8 @@ async function createPackageInstallationService(store) {
         packages: snapshot.packages,
         installations: snapshot.installations,
         statesByArtifactId: snapshot.statesByArtifactId,
-        generatedAt: snapshot.generatedAt
+        generatedAt: snapshot.generatedAt,
+        ...snapshot.disabledArtifactIds ? { disabledArtifactIds: snapshot.disabledArtifactIds } : {}
       });
     },
     readWorkspaceInstallations: import_devtools_core2.readDeclaredWorkspaceInstallations
@@ -972,9 +1007,16 @@ async function createWorkspaceSnapshot(repoDisplayName, readers, workspaceDir) {
     })
   );
   const state = await readers.readWorkspaceState(workspaceDir);
+  let isDisabled = () => false;
+  try {
+    const marks = await new import_devtools_core2.DisabledContentStore().list();
+    isDisabled = (0, import_devtools_core2.buildDisabledIdentityMatcher)(workspaceDir, marks);
+  } catch {
+  }
   const packages = [];
   const installations = [];
   const statesByArtifactId = {};
+  const disabledArtifactIds = [];
   const resolvedPlugins = await Promise.all(
     manifest.plugins.map(async (plugin) => {
       const sourceId = (0, import_devtools_core2.getWorkspaceManifestPluginSourceId)(manifest, plugin);
@@ -1013,11 +1055,27 @@ async function createWorkspaceSnapshot(repoDisplayName, readers, workspaceDir) {
     });
     for (const entry of entries) {
       const previous = state.entries.find((candidate) => candidate.identity === entry.artifactId);
-      statesByArtifactId[entry.artifactId] = fallbackHealth ? { intent: "selected", health: fallbackHealth, gate: "ready" } : toArtifactState(entry, previous);
+      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, workspaceManifest: manifest };
+  return {
+    sources,
+    packages,
+    installations,
+    statesByArtifactId,
+    disabledArtifactIds,
+    workspaceManifest: manifest
+  };
 }
 async function createFullPersonalSnapshot(options, legacyLinks) {
   const capabilities = options.personal?.capabilities ?? await (0, import_devtools_core2.createDefaultCopilotHostCapabilities)();
@@ -1076,20 +1134,29 @@ async function createFullPersonalSnapshot(options, legacyLinks) {
 }
 function fallbackEntries(plugin, packageId) {
   const kinds = Object.keys(plugin.artifacts);
-  return kinds.filter((kind) => plugin.artifacts[kind] !== false).map((kind) => ({
-    identity: `${packageId}::${kind}:${plugin.id}`,
-    artifactId: `${packageId}::${kind}:${plugin.id}`,
-    packageId,
-    packageDisplayName: plugin.id,
-    repositoryId: packageId.split("::")[0] ?? packageId,
-    pluginId: plugin.id,
-    kind,
-    sourcePath: "",
-    sourceIsFile: false,
-    name: plugin.id,
-    digest: "",
-    requiresApproval: kind === "hook" || kind === "mcp"
-  }));
+  return kinds.filter((kind) => plugin.artifacts[kind] !== false).map((kind) => {
+    const repoId = packageId.split("::")[0] ?? packageId;
+    const identity = (0, import_devtools_core2.buildContentIdentity)({
+      repoId,
+      pluginId: plugin.id,
+      kind,
+      name: plugin.id
+    });
+    return {
+      identity,
+      artifactId: identity,
+      packageId,
+      packageDisplayName: plugin.id,
+      repositoryId: repoId,
+      pluginId: plugin.id,
+      kind,
+      sourcePath: "",
+      sourceIsFile: false,
+      name: plugin.id,
+      digest: "",
+      requiresApproval: kind === "hook" || kind === "mcp"
+    };
+  });
 }
 function toArtifactState(entry, previous) {
   if (!previous) {
@@ -1607,6 +1674,20 @@ var BridgeServer = class {
           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;

package/dist/cli.js

@@ -123,16 +123,12 @@ var init_CopilotContentBridgeHandler = __esm({
        * removed and never resurrected) while the manifest stays intact.
        */
       async makeReconciler(workspaceDir) {
-        const disabledStore = new import_devtools_core2.DisabledContentStore();
-        const marks = await disabledStore.list();
-        const matches = (identity) => {
-          const segments = identity.split("::");
-          if (segments.length < 3) return false;
-          const [repoId, pluginId, kindName] = segments;
-          return marks.some(
-            (mark) => mark.scope === "workspace" && mark.workspaceDir === workspaceDir && mark.repoId === repoId && mark.name === pluginId && kindName === mark.kind
-          );
-        };
+        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),
@@ -301,6 +297,8 @@ var BRIDGE_METHODS = [
   "copilotContent.convertToSymlink",
   "copilotContent.uninstall",
   "copilotContent.setEntryEnabled",
+  "copilotContent.detectUnmanaged",
+  "copilotContent.adoptUnmanaged",
   "copilotContent.listLinked",
   "copilotContent.draft.create",
   "copilotContent.draft.commit",
@@ -718,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,
@@ -1008,7 +1022,7 @@ var readline = __toESM(require("readline"));
 
 // src/version.ts
 var SERVICEME_CLI_NAME = "serviceme";
-var SERVICEME_CLI_VERSION = "2.0.0";
+var SERVICEME_CLI_VERSION = "2.0.1";
 
 // src/bridge/BridgeServer.ts
 init_CopilotContentBridgeHandler();
@@ -1069,7 +1083,8 @@ var CopilotCustomizationsBridgeHandler = class {
         installations: snapshot.installations.map(toPublicInstallation),
         statesByArtifactId: toPublicStates(snapshot.statesByArtifactId),
         legacyCount: snapshot.legacyCount,
-        generatedAt: snapshot.generatedAt
+        generatedAt: snapshot.generatedAt,
+        ...snapshot.disabledArtifactIds ? { disabledArtifactIds: snapshot.disabledArtifactIds } : {}
       }),
       ...availablePackages ? { availablePackages } : {}
     };
@@ -1193,13 +1208,35 @@ function createAvailablePackagesEnumerator(store) {
       repositories: [],
       plugins: []
     };
-    const workspaceInstalled = new Set(
-      manifest.plugins.map(
-        (plugin) => `${(0, import_devtools_core3.getWorkspaceManifestPluginSourceId)(manifest, plugin)}::${plugin.id}`
-      )
+    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 personalInstalled = new Set(
-      (personalIntent?.installations ?? []).filter((installation) => installation.scope === "personal").map((installation) => installation.packageId)
+    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) {
@@ -1209,7 +1246,20 @@ function createAvailablePackagesEnumerator(store) {
       registeredScopes.set(packageId, scopes);
     }
     return catalogPackages.map((pkg) => {
-      const installed = registeredScopes.get(pkg.packageId) !== void 0 || workspaceInstalled.has(pkg.packageId) || personalInstalled.has(pkg.packageId);
+      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"] : []
@@ -1390,7 +1440,8 @@ async function createPackageInstallationService(store) {
         packages: snapshot.packages,
         installations: snapshot.installations,
         statesByArtifactId: snapshot.statesByArtifactId,
-        generatedAt: snapshot.generatedAt
+        generatedAt: snapshot.generatedAt,
+        ...snapshot.disabledArtifactIds ? { disabledArtifactIds: snapshot.disabledArtifactIds } : {}
       });
     },
     readWorkspaceInstallations: import_devtools_core3.readDeclaredWorkspaceInstallations
@@ -1558,9 +1609,16 @@ async function createWorkspaceSnapshot(repoDisplayName, readers, workspaceDir) {
     })
   );
   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);
@@ -1599,11 +1657,27 @@ async function createWorkspaceSnapshot(repoDisplayName, readers, workspaceDir) {
     });
     for (const entry of entries) {
       const previous = state.entries.find((candidate) => candidate.identity === entry.artifactId);
-      statesByArtifactId[entry.artifactId] = fallbackHealth ? { intent: "selected", health: fallbackHealth, gate: "ready" } : toArtifactState(entry, previous);
+      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, workspaceManifest: manifest };
+  return {
+    sources,
+    packages,
+    installations,
+    statesByArtifactId,
+    disabledArtifactIds,
+    workspaceManifest: manifest
+  };
 }
 async function createFullPersonalSnapshot(options, legacyLinks) {
   const capabilities = options.personal?.capabilities ?? await (0, import_devtools_core3.createDefaultCopilotHostCapabilities)();
@@ -1662,20 +1736,29 @@ async function createFullPersonalSnapshot(options, legacyLinks) {
 }
 function fallbackEntries(plugin, packageId) {
   const kinds = Object.keys(plugin.artifacts);
-  return kinds.filter((kind) => plugin.artifacts[kind] !== false).map((kind) => ({
-    identity: `${packageId}::${kind}:${plugin.id}`,
-    artifactId: `${packageId}::${kind}:${plugin.id}`,
-    packageId,
-    packageDisplayName: plugin.id,
-    repositoryId: packageId.split("::")[0] ?? packageId,
-    pluginId: plugin.id,
-    kind,
-    sourcePath: "",
-    sourceIsFile: false,
-    name: plugin.id,
-    digest: "",
-    requiresApproval: kind === "hook" || kind === "mcp"
-  }));
+  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) {
@@ -2049,12 +2132,12 @@ var BridgeServer = class {
       input: process.stdin,
       crlfDelay: Number.POSITIVE_INFINITY
     });
-    await new Promise((resolve4) => {
+    await new Promise((resolve9) => {
       reader.on("line", (line) => {
         void this.handleLine(line);
       });
       reader.on("close", () => {
-        resolve4();
+        resolve9();
       });
     });
   }
@@ -2193,6 +2276,20 @@ var BridgeServer = class {
           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;
@@ -2603,9 +2700,22 @@ var SkillRepoBridgeHandler = class {
       marks = await new import_devtools_core6.DisabledContentStore().list();
     } catch {
     }
-    const isDisabled = (entry) => marks.some(
-      (mark) => mark.repoId === entry.repoId && mark.name === entry.name && mark.kind === entry.kind && (mark.scope === "user" || params.workspaceDir !== void 0 && mark.workspaceDir === params.workspaceDir)
-    );
+    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((entry) => ({
         ...toBridgeEntry(entry),
@@ -2647,10 +2757,22 @@ var SkillRepoBridgeHandler = class {
   async install(params) {
     const kind = params.kind ?? "skill";
     const source = await this.resolveEntrySource(params.repoId, params.name, kind);
-    if ((params.scope ?? "workspace") === "workspace") {
-      return this.installThroughDeclaration(params, kind, source);
-    }
-    return this.installUserScope(params, kind, source);
+    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
@@ -2672,15 +2794,31 @@ var SkillRepoBridgeHandler = class {
         `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: params.name,
+      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,
+        repositoryId: params.repoId,
+        pluginId: params.name,
+        kind
+      });
+    }
     const restored = await this.reconcileInstalledContent(params.workspaceDir);
     const linkBasename = source.sourceIsFile ? path5.basename(source.sourcePath) : params.name;
-    const expectedIdentity = `${params.repoId}::${params.name}::${kind}:${stripAgentSuffix(linkBasename)}`;
+    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(
@@ -2784,12 +2922,26 @@ var SkillRepoBridgeHandler = class {
   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: params.name,
+        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 {
@@ -2809,14 +2961,22 @@ 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 a machine-local mark and removes the
-   * materialized link (the workspace manifest declaration stays); the
-   * reconciler treats marked identities as undeclared, so a restore
-   * never resurrects them. Enable clears the mark and re-links.
+   * 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";
@@ -2833,8 +2993,10 @@ var SkillRepoBridgeHandler = class {
       ...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);
@@ -2846,21 +3008,9 @@ var SkillRepoBridgeHandler = class {
       }
       return { enabled: true };
     }
-    await store.add(mark);
     if (scope === "workspace") {
-      const stateStore = new import_devtools_core6.WorkspaceContentStateStore({
-        workspaceDir: params.workspaceDir
-      });
-      const state = await stateStore.read();
-      for (const previous of state.entries) {
-        if (previous.repositoryId !== params.repoId || previous.pluginId !== params.name || previous.kind !== kind || !previous.linkPath.replace(/\\/g, "/").includes(".github")) {
-          continue;
-        }
-        await fs3.rm(path5.resolve(params.workspaceDir, previous.linkPath), {
-          force: true,
-          recursive: true
-        });
-      }
+      await store.add(mark);
+      await this.setDeclaredArtifactDisabled(params, kind, true);
       await this.reconcileInstalledContent(params.workspaceDir);
     } else {
       let base = params.name;
@@ -2869,8 +3019,18 @@ var SkillRepoBridgeHandler = class {
         base = source.sourceIsFile ? path5.basename(source.sourcePath) : params.name;
       } catch {
       }
-      const userRoot = path5.join((0, import_devtools_core6.getHomeDir)(), ".copilot", kind === "agent" ? "agents" : "skills");
-      await fs3.rm(path5.join(userRoot, base), { force: true, recursive: true });
+      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 };
   }
@@ -2896,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.*
   // ─────────────────────────────────────────────────────────────────
@@ -3150,6 +3440,29 @@ var SkillRepoBridgeHandler = class {
   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
    * `install`/`convertToSymlink`. Repos vary wildly in layout — flat
@@ -3189,6 +3502,9 @@ var SkillRepoBridgeHandler = class {
 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,
@@ -3421,9 +3737,20 @@ var import_devtools_core11 = require("@serviceme/devtools-core");
 
 // src/input.ts
 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 fs4.readFile(options.filePath, "utf8");
+    return fs4.readFile(sanitizeCliFilePath(options.filePath), "utf8");
   }
   if (options.stdin) {
     return readStdin();
@@ -3701,7 +4028,7 @@ async function runReposCommand(parsed) {
 
 // src/commands/schedule.ts
 var fs5 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
 var import_devtools_core14 = require("@serviceme/devtools-core");
 async function runScheduleCommand(parsed) {
   const action = parsed.positionals[1];
@@ -3756,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) {
@@ -3786,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"),
@@ -3902,7 +4242,7 @@ async function handleCreate(parsed) {
     payload,
     workspace: {
       path: wp,
-      name: path6.basename(wp) || wp
+      name: path7.basename(wp) || wp
     },
     enabled
   };
@@ -4237,7 +4577,7 @@ function writeDescribe(action) {
 // src/commands/scheduler.ts
 var import_node_child_process = require("child_process");
 var fs6 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+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) {
@@ -4325,12 +4665,16 @@ function handleStart(_parsed) {
     throw createServicemeError("internal_error", "Cannot determine CLI path for daemon spawn");
   }
   const logPath = (0, import_devtools_core15.getSchedulerLogPath)();
-  const logDir = path7.dirname(logPath);
+  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") {
     fs6.appendFileSync(
       logPath,
@@ -4463,6 +4807,10 @@ 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_core15.PidManager("", { pidPath: (0, import_devtools_core15.getSchedulerPidPath)() });
@@ -4566,7 +4914,7 @@ function writeDescribe2(action) {
 // src/commands/skill.ts
 var fs7 = __toESM(require("fs/promises"));
 var os2 = __toESM(require("os"));
-var path8 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 var import_devtools_core16 = require("@serviceme/devtools-core");
 function normalizeSkillIdOrThrow(store, remoteId) {
   try {
@@ -4583,7 +4931,7 @@ async function runSkillCommand(parsed) {
   }
   const store = new import_devtools_core16.SkillStore({
     workspacePath,
-    userSkillsRoot: path8.join(os2.homedir(), ".copilot", "skills")
+    userSkillsRoot: path9.join(os2.homedir(), ".copilot", "skills")
   });
   const catalogClient = new import_devtools_core16.SkillCatalogClient({
     baseUrl: getStringFlag(parsed, "baseUrl")
@@ -4697,11 +5045,24 @@ async function handleUninstall2(store, workspacePath, parsed) {
     throw createServicemeError("invalid_params", "Expected --id <remoteSkillId>.");
   }
   const skillId = normalizeSkillIdOrThrow(store, remoteId);
-  await fs7.rm(path8.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 fs7.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
   });
@@ -4723,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 = path8.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);
@@ -4744,7 +5105,7 @@ async function handleMove2(store, workspacePath, parsed) {
   };
 }
 async function moveDirectory(fromPath, toPath) {
-  await fs7.mkdir(path8.dirname(toPath), { recursive: true });
+  await fs7.mkdir(path9.dirname(toPath), { recursive: true });
   try {
     await fs7.rename(fromPath, toPath);
   } catch {
@@ -4850,14 +5211,14 @@ async function handlePublishable(store, workspacePath) {
     skills: workspaceSkillIds.map((skillId) => ({
       id: skillId,
       displayName: skillId,
-      path: path8.join(workspacePath, store.getWorkspaceSkillPath(skillId))
+      path: path9.join(workspacePath, store.getWorkspaceSkillPath(skillId))
     }))
   };
 }
 
 // src/commands/skills.ts
 var fs8 = __toESM(require("fs/promises"));
-var path9 = __toESM(require("path"));
+var path10 = __toESM(require("path"));
 var import_devtools_core17 = require("@serviceme/devtools-core");
 function requireFlag(parsed, name) {
   const value = getStringFlag(parsed, name);
@@ -4929,12 +5290,14 @@ async function readDraftFilesFromDir(dirPath) {
   }
   const files = [];
   let manifestFound = false;
+  const dirRoot = path10.resolve(dirPath);
   async function walk(currentAbs, currentRel) {
     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 = path9.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()) {
@@ -4949,7 +5312,7 @@ async function readDraftFilesFromDir(dirPath) {
       files.push({ path: childRel, content });
     }
   }
-  await walk(dirPath, "");
+  await walk(dirRoot, "");
   if (!manifestFound) {
     throw createServicemeError(
       "invalid_params",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serviceme/devtools-cli",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Unified SERVICEME CLI for automation, project scaffolding, and bridge-based tooling.",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {
@@ -39,9 +39,9 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@serviceme/devtools-core": "2.0.0",
-    "@serviceme/devtools-protocol": "2.0.0",
-    "@serviceme/devtools-shared": "2.0.0"
+    "@serviceme/devtools-core": "2.0.1",
+    "@serviceme/devtools-protocol": "2.0.1",
+    "@serviceme/devtools-shared": "2.0.1"
   },
   "devDependencies": {
     "@types/node": "^24",