@serviceme/devtools-core 2.0.0 → 2.0.1

package/dist/index.mjs

@@ -1311,7 +1311,7 @@ var GitHubAuthProvider = class {
   }
 };
 function sleep(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 
 // src/auth/providers/MicrosoftAuthProvider.ts
@@ -1393,7 +1393,7 @@ function scheduleForceKill(child) {
   return timer;
 }
 async function runCommand(command, options = {}) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     const child = spawn(command, options.args ?? [], {
       cwd: options.cwd,
       env: options.env,
@@ -1440,7 +1440,7 @@ async function runCommand(command, options = {}) {
       }
       finish(() => {
         if (code === 0) {
-          resolve11({
+          resolve13({
             stdout,
             stderr,
             code: 0
@@ -1772,8 +1772,8 @@ async function createDefaultCopilotHostCapabilities(options) {
   for (const kind of allPersonalLinkKinds) {
     if (kind !== "agent" && kind !== "skill") continue;
     const target = path3.join(home, ".copilot", kind === "agent" ? "agents" : "skills");
-    const stat15 = await fsp.stat(target).catch(() => null);
-    if (stat15?.isDirectory() === true) {
+    const stat16 = await fsp.stat(target).catch(() => null);
+    if (stat16?.isDirectory() === true) {
       personalTargets[kind] = target;
     }
   }
@@ -1826,8 +1826,8 @@ var CopilotLinkMaterializer = class {
       const previous = input.previousState.entries.find(
         (state) => state.identity === entry.identity
       );
-      const stat15 = await fsp2.lstat(linkPath).catch(() => null);
-      if (stat15 && !stat15.isSymbolicLink()) {
+      const stat16 = await fsp2.lstat(linkPath).catch(() => null);
+      if (stat16 && !stat16.isSymbolicLink()) {
         results.push({
           identity: entry.identity,
           status: previous ? "drifted" : "conflict",
@@ -1835,7 +1835,7 @@ var CopilotLinkMaterializer = class {
         });
         continue;
       }
-      if (stat15?.isSymbolicLink()) {
+      if (stat16?.isSymbolicLink()) {
         const currentTarget = await fsp2.readlink(linkPath);
         if (currentTarget !== entry.sourcePath) {
           if (previous?.linkPath === this.toStateLinkPath(linkPath) && previous.sourcePath === entry.sourcePath) {
@@ -1874,8 +1874,8 @@ var CopilotLinkMaterializer = class {
   /** Adopt a matching legacy link without recreating it. */
   async adoptLegacyLink(input) {
     const linkPath = this.resolveLinkPath(input.workspaceDir, input.entry);
-    const stat15 = await fsp2.lstat(linkPath).catch(() => null);
-    if (stat15?.isSymbolicLink() && await fsp2.readlink(linkPath) === input.entry.sourcePath) {
+    const stat16 = await fsp2.lstat(linkPath).catch(() => null);
+    if (stat16?.isSymbolicLink() && await fsp2.readlink(linkPath) === input.entry.sourcePath) {
       return { identity: input.entry.identity, status: "adopted" };
     }
     return {
@@ -1893,8 +1893,8 @@ var CopilotLinkMaterializer = class {
       kindDir,
       input.entry.sourceIsFile ? path4.basename(input.entry.sourcePath) : input.entry.name
     );
-    const stat15 = await fsp2.lstat(legacyPath).catch(() => null);
-    if (stat15?.isSymbolicLink() && await fsp2.readlink(legacyPath) === input.entry.sourcePath) {
+    const stat16 = await fsp2.lstat(legacyPath).catch(() => null);
+    if (stat16?.isSymbolicLink() && await fsp2.readlink(legacyPath) === input.entry.sourcePath) {
       return {
         identity: input.entry.identity,
         status: "adopted",
@@ -1946,8 +1946,8 @@ var CopilotLinkMaterializer = class {
       return toPosix(linkPath);
     }
     const workspaceRoot = path4.dirname(cursor);
-    const relative4 = toPosix(path4.relative(workspaceRoot, linkPath));
-    return relative4 === "" ? toPosix(linkPath) : relative4;
+    const relative5 = toPosix(path4.relative(workspaceRoot, linkPath));
+    return relative5 === "" ? toPosix(linkPath) : relative5;
   }
 };
 function toPosix(value) {
@@ -1993,8 +1993,8 @@ async function resolveSource(entry, pluginDir, repoRoot) {
     candidates.push(path5.join(repoRoot, "agents", `${base}.agent.md`));
   }
   for (const candidate of candidates) {
-    const stat15 = await fs2.stat(candidate).catch(() => void 0);
-    if (stat15) return candidate;
+    const stat16 = await fs2.stat(candidate).catch(() => void 0);
+    if (stat16) return candidate;
   }
   return null;
 }
@@ -2007,8 +2007,8 @@ function normalizeRefPath(entry) {
 async function copyProjectionEntry(source, dest) {
   await fs2.mkdir(path5.dirname(dest), { recursive: true });
   await fs2.rm(dest, { force: true, recursive: true });
-  const stat15 = await fs2.stat(source);
-  if (stat15.isDirectory()) {
+  const stat16 = await fs2.stat(source);
+  if (stat16.isDirectory()) {
     await fs2.cp(source, dest, { recursive: true, dereference: true });
   } else {
     await fs2.copyFile(source, dest);
@@ -2065,13 +2065,15 @@ async function materializePluginProjection(input) {
   };
   await fs2.writeFile(
     inside("plugin.json"),
-    JSON.stringify(servedPluginManifest(raw), null, 2) + "\n"
+    `${JSON.stringify(servedPluginManifest(raw), null, 2)}
+`
   );
   const pluginMarkerDir = inside(PLUGIN_MARKER_DIR);
   await fs2.mkdir(pluginMarkerDir, { recursive: true });
   await fs2.writeFile(
     path5.join(pluginMarkerDir, "plugin.json"),
-    JSON.stringify(servedPluginManifest(raw), null, 2) + "\n"
+    `${JSON.stringify(servedPluginManifest(raw), null, 2)}
+`
   );
   const mcpJson = await fs2.stat(path5.join(pluginDir, "mcp.json")).catch(() => void 0);
   if (mcpJson?.isFile()) {
@@ -2083,8 +2085,8 @@ async function materializePluginProjection(input) {
   return result;
 }
 async function isMaterializedProjection(dir) {
-  const stat15 = await fs2.lstat(dir).catch(() => void 0);
-  if (!stat15?.isDirectory() || stat15.isSymbolicLink()) return false;
+  const stat16 = await fs2.lstat(dir).catch(() => void 0);
+  if (!stat16?.isDirectory() || stat16.isSymbolicLink()) return false;
   const root = path5.resolve(dir);
   const markerPath = path5.resolve(root, PLUGIN_MARKER_DIR, MARKER_FILE);
   if (!markerPath.startsWith(root + path5.sep)) return false;
@@ -2194,8 +2196,8 @@ var CopilotPluginRegistrar = class {
         merged.set(id, reg);
       }
       const legacyLink = path6.join(legacyDir, id);
-      const stat15 = await fs3.lstat(legacyLink).catch(() => void 0);
-      if (stat15?.isSymbolicLink()) {
+      const stat16 = await fs3.lstat(legacyLink).catch(() => void 0);
+      if (stat16?.isSymbolicLink()) {
         await this.writeRegistry(merged);
         await fs3.mkdir(dest, { recursive: true });
         await fs3.rm(this.linkPath(id), { force: true, recursive: true });
@@ -2345,6 +2347,7 @@ function buildCopilotCustomizationView(input) {
       throw new Error(`Unknown Copilot source ${definition.sourceId} for package ${definition.id}`);
     }
   }
+  const disabledArtifactIds = new Set(input.disabledArtifactIds ?? []);
   const packages = input.installations.filter((installation) => installation.scope === input.scope).map((installation) => {
     const definition = requirePackage(input.packages, installation.packageId);
     const artifacts = installation.selectedArtifactIds.map((artifactId) => {
@@ -2368,6 +2371,11 @@ function buildCopilotCustomizationView(input) {
       return status === "action-required" || status === "blocked";
     })
   );
+  const packageCount = packages.filter((pkg) => pkg.definition.wholePackage === true).length;
+  const enabledArtifactCount = packages.reduce(
+    (count, pkg) => count + pkg.artifacts.filter(({ artifact }) => !disabledArtifactIds.has(artifact.id)).length,
+    0
+  );
   const sources = input.sources.map((source) => ({
     ...source,
     packages: packages.filter((pkg) => pkg.definition.sourceId === source.id)
@@ -2379,11 +2387,16 @@ function buildCopilotCustomizationView(input) {
     packages,
     attention,
     summary: {
-      packageCount: packages.length,
-      enabledArtifactCount: packages.reduce((count, pkg) => count + pkg.selectedArtifactCount, 0),
+      packageCount,
+      enabledArtifactCount,
       attentionCount: attention.length
     },
-    ...input.legacyCount ? { legacyMigration: { count: input.legacyCount, sourceLabel: "~/.agents" } } : {}
+    ...input.legacyCount ? {
+      legacyMigration: {
+        count: input.legacyCount,
+        sourceLabel: "~/.agents"
+      }
+    } : {}
   };
 }
 function requirePackage(packages, packageId) {
@@ -2407,6 +2420,33 @@ function requireState(statesByArtifactId, artifactId) {
 // src/copilot-content/disabled-content-store.ts
 import * as fsp3 from "fs/promises";
 import * as path7 from "path";
+
+// src/copilot-content/types.ts
+function buildContentIdentity(identity) {
+  return `${identity.repoId}::${identity.pluginId}::${identity.kind}:${identity.name}`;
+}
+function parseContentIdentity(value) {
+  const segments = value.split("::");
+  if (segments.length !== 3) return null;
+  const repoId = segments[0] ?? "";
+  const pluginId = segments[1] ?? "";
+  const tail = (segments[2] ?? "").split(":");
+  const kind = tail[0] ?? "";
+  const name = tail.slice(1).join(":");
+  if (!repoId || !pluginId || !kind || !name) return null;
+  return { repoId, pluginId, kind, name };
+}
+function getWorkspaceManifestSources(manifest) {
+  return manifest.version === 1 ? manifest.repositories.map((repository) => ({
+    ...repository,
+    type: "git"
+  })) : manifest.sources;
+}
+function getWorkspaceManifestPluginSourceId(manifest, plugin) {
+  return manifest.version === 1 ? plugin.repository : plugin.source;
+}
+
+// src/copilot-content/disabled-content-store.ts
 function sameEntry(a, b) {
   if (a.scope !== b.scope || a.repoId !== b.repoId || a.name !== b.name || a.kind !== b.kind) {
     return false;
@@ -2416,6 +2456,15 @@ function sameEntry(a, b) {
   }
   return true;
 }
+function buildDisabledIdentityMatcher(workspaceDir, marks) {
+  return (identity) => {
+    const parsed = parseContentIdentity(identity);
+    if (parsed === null) return false;
+    return marks.some(
+      (mark) => mark.repoId === parsed.repoId && mark.kind === parsed.kind && mark.name === parsed.name && (mark.scope === "user" || mark.workspaceDir === workspaceDir)
+    );
+  };
+}
 var DisabledContentStore = class {
   constructor(options = {}) {
     this.homeDir = options.homeDir ?? getServicemeHome();
@@ -2436,9 +2485,6 @@ var DisabledContentStore = class {
       throw error;
     }
   }
-  async has(matcher) {
-    return this.list().then((entries) => entries.some(matcher));
-  }
   async add(entry) {
     const entries = await this.list();
     if (entries.some((candidate) => sameEntry(candidate, entry))) {
@@ -2454,6 +2500,30 @@ var DisabledContentStore = class {
     }
     await this.write(next);
   }
+  /**
+   * Lifecycle cleanup: installing or uninstalling an artifact clears
+   * its disable marks for that scope — a mark without its artifact is
+   * stale garbage that keeps the home page showing a disabled row for
+   * content the catalog already reports as gone. User scope matches
+   * any workspace; workspace scope matches the exact workspace.
+   */
+  async removeForArtifact(input) {
+    const entries = await this.list();
+    const next = entries.filter((candidate) => {
+      const sameArtifact = candidate.repoId === input.repoId && candidate.name === input.name && candidate.kind === input.kind;
+      if (!sameArtifact || candidate.scope !== input.scope) {
+        return true;
+      }
+      if (input.scope === "user") {
+        return false;
+      }
+      return candidate.workspaceDir !== input.workspaceDir;
+    });
+    if (next.length === entries.length) {
+      return;
+    }
+    await this.write(next);
+  }
   async write(entries) {
     const statePath = await this.path();
     await fsp3.mkdir(path7.dirname(statePath), { recursive: true });
@@ -2638,9 +2708,9 @@ async function copyDirPreservingMode(sourceDir, targetDir) {
       continue;
     }
     if (!dirent.isFile()) continue;
-    const stat15 = await fsp4.stat(sourceChild);
+    const stat16 = await fsp4.stat(sourceChild);
     await fsp4.copyFile(sourceChild, targetChild);
-    await fsp4.chmod(targetChild, stat15.mode & 511);
+    await fsp4.chmod(targetChild, stat16.mode & 511);
   }
 }
 
@@ -2755,7 +2825,7 @@ async function defaultResolveGitExcludePath(workspaceDir) {
   );
 }
 async function resolveGitExcludeViaRevParse(workspaceDir) {
-  const result = await new Promise((resolve11, reject) => {
+  const result = await new Promise((resolve13, reject) => {
     const child = spawn2("git", ["rev-parse", "--git-path", "info/exclude"], {
       cwd: workspaceDir
     });
@@ -2764,7 +2834,7 @@ async function resolveGitExcludeViaRevParse(workspaceDir) {
       stdout += chunk;
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve11({ code: code ?? -1, stdout }));
+    child.on("close", (code) => resolve13({ code: code ?? -1, stdout }));
   });
   if (result.code !== 0) {
     throw new Error(`git rev-parse --git-path failed with exit code ${result.code}`);
@@ -2851,17 +2921,26 @@ var catalogSourceSchema = z.object({
   revision: z.string().regex(CATALOG_REVISION_PATTERN, "invalid catalog revision"),
   digest: z.string().regex(SHA256_DIGEST_PATTERN, "invalid catalog digest")
 });
+var artifactTargetSchema = z.string().refine((value) => {
+  const separator = value.indexOf(":");
+  if (separator <= 0 || separator === value.length - 1) return false;
+  const kind = value.slice(0, separator);
+  const name = value.slice(separator + 1);
+  return artifactKindSchema.safeParse(kind).success && !/[\\/\0]/.test(name) && name !== "." && name !== "..";
+}, "unsafe artifact target");
 var pluginSchema = z.object({
   repository: z.string().min(1),
   id: z.string().regex(PLUGIN_ID_PATTERN, "unsafe plugin id"),
   artifacts: z.record(z.string(), z.boolean()),
-  artifactIds: z.array(artifactIdSchema).optional()
+  artifactIds: z.array(artifactIdSchema).optional(),
+  disabledArtifacts: z.array(artifactTargetSchema).optional()
 });
 var pluginV2Schema = z.object({
   source: z.string().min(1),
   id: z.string().regex(PLUGIN_ID_PATTERN, "unsafe plugin id"),
   artifacts: z.record(z.string(), z.boolean()),
-  artifactIds: z.array(artifactIdSchema).optional()
+  artifactIds: z.array(artifactIdSchema).optional(),
+  disabledArtifacts: z.array(artifactTargetSchema).optional()
 });
 function validatePluginArtifacts(plugins, ctx) {
   for (const plugin of plugins) {
@@ -3072,6 +3151,34 @@ async function removeWorkspaceContentSelection(input) {
   await writeWorkspaceCopilotManifest(input.workspaceDir, next);
   return next;
 }
+async function setWorkspacePluginArtifactsDisabled(input) {
+  const manifest = await loadWorkspaceCopilotManifest(input.workspaceDir).catch(() => void 0);
+  if (!manifest) return void 0;
+  const withDisabledTarget = (plugin) => {
+    const current = new Set(plugin.disabledArtifacts ?? []);
+    if (input.disabled) {
+      current.add(input.target);
+    } else {
+      current.delete(input.target);
+    }
+    const { disabledArtifacts: _dropped, ...rest } = plugin;
+    return current.size > 0 ? { ...rest, disabledArtifacts: [...current].sort() } : rest;
+  };
+  if (manifest.version === 2) {
+    const plugins2 = manifest.plugins.map(
+      (plugin) => plugin.source === input.repositoryId && plugin.id === input.pluginId ? withDisabledTarget({ ...plugin, repository: plugin.source }) : plugin
+    );
+    const next2 = { ...manifest, plugins: plugins2 };
+    await writeWorkspaceCopilotManifest(input.workspaceDir, next2);
+    return next2;
+  }
+  const plugins = manifest.plugins.map(
+    (plugin) => plugin.repository === input.repositoryId && plugin.id === input.pluginId ? withDisabledTarget(plugin) : plugin
+  );
+  const next = { ...manifest, plugins };
+  await writeWorkspaceCopilotManifest(input.workspaceDir, next);
+  return next;
+}
 
 // src/copilot-content/workspace-state-store.ts
 import { createHash } from "crypto";
@@ -3287,8 +3394,8 @@ var PackageInstallationService = class {
       const dirents = await fsp9.readdir(kindDir, { withFileTypes: true }).catch(() => []);
       for (const dirent of dirents) {
         const legacyPath = path13.join(kindDir, dirent.name);
-        const stat15 = await fsp9.lstat(legacyPath).catch(() => null);
-        const isLink = stat15?.isSymbolicLink() === true;
+        const stat16 = await fsp9.lstat(legacyPath).catch(() => null);
+        const isLink = stat16?.isSymbolicLink() === true;
         const targetPath = isLink ? await fsp9.readlink(legacyPath).catch(() => "") : "";
         const resolved = isLink ? this.resolveLegacyTarget(legacyPath, targetPath) : "";
         const targetStat = resolved !== "" ? await fsp9.stat(resolved).catch(() => null) : null;
@@ -3314,8 +3421,8 @@ var PackageInstallationService = class {
       if (!entry?.eligible) {
         throw new Error(`Legacy entry ${artifactId} is not eligible for migration`);
       }
-      const stat15 = await fsp9.lstat(entry.sourcePath).catch(() => null);
-      if (!stat15?.isSymbolicLink()) {
+      const stat16 = await fsp9.lstat(entry.sourcePath).catch(() => null);
+      if (!stat16?.isSymbolicLink()) {
         throw new Error(`Legacy entry ${entry.name} is no longer a link`);
       }
       const currentTarget = this.resolveLegacyTarget(
@@ -3843,8 +3950,8 @@ var PersonalCopilotContentReconciler = class {
     const target = this.capabilities.personalTargets[previous.kind];
     if (target === void 0) return;
     const linkPath = path15.join(target, path15.basename(previous.linkPath));
-    const stat15 = await fsp11.lstat(linkPath).catch(() => null);
-    if (!stat15?.isSymbolicLink()) return;
+    const stat16 = await fsp11.lstat(linkPath).catch(() => null);
+    if (!stat16?.isSymbolicLink()) return;
     const currentTarget = await fsp11.readlink(linkPath).catch(() => null);
     if (currentTarget !== previous.sourcePath) return;
     await fsp11.rm(linkPath, { force: true });
@@ -3923,16 +4030,6 @@ import * as path17 from "path";
 import { createHash as createHash2 } from "crypto";
 import * as fsp12 from "fs/promises";
 import * as path16 from "path";
-
-// src/copilot-content/types.ts
-function getWorkspaceManifestSources(manifest) {
-  return manifest.version === 1 ? manifest.repositories.map((repository) => ({ ...repository, type: "git" })) : manifest.sources;
-}
-function getWorkspaceManifestPluginSourceId(manifest, plugin) {
-  return manifest.version === 1 ? plugin.repository : plugin.source;
-}
-
-// src/copilot-content/plugin-resolver.ts
 var AWESOME_COPILOT_NAMESPACE = "com.github.awesome-copilot";
 var PATH_KINDS = {
   agent: "agents",
@@ -3946,6 +4043,7 @@ var EXECUTABLE_SUFFIXES = /* @__PURE__ */ new Set([".py", ".rb"]);
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".vscode", "dist", "build", "out", "plugins"]);
 async function resolveWorkspaceContentPlan(input) {
   const entries = [];
+  const conflicts = [];
   const seenTargets = /* @__PURE__ */ new Map();
   const sources = getWorkspaceManifestSources(input.manifest);
   for (const plugin of input.manifest.plugins) {
@@ -3995,15 +4093,17 @@ async function resolveWorkspaceContentPlan(input) {
       const targetKey = entry.kind === "mcp" || entry.kind === "hook" ? `${entry.kind}:${plugin.id}:${entry.name}` : `${entry.kind}:${entry.name}`;
       const owner = seenTargets.get(targetKey);
       if (owner !== void 0) {
-        throw new Error(
-          `Duplicate ${entry.kind} target ${entry.name} from plugins ${owner} and ${plugin.id}`
-        );
+        conflicts.push({
+          identity: entry.identity,
+          message: `Duplicate ${entry.kind} target ${entry.name} from plugins ${owner} and ${plugin.id}`
+        });
+        continue;
       }
       seenTargets.set(targetKey, plugin.id);
       entries.push(entry);
     }
   }
-  return { entries };
+  return { entries, conflicts };
 }
 async function resolvePluginEntriesLenient(input) {
   const namespace = input.manifest.extensions[AWESOME_COPILOT_NAMESPACE];
@@ -4013,6 +4113,7 @@ async function resolvePluginEntriesLenient(input) {
       path16.join(input.repoRoot, "plugins", input.pluginId),
       input.repositoryId,
       input.pluginId,
+      void 0,
       input.manifest
     );
   }
@@ -4021,9 +4122,9 @@ async function resolvePluginEntriesLenient(input) {
     if (kind === "mcp" || kind === "hook") continue;
     const declared = namespace[manifestKey];
     if (!Array.isArray(declared)) continue;
-    for (const relative4 of declared) {
-      if (typeof relative4 !== "string") continue;
-      const effective = await resolveDeclaredRelative(input.repoRoot, relative4);
+    for (const relative5 of declared) {
+      if (typeof relative5 !== "string") continue;
+      const effective = await resolveDeclaredRelative(input.repoRoot, relative5);
       const sourcePath = path16.resolve(input.repoRoot, effective);
       if (!sourcePath.startsWith(`${input.repoRoot}${path16.sep}`)) continue;
       try {
@@ -4063,10 +4164,12 @@ async function tryReadPluginManifest(repoRoot, pluginId) {
 function selectedKind(artifacts, kind) {
   return artifacts?.[kind] !== false;
 }
-async function resolveConventionEntries(repoRoot, pluginDir, repositoryId, pluginId, manifest) {
+async function resolveConventionEntries(repoRoot, pluginDir, repositoryId, pluginId, artifacts, manifest) {
   const entries = [];
   const seen = /* @__PURE__ */ new Set();
+  const wants = artifacts === void 0 || Object.keys(artifacts).length === 0 ? () => true : (kind) => artifacts[kind] === true;
   const push = async (kind, base, subdir, options = {}) => {
+    if (!wants(kind)) return;
     const dir = path16.join(base, subdir);
     const dirents = await fsp12.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const dirent of dirents) {
@@ -4093,11 +4196,18 @@ async function resolveConventionEntries(repoRoot, pluginDir, repositoryId, plugi
     await push("prompt", base, "commands");
     await push("hook", base, "hooks");
   }
-  return entries;
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = `${entry.kind}:${entry.name}`;
+    if (!byTarget.has(key)) {
+      byTarget.set(key, entry);
+    }
+  }
+  return [...byTarget.values()];
 }
-async function resolveDeclaredRelative(repoRoot, relative4) {
-  if (await pathExists2(path16.resolve(repoRoot, relative4))) return relative4;
-  const normalized = relative4.replace(/^\.\//, "");
+async function resolveDeclaredRelative(repoRoot, relative5) {
+  if (await pathExists2(path16.resolve(repoRoot, relative5))) return relative5;
+  const normalized = relative5.replace(/^\.\//, "");
   if (normalized.startsWith("agents/") && normalized.endsWith(".md")) {
     const base = path16.basename(normalized, ".md");
     const candidate = path16.join(path16.dirname(normalized), `${base}.agent.md`);
@@ -4105,7 +4215,7 @@ async function resolveDeclaredRelative(repoRoot, relative4) {
       return `./${candidate}`;
     }
   }
-  return relative4;
+  return relative5;
 }
 async function resolvePluginManifestEntries(repoRoot, repositoryId, pluginId, artifacts, pluginManifest) {
   const namespace = pluginManifest.extensions[AWESOME_COPILOT_NAMESPACE];
@@ -4115,6 +4225,7 @@ async function resolvePluginManifestEntries(repoRoot, repositoryId, pluginId, ar
       path16.join(repoRoot, "plugins", pluginId),
       repositoryId,
       pluginId,
+      artifacts,
       pluginManifest
     );
   }
@@ -4123,8 +4234,8 @@ async function resolvePluginManifestEntries(repoRoot, repositoryId, pluginId, ar
     if (!selectedKind(artifacts, kind)) continue;
     const declared = namespace[manifestKey];
     if (!Array.isArray(declared)) continue;
-    for (const relative4 of declared) {
-      if (typeof relative4 !== "string") {
+    for (const relative5 of declared) {
+      if (typeof relative5 !== "string") {
         throw new Error(`Plugin ${pluginId} declares a non-string ${manifestKey} path`);
       }
       entries.push(
@@ -4133,7 +4244,7 @@ async function resolvePluginManifestEntries(repoRoot, repositoryId, pluginId, ar
           repositoryId,
           pluginId,
           kind,
-          await resolveDeclaredRelative(repoRoot, relative4),
+          await resolveDeclaredRelative(repoRoot, relative5),
           pluginManifest
         )
       );
@@ -4239,23 +4350,23 @@ async function findFlatFile(repoRoot, filename, preferredDir) {
   }
   return null;
 }
-async function materializePathEntry(repoRoot, repositoryId, pluginId, kind, relative4, pluginManifest) {
-  const sourcePath = path16.resolve(repoRoot, relative4);
+async function materializePathEntry(repoRoot, repositoryId, pluginId, kind, relative5, pluginManifest) {
+  const sourcePath = path16.resolve(repoRoot, relative5);
   if (sourcePath !== repoRoot && !sourcePath.startsWith(`${repoRoot}${path16.sep}`)) {
-    throw new Error(`Plugin ${pluginId} path escapes repository root: ${relative4}`);
+    throw new Error(`Plugin ${pluginId} path escapes repository root: ${relative5}`);
   }
-  const stat15 = await fsp12.stat(sourcePath).catch(() => null);
-  if (!stat15) {
-    throw new Error(`Plugin ${pluginId} source missing: ${relative4}`);
+  const stat16 = await fsp12.stat(sourcePath).catch(() => null);
+  if (!stat16) {
+    throw new Error(`Plugin ${pluginId} source missing: ${relative5}`);
   }
   if (kind === "skill") {
-    if (!stat15.isDirectory() || !await pathExists2(path16.join(sourcePath, "SKILL.md"))) {
-      throw new Error(`Plugin ${pluginId} skill source has no SKILL.md: ${relative4}`);
+    if (!stat16.isDirectory() || !await pathExists2(path16.join(sourcePath, "SKILL.md"))) {
+      throw new Error(`Plugin ${pluginId} skill source has no SKILL.md: ${relative5}`);
     }
     return [await buildEntry(repositoryId, pluginId, kind, sourcePath, false, pluginManifest)];
   }
-  if (!stat15.isFile()) {
-    throw new Error(`Plugin ${pluginId} ${kind} source is not a file: ${relative4}`);
+  if (!stat16.isFile()) {
+    throw new Error(`Plugin ${pluginId} ${kind} source is not a file: ${relative5}`);
   }
   return [await buildEntry(repositoryId, pluginId, kind, sourcePath, true, pluginManifest)];
 }
@@ -4377,9 +4488,9 @@ async function resolveCatalogPackage(sourceId, repoRoot, pluginId, cache) {
   }
   const cacheKey = `${sourceId}/${pluginId}`;
   try {
-    const stat15 = await fsp13.stat(manifestPath);
+    const stat16 = await fsp13.stat(manifestPath);
     const cached = cache.get(cacheKey);
-    if (cached && cached.mtimeMs === stat15.mtimeMs && cached.size === stat15.size) {
+    if (cached && cached.mtimeMs === stat16.mtimeMs && cached.size === stat16.size) {
       return cached.pkg;
     }
     const parsed = JSON.parse(await fsp13.readFile(manifestPath, "utf8"));
@@ -4408,7 +4519,7 @@ async function resolveCatalogPackage(sourceId, repoRoot, pluginId, cache) {
       ...typeof parsed.version === "string" && parsed.version.trim().length > 0 ? { version: parsed.version.trim() } : {},
       artifacts: pluginEntries.map(toArtifactSummary)
     };
-    cache.set(cacheKey, { mtimeMs: stat15.mtimeMs, size: stat15.size, pkg });
+    cache.set(cacheKey, { mtimeMs: stat16.mtimeMs, size: stat16.size, pkg });
     return pkg;
   } catch {
     cache.delete(cacheKey);
@@ -4495,8 +4606,8 @@ var CopilotSourceCatalogService = class {
    * exactly like git checkouts, so availability is a directory check.
    */
   async isSourceAvailable(sourceId) {
-    const stat15 = await fsp14.stat(path18.join(this.reposDir, sourceId)).catch(() => null);
-    return stat15?.isDirectory() === true;
+    const stat16 = await fsp14.stat(path18.join(this.reposDir, sourceId)).catch(() => null);
+    return stat16?.isDirectory() === true;
   }
   /**
    * Deterministic, side-effect-free update preview: compares the
@@ -4573,9 +4684,243 @@ var CopilotSourceCatalogService = class {
   }
 };
 
-// src/copilot-content/workspace-copilot-content-reconciler.ts
+// src/copilot-content/workspace-content-detector.ts
+import { createHash as createHash3 } from "crypto";
 import * as fsp15 from "fs/promises";
 import * as path19 from "path";
+function unmanagedDetectionSignature(detection) {
+  const parts = [
+    ...detection.adoptions.map((a) => `a:${a.kind}:${a.name}`),
+    ...detection.ambiguous.map((a) => `b:${a.kind}:${a.name}`),
+    ...detection.integrations.map((i) => `i:${i.kind}:${i.pluginId}`)
+  ].sort();
+  return parts.join("|");
+}
+function coveredTargetsOf(manifest) {
+  const targets = /* @__PURE__ */ new Set();
+  const extensions = manifest.extensions;
+  if (!extensions || typeof extensions !== "object") return targets;
+  for (const namespace of Object.values(extensions)) {
+    if (!namespace || typeof namespace !== "object") continue;
+    for (const [field, refs] of Object.entries(namespace)) {
+      if (!Array.isArray(refs)) continue;
+      for (const ref of refs) {
+        if (typeof ref !== "string" || !ref.startsWith("./")) continue;
+        const normalized = ref.replace(/^\.\//, "").replace(/\/+$/, "");
+        const segments = normalized.split("/");
+        const dir = segments[0];
+        const base = (segments[1] ?? "").replace(/\.(agent\.)?md$/i, "");
+        if (!base) continue;
+        if (dir === "skills" || field === "skills") targets.add(`skill:${base}`);
+        if (dir === "agents" || field === "agents") targets.add(`agent:${base}`);
+      }
+    }
+  }
+  return targets;
+}
+async function findPluginCoveringArtifact(repoRoot, kind, name) {
+  const root = path19.resolve(repoRoot);
+  const pluginsDir = path19.join(root, "plugins");
+  const dirents = await fsp15.readdir(pluginsDir, { withFileTypes: true }).catch(() => []);
+  const target = `${kind}:${name}`;
+  for (const dirent of dirents) {
+    if (!dirent.isDirectory()) continue;
+    const pluginDir = path19.join(pluginsDir, dirent.name);
+    let pluginName;
+    let pluginManifest;
+    for (const manifestRel of ["plugin.json", path19.join(".plugin", "plugin.json")]) {
+      const manifestPath = path19.resolve(pluginDir, manifestRel);
+      if (!manifestPath.startsWith(root + path19.sep)) continue;
+      try {
+        const parsed = JSON.parse(await fsp15.readFile(manifestPath, "utf8"));
+        if (typeof parsed?.name !== "string" || parsed.name.length === 0) continue;
+        pluginName = parsed.name;
+        pluginManifest = parsed;
+        break;
+      } catch {
+      }
+    }
+    if (pluginName === void 0 || pluginManifest === void 0) continue;
+    if (coveredTargetsOf(pluginManifest).has(target)) {
+      return pluginName;
+    }
+    const conventionBase = pluginManifest.extensions && typeof pluginManifest.extensions === "object" ? void 0 : path19.join(pluginDir, kind === "skill" ? "skills" : "agents");
+    if (conventionBase !== void 0) {
+      const conventionPath = path19.resolve(
+        conventionBase,
+        kind === "skill" ? path19.join(name, "SKILL.md") : `${name}.agent.md`
+      );
+      if (!conventionPath.startsWith(root + path19.sep)) continue;
+      if (await fsp15.stat(conventionPath).then(
+        () => true,
+        () => false
+      )) {
+        return pluginName;
+      }
+    }
+  }
+  return null;
+}
+function dedupeAdoptionsByPluginManifests(entries, pluginManifests) {
+  const covered = /* @__PURE__ */ new Map();
+  for (const [key, manifest] of pluginManifests) {
+    covered.set(key, coveredTargetsOf(manifest));
+  }
+  const kept = [];
+  const dropped = [];
+  for (const entry of entries) {
+    let owner;
+    for (const other of entries) {
+      if (other.repoId !== entry.repoId || other.name === entry.name) continue;
+      const targets = covered.get(`${entry.repoId}::${other.name}`);
+      if (targets?.has(`${entry.kind}:${entry.name}`)) {
+        owner = other.name;
+        break;
+      }
+    }
+    if (owner === void 0) {
+      kept.push(entry);
+    } else {
+      dropped.push({ entry, coveredBy: owner });
+    }
+  }
+  return { kept, dropped };
+}
+async function digestFile2(file) {
+  const hash = createHash3("sha256");
+  hash.update(await fsp15.readFile(file));
+  return hash.digest("hex");
+}
+async function digestTree(dir) {
+  const hash = createHash3("sha256");
+  await digestInto2(dir, hash);
+  return hash.digest("hex");
+}
+async function digestInto2(dir, hash) {
+  const dirents = await fsp15.readdir(dir, { withFileTypes: true });
+  dirents.sort((a, b) => a.name.localeCompare(b.name));
+  for (const dirent of dirents) {
+    const child = path19.join(dir, dirent.name);
+    hash.update(dirent.name);
+    if (dirent.isFile()) {
+      hash.update(await fsp15.readFile(child));
+    } else if (dirent.isDirectory()) {
+      await digestInto2(child, hash);
+    }
+  }
+}
+async function digestCatalogEntry(entry) {
+  return entry.dir === entry.manifestPath ? digestFile2(entry.manifestPath) : digestTree(entry.dir);
+}
+function entryNameFromLinkBasename(basename12, kind) {
+  if (kind === "agent") {
+    return basename12.replace(/\.agent\.md$/i, "");
+  }
+  return basename12;
+}
+async function readServicemeIdentities(configPath) {
+  try {
+    const raw = await fsp15.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed._serviceme && typeof parsed._serviceme === "object") {
+      return new Map(Object.entries(parsed._serviceme));
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Map();
+}
+async function detectUnmanagedWorkspaceContent(input) {
+  const detection = {
+    adoptions: [],
+    ambiguous: [],
+    integrations: [],
+    unmatched: []
+  };
+  const catalogByName = /* @__PURE__ */ new Map();
+  for (const entry of input.catalog) {
+    if (!input.knownRepoIds.has(entry.repoId)) continue;
+    const key = `${entry.kind}:${entry.name}`;
+    catalogByName.set(key, [...catalogByName.get(key) ?? [], entry]);
+  }
+  for (const kind of ["skill", "agent"]) {
+    const scanDir = path19.join(
+      input.workspaceDir,
+      ".github",
+      kind === "agent" ? "agents" : "skills"
+    );
+    const children = await fsp15.readdir(scanDir, { withFileTypes: true }).catch(() => []);
+    for (const child of children) {
+      const childPath = path19.join(scanDir, child.name);
+      const name = entryNameFromLinkBasename(child.name, kind);
+      const stat16 = await fsp15.lstat(childPath).catch(() => null);
+      if (!stat16) continue;
+      if (stat16.isSymbolicLink()) {
+        const target = await fsp15.readlink(childPath);
+        const resolved = path19.resolve(scanDir, target);
+        const relative5 = path19.relative(input.reposDir, resolved);
+        if (relative5.startsWith("..") || path19.isAbsolute(relative5)) {
+          detection.unmatched.push({ name, kind, reason: "foreign-symlink" });
+          continue;
+        }
+        const repoId = relative5.split(path19.sep)[0] ?? "";
+        if (!repoId || !input.knownRepoIds.has(repoId)) {
+          detection.unmatched.push({ name, kind, reason: "foreign-symlink" });
+          continue;
+        }
+        detection.adoptions.push({ repoId, name, kind, source: "symlink" });
+        continue;
+      }
+      const digest = stat16.isFile() ? await digestFile2(childPath) : await digestTree(childPath);
+      const candidates = catalogByName.get(`${kind}:${name}`) ?? [];
+      const matches = [];
+      for (const candidate of candidates) {
+        if (await digestCatalogEntry(candidate) === digest) {
+          matches.push(candidate.repoId);
+        }
+      }
+      if (matches.length === 1) {
+        detection.adoptions.push({
+          repoId: matches[0] ?? "",
+          name,
+          kind,
+          source: "fingerprint"
+        });
+      } else if (matches.length > 1) {
+        detection.ambiguous.push({ name, kind, candidates: matches.sort() });
+      } else {
+        detection.unmatched.push({ name, kind, reason: "no-catalog-match" });
+      }
+    }
+  }
+  for (const [configFile, kind] of [
+    ["hooks.serviceme.json", "hook"],
+    ["mcp.serviceme.json", "mcp"]
+  ]) {
+    const identities = await readServicemeIdentities(
+      path19.join(input.workspaceDir, ".vscode", configFile)
+    );
+    const seen = /* @__PURE__ */ new Set();
+    for (const identity of identities.keys()) {
+      const segments = identity.split("::");
+      if (segments.length < 3) continue;
+      const repoId = segments[0] ?? "";
+      const pluginId = segments[1] ?? "";
+      const kindPart = (segments[2] ?? "").split(":")[0] ?? "";
+      if (!repoId || !pluginId || kindPart !== kind || !input.knownRepoIds.has(repoId)) {
+        continue;
+      }
+      const dedupe = `${repoId}::${pluginId}::${kind}`;
+      if (seen.has(dedupe)) continue;
+      seen.add(dedupe);
+      detection.integrations.push({ repoId, pluginId, kind });
+    }
+  }
+  return detection;
+}
+
+// src/copilot-content/workspace-copilot-content-reconciler.ts
+import * as fsp16 from "fs/promises";
+import * as path20 from "path";
 var LINK_KINDS = /* @__PURE__ */ new Set(["agent", "skill", "instruction", "prompt"]);
 var INTEGRATION_KINDS = /* @__PURE__ */ new Set(["mcp", "hook"]);
 var WorkspaceCopilotContentReconciler = class {
@@ -4614,21 +4959,28 @@ var WorkspaceCopilotContentReconciler = class {
       }
       return { changed: false, entries };
     }
-    const reposDir = path19.join(this.homeDir, "repos");
+    const reposDir = path20.join(this.homeDir, "repos");
     const plan = await resolveWorkspaceContentPlan({ manifest, reposDir });
+    const sharedDisabled = /* @__PURE__ */ new Set();
+    for (const plugin of manifest.plugins) {
+      for (const target of plugin.disabledArtifacts ?? []) {
+        sharedDisabled.add(`${plugin.id}|${target}`);
+      }
+    }
     let linkEntries = plan.entries.filter((entry) => LINK_KINDS.has(entry.kind));
     let integrationEntries = plan.entries.filter((entry) => INTEGRATION_KINDS.has(entry.kind));
+    const isPlanEntryDisabled = (entry) => sharedDisabled.has(`${entry.pluginId}|${entry.kind}:${entry.name}`) || this.isDisabled !== void 0 && disabledIdentities.has(entry.identity);
+    const disabledIdentities = /* @__PURE__ */ new Set();
     if (this.isDisabled !== void 0) {
-      const disabled = /* @__PURE__ */ new Set();
       for (const entry of plan.entries) {
         if (await this.isDisabled(entry.identity)) {
-          disabled.add(entry.identity);
+          disabledIdentities.add(entry.identity);
         }
       }
-      if (disabled.size > 0) {
-        linkEntries = linkEntries.filter((entry) => !disabled.has(entry.identity));
-        integrationEntries = integrationEntries.filter((entry) => !disabled.has(entry.identity));
-      }
+    }
+    if (sharedDisabled.size > 0 || disabledIdentities.size > 0) {
+      linkEntries = linkEntries.filter((entry) => !isPlanEntryDisabled(entry));
+      integrationEntries = integrationEntries.filter((entry) => !isPlanEntryDisabled(entry));
     }
     const scopeOverlaps = previousState.entries.filter(
       (entry) => LINK_KINDS.has(entry.kind) && plan.entries.some((planned) => planned.identity === entry.identity) && !isWorkspaceScopePath(entry.linkPath)
@@ -4644,22 +4996,25 @@ var WorkspaceCopilotContentReconciler = class {
       });
       return { changed: false, entries };
     }
-    const excludeStore = new WorkspaceExcludeStore({ workspaceDir: this.workspaceDir });
+    const excludeStore = new WorkspaceExcludeStore({
+      workspaceDir: this.workspaceDir
+    });
     const linkMaterialized = await this.materializer.reconcile({
       workspaceDir: this.workspaceDir,
       entries: linkEntries,
       previousState
     });
+    const conflictedIds = new Set(plan.conflicts.map((conflict) => conflict.identity));
     const effectiveLinkIds = new Set(linkEntries.map((entry) => entry.identity));
     let removedLinks = 0;
     for (const previous of previousState.entries) {
       if (!LINK_KINDS.has(previous.kind) || effectiveLinkIds.has(previous.identity)) {
         continue;
       }
-      if (!isWorkspaceScopePath(previous.linkPath)) {
+      if (conflictedIds.has(previous.identity) || !isWorkspaceScopePath(previous.linkPath)) {
         continue;
       }
-      await fsp15.rm(path19.resolve(this.workspaceDir, previous.linkPath), {
+      await fsp16.rm(path20.resolve(this.workspaceDir, previous.linkPath), {
         force: true,
         recursive: true
       });
@@ -4692,7 +5047,15 @@ var WorkspaceCopilotContentReconciler = class {
     await excludeStore.reconcile(managedPaths);
     return {
       changed: linkMaterialized.changed || integrationMaterialized.changed || removedLinks > 0,
-      entries: [...linkMaterialized.entries, ...integrationMaterialized.entries]
+      entries: [
+        ...linkMaterialized.entries,
+        ...integrationMaterialized.entries,
+        ...plan.conflicts.map((conflict) => ({
+          identity: conflict.identity,
+          status: "conflict",
+          message: conflict.message
+        }))
+      ]
     };
   }
   /**
@@ -4737,14 +5100,18 @@ var WorkspaceCopilotContentReconciler = class {
       }
       try {
         if (entry.kind === "mcp") {
-          const raw = await fsp15.readFile(entry.sourcePath, "utf8");
+          const raw = await fsp16.readFile(entry.sourcePath, "utf8");
           for (const server of parseMcpJson(raw)) {
-            await mcpAdapter.applyServer({ workspaceDir: this.workspaceDir, entry, server });
+            await mcpAdapter.applyServer({
+              workspaceDir: this.workspaceDir,
+              entry,
+              server
+            });
             changed = true;
           }
         } else {
-          const hooksJsonPath = await findRepoHooksJson(path19.resolve(entry.sourcePath, "..", ".."), entry.name) ?? path19.join(entry.sourcePath, "hooks.json");
-          const raw = await fsp15.readFile(hooksJsonPath, "utf8");
+          const hooksJsonPath = await findRepoHooksJson(path20.resolve(entry.sourcePath, "..", ".."), entry.name) ?? path20.join(entry.sourcePath, "hooks.json");
+          const raw = await fsp16.readFile(hooksJsonPath, "utf8");
           await hookAdapter.applyHook({
             workspaceDir: this.workspaceDir,
             entry,
@@ -4798,14 +5165,17 @@ var WorkspaceCopilotContentReconciler = class {
     return this.reconcile();
   }
   async defaultEnsureRepository(manifest) {
-    const reposDir = path19.join(this.homeDir, "repos");
+    const reposDir = path20.join(this.homeDir, "repos");
     const sources = /* @__PURE__ */ new Map();
     for (const source of getWorkspaceManifestSources(manifest)) {
-      const localPath = path19.resolve(reposDir, source.id);
-      const stat15 = await fsp15.stat(localPath).catch(() => null);
+      const localPath = path20.resolve(reposDir, source.id);
+      const stat16 = await fsp16.stat(localPath).catch(() => null);
       sources.set(
         source.id,
-        stat15?.isDirectory() ? { ready: true, localPath } : { ready: false, error: "Source not materialized under ~/.serviceme/repos" }
+        stat16?.isDirectory() ? { ready: true, localPath } : {
+          ready: false,
+          error: "Source not materialized under ~/.serviceme/repos"
+        }
       );
     }
     return sources;
@@ -4854,7 +5224,7 @@ function declaredPinnedVersion(manifest, sourceId) {
 }
 
 // src/device/deviceAuth.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var DeviceAuthHeaders = {
   deviceId: "x-ms-device-id",
   deviceSecret: "x-ms-device-secret",
@@ -4870,7 +5240,7 @@ function createDeviceRequestSignature(params) {
     params.body,
     params.secret
   ].join("\n");
-  return createHash3("sha256").update(basis).digest("hex");
+  return createHash4("sha256").update(basis).digest("hex");
 }
 function buildSignedHeaders(params) {
   const timestamp = params.timestamp ?? Date.now();
@@ -4894,7 +5264,7 @@ function buildSignedHeaders(params) {
 import { randomBytes } from "crypto";
 
 // src/device/InstallationId.ts
-import { createHash as createHash4, randomUUID } from "crypto";
+import { createHash as createHash5, randomUUID } from "crypto";
 import * as os3 from "os";
 function fingerprintMaterial() {
   let username = "unknown";
@@ -4913,7 +5283,7 @@ function fingerprintMaterial() {
 }
 function deriveInstallationId() {
   const material = fingerprintMaterial();
-  const digest = createHash4("sha256").update(material).digest("hex");
+  const digest = createHash5("sha256").update(material).digest("hex");
   return formatAsV4(digest.slice(0, 32));
 }
 function randomInstallationId() {
@@ -5148,9 +5518,9 @@ async function emptyIdentity(random) {
 }
 
 // src/device/IdentityStore.ts
-import * as fsp16 from "fs/promises";
+import * as fsp17 from "fs/promises";
 import * as os4 from "os";
-import * as path20 from "path";
+import * as path21 from "path";
 import { setTimeout as delay } from "timers/promises";
 
 // src/device/types.ts
@@ -5166,7 +5536,7 @@ var TMP_SUFFIX = ".tmp";
 var FsIdentityFileBackend = class {
   async exists(filePath) {
     try {
-      await fsp16.access(filePath);
+      await fsp17.access(filePath);
       return true;
     } catch {
       return false;
@@ -5174,7 +5544,7 @@ var FsIdentityFileBackend = class {
   }
   async read(filePath) {
     try {
-      const buf = await fsp16.readFile(filePath, "utf8");
+      const buf = await fsp17.readFile(filePath, "utf8");
       const parsed = JSON.parse(buf);
       return migratePersistedIdentity(parsed);
     } catch (err) {
@@ -5183,23 +5553,23 @@ var FsIdentityFileBackend = class {
     }
   }
   async write(filePath, payload) {
-    await fsp16.mkdir(path20.dirname(filePath), { recursive: true });
+    await fsp17.mkdir(path21.dirname(filePath), { recursive: true });
     const tmpPath = `${filePath}${TMP_SUFFIX}`;
     const bytes = Buffer.from(JSON.stringify(payload, null, "	"), "utf8");
-    await fsp16.rm(tmpPath, { force: true });
-    const handle = await fsp16.open(tmpPath, "w", FILE_MODE);
+    await fsp17.rm(tmpPath, { force: true });
+    const handle = await fsp17.open(tmpPath, "w", FILE_MODE);
     try {
       await handle.writeFile(bytes);
       await handle.sync();
     } finally {
       await handle.close();
     }
-    await fsp16.rename(tmpPath, filePath);
-    await fsp16.chmod(filePath, FILE_MODE).catch(() => void 0);
+    await fsp17.rename(tmpPath, filePath);
+    await fsp17.chmod(filePath, FILE_MODE).catch(() => void 0);
     return { bytesWritten: bytes.byteLength, tmpPath };
   }
   async delete(filePath) {
-    await fsp16.rm(filePath, { force: true });
+    await fsp17.rm(filePath, { force: true });
   }
 };
 function migratePersistedIdentity(parsed) {
@@ -5237,7 +5607,7 @@ var FileLock = class {
   constructor(filePath, timeoutMs, retryMs) {
     this.acquired = false;
     this.dirPath = `${filePath}.lock`;
-    this.pidFilePath = path20.join(this.dirPath, LOCK_PID_FILE);
+    this.pidFilePath = path21.join(this.dirPath, LOCK_PID_FILE);
     this.timeoutMs = timeoutMs;
     this.retryMs = retryMs;
   }
@@ -5245,8 +5615,8 @@ var FileLock = class {
     const start = Date.now();
     while (true) {
       try {
-        await fsp16.mkdir(this.dirPath, { mode: LOCK_DIR_MODE });
-        await fsp16.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
+        await fsp17.mkdir(this.dirPath, { mode: LOCK_DIR_MODE });
+        await fsp17.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
         this.acquired = true;
         return;
       } catch (err) {
@@ -5255,7 +5625,7 @@ var FileLock = class {
         }
         const stale = await this.isStaleLock();
         if (stale) {
-          await fsp16.rm(this.dirPath, { recursive: true, force: true });
+          await fsp17.rm(this.dirPath, { recursive: true, force: true });
           continue;
         }
         if (Date.now() - start >= this.timeoutMs) {
@@ -5268,11 +5638,11 @@ var FileLock = class {
   async isStaleLock() {
     let pidStr;
     try {
-      pidStr = await fsp16.readFile(this.pidFilePath, "utf8");
+      pidStr = await fsp17.readFile(this.pidFilePath, "utf8");
     } catch {
       try {
-        const stat15 = await fsp16.stat(this.dirPath);
-        return Date.now() - stat15.mtimeMs > LOCK_STALE_GRACE_MS;
+        const stat16 = await fsp17.stat(this.dirPath);
+        return Date.now() - stat16.mtimeMs > LOCK_STALE_GRACE_MS;
       } catch {
         return false;
       }
@@ -5284,7 +5654,7 @@ var FileLock = class {
   async release() {
     if (!this.acquired) return;
     this.acquired = false;
-    await fsp16.rm(this.dirPath, { recursive: true, force: true });
+    await fsp17.rm(this.dirPath, { recursive: true, force: true });
   }
 };
 var IdentityStore = class {
@@ -5374,8 +5744,8 @@ var IdentityStore = class {
    * Useful when the bootstrap phase5 placeholder wasn't run yet.
    */
   async ensureHome() {
-    await fsp16.mkdir(getServicemeHome(), { recursive: true });
-    await fsp16.mkdir(path20.dirname(this.filePath), { recursive: true });
+    await fsp17.mkdir(getServicemeHome(), { recursive: true });
+    await fsp17.mkdir(path21.dirname(this.filePath), { recursive: true });
   }
 };
 
@@ -5487,15 +5857,15 @@ function projectMetadata(stored) {
 // src/drafts/index.ts
 import * as crypto from "crypto";
 import * as fs6 from "fs/promises";
-import * as path23 from "path";
+import * as path24 from "path";
 
 // src/skill-store/index.ts
 import * as fs5 from "fs/promises";
-import * as path22 from "path";
+import * as path23 from "path";
 
 // src/repo-layout/index.ts
 import * as fs4 from "fs/promises";
-import * as path21 from "path";
+import * as path22 from "path";
 
 // src/skill-store/index.ts
 function extractFrontmatter(raw) {
@@ -5572,7 +5942,7 @@ function generateDraftId() {
 }
 function resolveDraftDir(kind, id) {
   const root = kind === "skill" ? getSkillDraftsDir() : getAgentDraftsDir();
-  return path23.join(root, id);
+  return path24.join(root, id);
 }
 var DraftsStore = class {
   /**
@@ -5600,10 +5970,10 @@ var DraftsStore = class {
   async tryReadSummary(kind, id) {
     const dir = resolveDraftDir(kind, id);
     const manifestFilename = kind === "skill" ? "SKILL.md" : "AGENT.md";
-    const manifestPath = path23.join(dir, manifestFilename);
-    let stat15;
+    const manifestPath = path24.join(dir, manifestFilename);
+    let stat16;
     try {
-      stat15 = await fs6.stat(manifestPath);
+      stat16 = await fs6.stat(manifestPath);
     } catch {
       return null;
     }
@@ -5622,7 +5992,7 @@ var DraftsStore = class {
       dir,
       name,
       description,
-      modifiedAt: stat15.mtime.toISOString()
+      modifiedAt: stat16.mtime.toISOString()
     };
   }
   /** Single draft detail (summary + all files). Throws when missing. */
@@ -5661,8 +6031,8 @@ var DraftsStore = class {
     await fs6.rm(dir, { recursive: true, force: true });
     await fs6.mkdir(dir, { recursive: true });
     for (const f of opts.files) {
-      const full = path23.join(dir, f.path);
-      await fs6.mkdir(path23.dirname(full), { recursive: true });
+      const full = path24.join(dir, f.path);
+      await fs6.mkdir(path24.dirname(full), { recursive: true });
       const tmp = `${full}.${process.pid}.${Date.now()}.tmp`;
       await fs6.writeFile(tmp, f.content, "utf8");
       await fs6.rename(tmp, full);
@@ -5690,7 +6060,7 @@ var DraftsStore = class {
     }
     for (const n of names) {
       if (n.endsWith(".tmp")) {
-        await fs6.rm(path23.join(dir, n), { force: true }).catch(() => void 0);
+        await fs6.rm(path24.join(dir, n), { force: true }).catch(() => void 0);
       }
     }
   }
@@ -5704,12 +6074,12 @@ async function collectRecursive(absDir, root, out) {
   }
   for (const d of dirents) {
     if (d.name.endsWith(".tmp")) continue;
-    const full = path23.join(absDir, d.name);
+    const full = path24.join(absDir, d.name);
     if (d.isDirectory()) {
       await collectRecursive(full, root, out);
     } else if (d.isFile()) {
       const content = await fs6.readFile(full, "utf8");
-      out.push({ path: path23.relative(root, full), content });
+      out.push({ path: path24.relative(root, full), content });
     }
   }
 }
@@ -5717,7 +6087,7 @@ async function collectRecursive(absDir, root, out) {
 // src/env/environmentInspector.ts
 import { existsSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 import {
   createServicemeError as createServicemeError4,
   KNOWN_ENVIRONMENT_TOOLS
@@ -5952,7 +6322,7 @@ var EnvironmentInspector = class {
       candidates.push(dir.replace(/^\$HOME/, homedir2()));
     }
     for (const candidate of candidates) {
-      const scriptPath = join24(candidate, "nvm.sh");
+      const scriptPath = join25(candidate, "nvm.sh");
       if (existsSync(scriptPath)) {
         return scriptPath;
       }
@@ -6056,7 +6426,7 @@ var EnvironmentInspector = class {
 
 // src/git-client/index.ts
 import { spawn as spawn3 } from "child_process";
-import * as path24 from "path";
+import * as path25 from "path";
 
 // src/git-client/types.ts
 var GitError = class extends Error {
@@ -6250,8 +6620,8 @@ var GitClient = class {
       throw new GitError(["rev-parse", "--git-path", pathspec], result);
     }
     const resolved = result.stdout.trim();
-    if (!path24.isAbsolute(resolved)) {
-      return path24.resolve(localPath, resolved);
+    if (!path25.isAbsolute(resolved)) {
+      return path25.resolve(localPath, resolved);
     }
     return resolved;
   }
@@ -6313,7 +6683,7 @@ var GitClient = class {
 };
 var NodeGitSpawner = class {
   async spawn(args, opts) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve13, reject) => {
       const child = spawn3("git", args, {
         cwd: opts.cwd,
         stdio: ["ignore", "pipe", "pipe"],
@@ -6325,7 +6695,7 @@ var NodeGitSpawner = class {
       child.stderr?.on("data", (c) => stderrChunks.push(c));
       child.on("error", reject);
       child.on("close", (code) => {
-        resolve11({
+        resolve13({
           stdout: Buffer.concat(stdoutChunks).toString("utf8"),
           stderr: Buffer.concat(stderrChunks).toString("utf8"),
           code: code ?? 1
@@ -6354,7 +6724,7 @@ var StubGitSpawner = class {
   }
 };
 function toFileUrl(absolutePath) {
-  const normalized = path24.resolve(absolutePath);
+  const normalized = path25.resolve(absolutePath);
   if (process.platform === "win32") {
     return `file:///${normalized.replace(/\\/g, "/")}`;
   }
@@ -6367,7 +6737,7 @@ function buildGitProxyBase(serverBaseUrl) {
 
 // src/image/imageTools.ts
 import * as fs7 from "fs/promises";
-import * as path25 from "path";
+import * as path26 from "path";
 import {
   createServicemeError as createServicemeError5
 } from "@serviceme/devtools-protocol";
@@ -6382,7 +6752,7 @@ var ImageTools = class {
       if (!await this.pathExists(filePath)) {
         return { valid: false };
       }
-      if (!SUPPORTED_FORMATS.includes(path25.extname(filePath).toLowerCase())) {
+      if (!SUPPORTED_FORMATS.includes(path26.extname(filePath).toLowerCase())) {
         return { valid: false };
       }
       await this.getInfo(filePath, sharpModulePath);
@@ -6434,7 +6804,7 @@ var ImageTools = class {
   async compressWithSharp(imagePath, options) {
     const sharp = this.loadSharp(options.sharpModulePath);
     let pipeline = sharp(imagePath);
-    switch (options.format ?? path25.extname(imagePath).toLowerCase().slice(1)) {
+    switch (options.format ?? path26.extname(imagePath).toLowerCase().slice(1)) {
       case "jpg":
       case "jpeg":
         pipeline = pipeline.jpeg({ quality: options.quality });
@@ -6460,10 +6830,18 @@ var ImageTools = class {
     if (options.replaceOriginImage) {
       return inputPath;
     }
-    const dir = path25.dirname(inputPath);
-    const ext = path25.extname(inputPath);
-    const name = path25.basename(inputPath, ext);
-    return path25.join(dir, `${name}_compressed${ext}`);
+    const dir = path26.dirname(inputPath);
+    const ext = path26.extname(inputPath);
+    const name = path26.basename(inputPath, ext);
+    const outputPath = path26.join(dir, `${name}_compressed${ext}`);
+    const resolvedDir = path26.resolve(dir);
+    if (!path26.resolve(outputPath).startsWith(resolvedDir + path26.sep)) {
+      throw createServicemeError5(
+        "invalid_params",
+        "Derived output path escapes the image directory."
+      );
+    }
+    return outputPath;
   }
   async pathExists(targetPath) {
     try {
@@ -6577,7 +6955,7 @@ function detectIndent(text) {
 import { randomUUID as randomUUID2 } from "crypto";
 import * as fs8 from "fs/promises";
 import { open as open2 } from "fs/promises";
-import * as path26 from "path";
+import * as path27 from "path";
 async function readServerProxyGlobal() {
   const filePath = getServerProxyGlobalPath();
   try {
@@ -6596,7 +6974,7 @@ async function readServerProxyGlobal() {
 }
 async function writeServerProxyGlobal(patch) {
   const filePath = getServerProxyGlobalPath();
-  const dirPath = path26.dirname(filePath);
+  const dirPath = path27.dirname(filePath);
   await fs8.mkdir(dirPath, { recursive: true });
   const current = await readServerProxyGlobal() ?? {
     enabled: false,
@@ -6651,7 +7029,7 @@ function isENOENT(err) {
 // src/phase5/bootstrap.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import * as fs9 from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 function getPhase5FileSpecs() {
   return [
     {
@@ -6707,7 +7085,7 @@ async function bootstrapPhase5Placeholders() {
       result.skipped.push(spec.path);
     } catch {
       try {
-        await fs9.mkdir(path27.dirname(spec.path), { recursive: true });
+        await fs9.mkdir(path28.dirname(spec.path), { recursive: true });
         await fs9.writeFile(spec.path, spec.defaultContent, "utf8");
         result.created.push(spec.path);
       } catch (writeErr) {
@@ -6720,29 +7098,29 @@ async function bootstrapPhase5Placeholders() {
 
 // src/project/projectTools.ts
 import * as fs10 from "fs/promises";
-import * as path28 from "path";
+import * as path29 from "path";
 import {
   createServicemeError as createServicemeError7
 } from "@serviceme/devtools-protocol";
 
 // src/utils/fileUtils.ts
 import { constants, createWriteStream } from "fs";
-import { access as access7, copyFile as copyFile3, lstat as lstat6, mkdir as mkdir16, readdir as readdir8, rename as rename12, rm as rm10 } from "fs/promises";
-import { dirname as dirname19, join as join26 } from "path";
+import { access as access7, copyFile as copyFile3, lstat as lstat7, mkdir as mkdir16, readdir as readdir9, rename as rename12, rm as rm10 } from "fs/promises";
+import { dirname as dirname19, join as join27 } from "path";
 import yauzl from "yauzl";
 var unzipFile = (zipPath, dest) => {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
       if (err) return reject(err);
       if (!zipfile) return reject(new Error("Failed to open zip file."));
       zipfile.readEntry();
       zipfile.on("entry", (entry) => {
         if (/\/$/.test(entry.fileName)) {
-          void mkdir16(join26(dest, entry.fileName), { recursive: true }).then(() => {
+          void mkdir16(join27(dest, entry.fileName), { recursive: true }).then(() => {
             zipfile.readEntry();
           }).catch(reject);
         } else {
-          const outputPath = join26(dest, entry.fileName);
+          const outputPath = join27(dest, entry.fileName);
           void mkdir16(dirname19(outputPath), { recursive: true }).then(() => {
             zipfile.openReadStream(
               entry,
@@ -6762,7 +7140,7 @@ var unzipFile = (zipPath, dest) => {
         }
       });
       zipfile.on("end", () => {
-        resolve11();
+        resolve13();
       });
       zipfile.on("error", (zipError) => {
         reject(zipError);
@@ -6772,13 +7150,13 @@ var unzipFile = (zipPath, dest) => {
 };
 var tryLstat = async (targetPath) => {
   try {
-    return await lstat6(targetPath);
+    return await lstat7(targetPath);
   } catch {
     return null;
   }
 };
 var mergeEntry = async (sourcePath, destPath, overwrite) => {
-  const sourceStat = await lstat6(sourcePath);
+  const sourceStat = await lstat7(sourcePath);
   const destStat = await tryLstat(destPath);
   if (sourceStat.isDirectory()) {
     if (destStat && !destStat.isDirectory()) {
@@ -6789,9 +7167,9 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
       await rm10(destPath, { recursive: true, force: true });
     }
     await mkdir16(destPath, { recursive: true });
-    const children = await readdir8(sourcePath);
+    const children = await readdir9(sourcePath);
     for (const child of children) {
-      await mergeEntry(join26(sourcePath, child), join26(destPath, child), overwrite);
+      await mergeEntry(join27(sourcePath, child), join27(destPath, child), overwrite);
     }
     await rm10(sourcePath, { recursive: true, force: true });
     return;
@@ -6812,10 +7190,10 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
 };
 var moveFiles = async (sourceDir, destDir, overwrite = false) => {
   await mkdir16(destDir, { recursive: true });
-  const files = await readdir8(sourceDir);
+  const files = await readdir9(sourceDir);
   for (const file of files) {
-    const sourceFile = join26(sourceDir, file);
-    const destFile = join26(destDir, file);
+    const sourceFile = join27(sourceDir, file);
+    const destFile = join27(destDir, file);
     if (!overwrite) {
       try {
         await access7(destFile, constants.F_OK);
@@ -6832,7 +7210,7 @@ var moveFiles = async (sourceDir, destDir, overwrite = false) => {
 var ProjectTools = class {
   async extractTemplate(zipPath, workspacePath, tempExtractDir, input) {
     await unzipFile(zipPath, tempExtractDir);
-    let sourceDir = path28.join(tempExtractDir, input.extractedDirName);
+    let sourceDir = path29.join(tempExtractDir, input.extractedDirName);
     let actualDirName = input.extractedDirName;
     if (!await this.pathExists(sourceDir)) {
       const entries = await fs10.readdir(tempExtractDir, { withFileTypes: true });
@@ -6847,7 +7225,7 @@ var ProjectTools = class {
       );
       if (selectedDirectory) {
         actualDirName = selectedDirectory;
-        sourceDir = path28.join(tempExtractDir, actualDirName);
+        sourceDir = path29.join(tempExtractDir, actualDirName);
       } else if (directories.length === 0) {
         throw new Error(
           `No directory found after extraction. Expected directory: ${input.extractedDirName}`
@@ -6870,6 +7248,13 @@ var ProjectTools = class {
     if (!command) {
       throw createServicemeError7("invalid_params", "Expected install command.");
     }
+    const hasControlCharacter = [...command].some((character) => {
+      const code = character.charCodeAt(0);
+      return code > 0 && code < 32 && character !== "	";
+    });
+    if (hasControlCharacter) {
+      throw createServicemeError7("invalid_params", "Install command contains control characters.");
+    }
     await runCommand(command, {
       cwd: workspacePath,
       shell: true
@@ -6945,7 +7330,7 @@ var ProjectTools = class {
     };
   }
   async ensurePresetManifest(workspacePath, preset) {
-    const presetManifestPath = path28.join(
+    const presetManifestPath = path29.join(
       workspacePath,
       ".ms-scaffold",
       "presets",
@@ -6954,7 +7339,7 @@ var ProjectTools = class {
     if (await this.pathExists(presetManifestPath)) {
       return;
     }
-    const projectModePath = path28.join(workspacePath, ".ms-scaffold", "project-mode.json");
+    const projectModePath = path29.join(workspacePath, ".ms-scaffold", "project-mode.json");
     if (!await this.pathExists(projectModePath)) {
       return;
     }
@@ -6970,7 +7355,7 @@ var ProjectTools = class {
       mergeManagedFiles: [],
       userOwnedPaths: []
     };
-    await fs10.mkdir(path28.dirname(presetManifestPath), { recursive: true });
+    await fs10.mkdir(path29.dirname(presetManifestPath), { recursive: true });
     await fs10.writeFile(
       presetManifestPath,
       `${JSON.stringify(synthesizedPreset, null, 2)}
@@ -6987,7 +7372,7 @@ var ProjectTools = class {
       return results;
     }
     for (const entry of entries) {
-      const fullPath = path28.join(dir, entry.name);
+      const fullPath = path29.join(dir, entry.name);
       if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
         results.push(...await this.findScripts(fullPath, extensions));
       } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
@@ -7015,7 +7400,7 @@ var ProjectTools = class {
     const matches = [];
     for (const directoryName of directoryNames) {
       if (await this.directoryMatchesProjectPattern(
-        path28.join(tempExtractDir, directoryName),
+        path29.join(tempExtractDir, directoryName),
         projectFilePattern
       )) {
         matches.push(directoryName);
@@ -7041,7 +7426,7 @@ function createProjectTools() {
 
 // src/repo-manager/index.ts
 import * as fs11 from "fs/promises";
-import * as path29 from "path";
+import * as path30 from "path";
 
 // src/repos/types.ts
 function isDefaultRepo(repo) {
@@ -7133,7 +7518,7 @@ var RepoManager = class {
       }
       try {
         if (!this.skipClone) {
-          await fs11.mkdir(path29.dirname(localPath), { recursive: true });
+          await fs11.mkdir(path30.dirname(localPath), { recursive: true });
           await this.git.clone(repo.id, repo.url, localPath, repo.branch, true);
         }
         await this.store.updateRepo(repo.id, {
@@ -7175,7 +7560,7 @@ var RepoManager = class {
       await fs11.rm(localPath, { recursive: true, force: true });
     }
     if (!exists || !await this.pathExists(localPath)) {
-      await fs11.mkdir(path29.dirname(localPath), { recursive: true });
+      await fs11.mkdir(path30.dirname(localPath), { recursive: true });
       if (!this.skipClone) {
         await this.git.clone(proxyId, repo.url, localPath, repo.branch, useProxy);
       }
@@ -7242,7 +7627,7 @@ var RepoManager = class {
       await fs11.rm(localPath, { recursive: true, force: true });
     }
     if (!exists || !await this.pathExists(localPath)) {
-      await fs11.mkdir(path29.dirname(localPath), { recursive: true });
+      await fs11.mkdir(path30.dirname(localPath), { recursive: true });
       if (!this.skipClone) {
         await this.git.clone(
           input.repository.useProxy ?? true ? input.repository.id : input.repository.id,
@@ -7389,7 +7774,7 @@ var RepoManager = class {
     let cloned = false;
     if (!this.skipClone) {
       const localPath = getRepoDir(uniqueId);
-      await fs11.mkdir(path29.dirname(localPath), { recursive: true });
+      await fs11.mkdir(path30.dirname(localPath), { recursive: true });
       await this.git.clone(userProxyId, url, localPath, branch, useProxy);
       cloned = true;
     }
@@ -7445,7 +7830,7 @@ var RepoManager = class {
    * (e.g. from an interrupted clone) return `false`.
    */
   async isValidGitRepo(p) {
-    return this.pathExists(path29.join(p, ".git"));
+    return this.pathExists(path30.join(p, ".git"));
   }
   async pathExists(p) {
     try {
@@ -7612,7 +7997,7 @@ function resolveDefaultRepoId(existing, existingIds) {
 
 // src/repos/loader.ts
 import * as fs12 from "fs/promises";
-import * as path30 from "path";
+import * as path31 from "path";
 import { z as z2 } from "zod";
 var ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
 var repoIdSchema = z2.string().min(1).max(64).regex(SAFE_REPO_ID_PATTERN, "repo id must match /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/");
@@ -7748,7 +8133,7 @@ var ReposLoader = class {
    */
   async save(config) {
     const validated = reposFileSchema.parse(config);
-    const dir = path30.dirname(this.configPath);
+    const dir = path31.dirname(this.configPath);
     await this.fileSystem.mkdir(dir, { recursive: true });
     const serialized = `${JSON.stringify(validated, null, 2)}
 `;
@@ -8109,14 +8494,14 @@ async function bootstrapDefaults(store) {
 
 // src/scheduled-tasks/daemon/DaemonLogger.ts
 import * as fs14 from "fs";
-import * as path31 from "path";
+import * as path32 from "path";
 var CONFIG_DIR = ".serviceme";
 var LOG_FILE = "scheduler.log";
 var MAX_LOG_SIZE = 1024 * 1024;
 var DaemonLogger = class {
   constructor(workspacePath, options = {}) {
-    this.logPath = options.logPath ?? path31.join(workspacePath, CONFIG_DIR, LOG_FILE);
-    const dir = path31.dirname(this.logPath);
+    this.logPath = options.logPath ?? path32.join(workspacePath, CONFIG_DIR, LOG_FILE);
+    const dir = path32.dirname(this.logPath);
     if (!fs14.existsSync(dir)) {
       fs14.mkdirSync(dir, { recursive: true });
     }
@@ -8148,31 +8533,31 @@ var DaemonLogger = class {
 
 // src/scheduled-tasks/daemon/PidManager.ts
 import * as fs15 from "fs";
-import * as path32 from "path";
+import * as path33 from "path";
 var CONFIG_DIR2 = ".serviceme";
 var PID_FILE = "scheduler.pid";
 var PidManager = class {
   constructor(workspacePath, options = {}) {
-    this.pidPath = options.pidPath ?? path32.join(workspacePath, CONFIG_DIR2, PID_FILE);
+    this.pidPath = options.pidPath ?? path33.join(workspacePath, CONFIG_DIR2, PID_FILE);
   }
   getPidPath() {
     return this.pidPath;
   }
   writePid(pid) {
-    const dir = path32.dirname(this.pidPath);
+    const dir = path33.dirname(this.pidPath);
     if (!fs15.existsSync(dir)) {
       fs15.mkdirSync(dir, { recursive: true });
     }
     fs15.writeFileSync(this.pidPath, String(pid), "utf-8");
   }
   readPid() {
-    let stat15;
+    let stat16;
     try {
-      stat15 = fs15.statSync(this.pidPath);
+      stat16 = fs15.statSync(this.pidPath);
     } catch {
       return null;
     }
-    if (!stat15.isFile()) return null;
+    if (!stat16.isFile()) return null;
     const raw = fs15.readFileSync(this.pidPath, "utf-8").trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isNaN(pid) ? null : pid;
@@ -8202,7 +8587,7 @@ var PidManager = class {
 // src/scheduled-tasks/daemon/SchedulerDaemonV2.ts
 import * as fs20 from "fs";
 import * as os6 from "os";
-import * as path36 from "path";
+import * as path37 from "path";
 
 // src/scheduled-tasks/executors/GithubCopilotCliExecutor.ts
 import { spawn as spawn4 } from "child_process";
@@ -8293,16 +8678,16 @@ var GithubCopilotCliExecutor = class {
   executeStreaming(payload, onOutput, abortSignal) {
     const p = payload;
     const execution = resolveGithubCopilotCliExecution(p);
-    let resolve11;
+    let resolve13;
     const resultPromise = new Promise((r) => {
-      resolve11 = r;
+      resolve13 = r;
     });
     let settled = false;
     const settle = (result) => {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
-      resolve11?.(result);
+      resolve13?.(result);
     };
     if (abortSignal?.aborted) {
       return {
@@ -8448,7 +8833,7 @@ ${body}`.trim()
 // src/scheduled-tasks/executors/ShellExecutor.ts
 import { spawn as spawn5 } from "child_process";
 import * as fs17 from "fs";
-import * as path33 from "path";
+import * as path34 from "path";
 var MAX_OUTPUT_BYTES2 = 1024 * 1024;
 var DEFAULT_TIMEOUT_MS4 = 6e4;
 var POSIX_SHELL_CANDIDATES = ["bash.exe", "sh.exe"];
@@ -8500,10 +8885,10 @@ function findWindowsPosixShell(env, fileExists) {
     if (fileExists(candidate)) return candidate;
   }
   const pathValue = env.Path ?? env.PATH ?? "";
-  for (const dir of pathValue.split(path33.win32.delimiter)) {
+  for (const dir of pathValue.split(path34.win32.delimiter)) {
     if (!dir) continue;
     for (const executable of POSIX_SHELL_CANDIDATES) {
-      const candidate = path33.win32.join(dir, executable);
+      const candidate = path34.win32.join(dir, executable);
       if (fileExists(candidate) && !isWindowsWslLauncher(candidate)) {
         return candidate;
       }
@@ -8512,7 +8897,7 @@ function findWindowsPosixShell(env, fileExists) {
   return null;
 }
 function isWindowsWslLauncher(candidate) {
-  const normalized = path33.win32.normalize(candidate).toLowerCase();
+  const normalized = path34.win32.normalize(candidate).toLowerCase();
   return normalized.endsWith("\\windows\\system32\\bash.exe") || normalized.endsWith("\\windows\\syswow64\\bash.exe");
 }
 function writeDiagnostic2(message) {
@@ -8539,16 +8924,16 @@ var ShellExecutor = class {
   executeStreaming(payload, onOutput, abortSignal) {
     const p = payload;
     const timeoutMs = resolveConfiguredTimeoutMs(p.timeout, DEFAULT_TIMEOUT_MS4);
-    let resolve11;
+    let resolve13;
     const resultPromise = new Promise((r) => {
-      resolve11 = r;
+      resolve13 = r;
     });
     let settled = false;
     const settle = (result) => {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
-      resolve11?.(result);
+      resolve13?.(result);
     };
     if (abortSignal?.aborted) {
       return {
@@ -8663,7 +9048,7 @@ function getExecutor(taskType) {
 import { randomUUID as randomUUID4 } from "crypto";
 import * as fs18 from "fs";
 import * as os5 from "os";
-import * as path34 from "path";
+import * as path35 from "path";
 import {
   createServicemeError as createServicemeError8,
   isScheduledTasksConfig,
@@ -8693,7 +9078,7 @@ function v1ContainerShape(value) {
 }
 function defaultWorkspaceContext() {
   const home = os5.homedir() || "/";
-  return { path: home, name: path34.basename(home) || home };
+  return { path: home, name: path35.basename(home) || home };
 }
 function requireNonEmptyString(payload, field, taskType) {
   if (!isRecord2(payload) || typeof payload[field] !== "string" || !payload[field].trim()) {
@@ -8797,7 +9182,7 @@ var TaskConfigManager = class {
         snippet: raw.slice(0, 500),
         recordedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      fs18.mkdirSync(path34.dirname(target), { recursive: true });
+      fs18.mkdirSync(path35.dirname(target), { recursive: true });
       fs18.writeFileSync(target, JSON.stringify(failures, null, "	"), "utf-8");
     } catch (writeError) {
       this.warn(
@@ -8806,7 +9191,7 @@ var TaskConfigManager = class {
     }
   }
   writeConfig(config) {
-    const dir = path34.dirname(this.configPath);
+    const dir = path35.dirname(this.configPath);
     if (!fs18.existsSync(dir)) {
       fs18.mkdirSync(dir, { recursive: true });
     }
@@ -9091,7 +9476,7 @@ var TaskExecutionEngine = class {
 // src/scheduled-tasks/TaskLogManager.ts
 import { randomUUID as randomUUID5 } from "crypto";
 import * as fs19 from "fs";
-import * as path35 from "path";
+import * as path36 from "path";
 var MAX_LOGS = 200;
 function emptyLogFile() {
   return { logs: [] };
@@ -9148,7 +9533,7 @@ var TaskLogManager = class {
     }
   }
   writeLogFile(file) {
-    const dir = path35.dirname(this.logPath);
+    const dir = path36.dirname(this.logPath);
     if (!fs19.existsSync(dir)) {
       fs19.mkdirSync(dir, { recursive: true });
     }
@@ -9221,7 +9606,7 @@ var SchedulerDaemonV2 = class {
     this.logManager = options.logManager ?? new TaskLogManager();
     this.pidManager = options.pidManager ?? new PidManager("", { pidPath: getSchedulerPidPath() });
     this.logger = options.logger ?? new DaemonLogger(os6.homedir(), {
-      logPath: path36.join(path36.dirname(this.pidManager.getPidPath()), SCHEDULER_LOG_FILENAME2)
+      logPath: path37.join(path37.dirname(this.pidManager.getPidPath()), SCHEDULER_LOG_FILENAME2)
     });
     this.getExecutor = options.getExecutor ?? getExecutor;
     this.tryAcquireLock = options.tryAcquireLock ?? (() => true);
@@ -9437,14 +9822,14 @@ function matchCronField(field, value) {
 
 // src/scheduled-tasks/migration/MigrateToGlobal.ts
 import * as fs21 from "fs";
-import * as path37 from "path";
+import * as path38 from "path";
 import { isScheduledTasksConfigV1 as isScheduledTasksConfigV12, migrateV1ToV2 as migrateV1ToV22 } from "@serviceme/devtools-protocol";
 var WORKSPACE_DIR = ".serviceme";
 var V1_FILENAME = "scheduled-tasks.json";
 function defaultProbe(workspacePath) {
   return {
     path: workspacePath,
-    name: path37.basename(workspacePath) || workspacePath
+    name: path38.basename(workspacePath) || workspacePath
   };
 }
 function readV1Config(v1Path) {
@@ -9478,7 +9863,7 @@ function safeDelete(filePath) {
   }
 }
 function ensureDir(filePath) {
-  const dir = path37.dirname(filePath);
+  const dir = path38.dirname(filePath);
   if (!fs21.existsSync(dir)) {
     fs21.mkdirSync(dir, { recursive: true });
   }
@@ -9523,7 +9908,7 @@ async function migrateToGlobal(options) {
   const conflicts = [];
   const issues = [];
   for (const workspacePath of options.workspacePaths) {
-    const v1Path = path37.join(workspacePath, WORKSPACE_DIR, V1_FILENAME);
+    const v1Path = path38.join(workspacePath, WORKSPACE_DIR, V1_FILENAME);
     if (!fs21.existsSync(v1Path)) continue;
     const v1 = readV1Config(v1Path);
     if (!v1.ok) {
@@ -9585,7 +9970,7 @@ async function migrateToGlobal(options) {
 // src/scheduled-tasks/workspace-probe/WorkspaceProbe.ts
 import { spawn as spawn6 } from "child_process";
 import * as fs22 from "fs";
-import * as path38 from "path";
+import * as path39 from "path";
 var DEFAULT_TIMEOUT_MS5 = 2e3;
 var GitTimeoutError = class extends Error {
   constructor() {
@@ -9601,7 +9986,7 @@ function isTimeout(err) {
   return false;
 }
 function defaultRunGit(gitBinary, args, cwd, timeoutMs) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve13, reject) => {
     let settled = false;
     const child = spawn6(gitBinary, args, {
       cwd,
@@ -9631,7 +10016,7 @@ function defaultRunGit(gitBinary, args, cwd, timeoutMs) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve11({ stdout, stderr, code: code ?? 0 });
+      resolve13({ stdout, stderr, code: code ?? 0 });
     });
   });
 }
@@ -9648,7 +10033,7 @@ var WorkspaceProbe = class {
     }
   }
   async probe(workspacePath) {
-    const name = path38.basename(workspacePath) || workspacePath;
+    const name = path39.basename(workspacePath) || workspacePath;
     if (!workspacePath || !fs22.existsSync(workspacePath)) {
       return {
         workspace: { path: workspacePath, name },
@@ -9802,7 +10187,7 @@ var SkillReconciler = class {
 
 // src/skills/SkillStore.ts
 import * as fs23 from "fs/promises";
-import * as path39 from "path";
+import * as path40 from "path";
 var USER_SKILL_MARKER_FILE = ".serviceme-skill.json";
 var LEGACY_USER_SKILL_MARKER_FILE = ".ms-devtools-skill.json";
 var WORKSPACE_SKILLS_ROOT_RELATIVE = ".github/skills";
@@ -9838,10 +10223,10 @@ var SkillStore = class {
     return WORKSPACE_SKILLS_MARKER_RELATIVE;
   }
   getUserSkillPath(skillId) {
-    return path39.join(this.userSkillsRoot, skillId);
+    return path40.join(this.userSkillsRoot, skillId);
   }
   async listWorkspaceSkillIds() {
-    const skillsRootPath = path39.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE);
+    const skillsRootPath = path40.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE);
     try {
       const entries = await this.fileSystem.readdir(skillsRootPath, {
         withFileTypes: true
@@ -9865,7 +10250,7 @@ var SkillStore = class {
     const targetDir = this.getUserSkillPath(skillId);
     await this.fileSystem.mkdir(targetDir, { recursive: true });
     await this.fileSystem.writeFile(
-      path39.join(targetDir, USER_SKILL_MARKER_FILE),
+      path40.join(targetDir, USER_SKILL_MARKER_FILE),
       JSON.stringify({ skillId, installedBy: "serviceme" }, null, 2),
       "utf-8"
     );
@@ -9874,7 +10259,7 @@ var SkillStore = class {
     await this.migrateLegacyUserSkillMarker(skillId);
     try {
       const marker = await this.fileSystem.readFile(
-        path39.join(this.getUserSkillPath(skillId), USER_SKILL_MARKER_FILE),
+        path40.join(this.getUserSkillPath(skillId), USER_SKILL_MARKER_FILE),
         "utf-8"
       );
       const parsed = JSON.parse(marker);
@@ -9891,8 +10276,8 @@ var SkillStore = class {
    */
   async migrateLegacyUserSkillMarker(skillId) {
     const targetDir = this.getUserSkillPath(skillId);
-    const newPath = path39.join(targetDir, USER_SKILL_MARKER_FILE);
-    const legacyPath = path39.join(targetDir, LEGACY_USER_SKILL_MARKER_FILE);
+    const newPath = path40.join(targetDir, USER_SKILL_MARKER_FILE);
+    const legacyPath = path40.join(targetDir, LEGACY_USER_SKILL_MARKER_FILE);
     try {
       await this.fileSystem.readFile(newPath, "utf-8");
       return;
@@ -9905,12 +10290,12 @@ var SkillStore = class {
     }
   }
   async writeSkillFiles(skillId, scope, files) {
-    const root = scope === "workspace" ? path39.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE) : this.userSkillsRoot;
-    const targetDir = path39.join(root, skillId);
+    const root = scope === "workspace" ? path40.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE) : this.userSkillsRoot;
+    const targetDir = path40.join(root, skillId);
     await this.fileSystem.mkdir(targetDir, { recursive: true });
     for (const file of files) {
-      const filePath = path39.join(targetDir, file.path);
-      await this.fileSystem.mkdir(path39.dirname(filePath), { recursive: true });
+      const filePath = path40.join(targetDir, file.path);
+      await this.fileSystem.mkdir(path40.dirname(filePath), { recursive: true });
       await this.fileSystem.writeFile(filePath, file.content, "utf-8");
       if (file.executable) {
         try {
@@ -9923,8 +10308,8 @@ var SkillStore = class {
 };
 async function migrateLegacyUserSkillContent(input) {
   const fileSystem = input.fileSystem ?? fs23;
-  const legacyRoot = path39.join(input.homeDir, ...LEGACY_USER_SKILLS_ROOT_RELATIVE.split("/"));
-  const targetRoot = path39.join(input.homeDir, ".copilot", "skills");
+  const legacyRoot = path40.join(input.homeDir, ...LEGACY_USER_SKILLS_ROOT_RELATIVE.split("/"));
+  const targetRoot = path40.join(input.homeDir, ".copilot", "skills");
   let entries;
   try {
     entries = await fileSystem.readdir(legacyRoot, { withFileTypes: true });
@@ -9936,8 +10321,8 @@ async function migrateLegacyUserSkillContent(input) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
     result.push({
       id: entry.name,
-      legacyPath: path39.join(legacyRoot, entry.name),
-      targetPath: path39.join(targetRoot, entry.name),
+      legacyPath: path40.join(legacyRoot, entry.name),
+      targetPath: path40.join(targetRoot, entry.name),
       status: "migration_available"
     });
   }
@@ -9946,7 +10331,7 @@ async function migrateLegacyUserSkillContent(input) {
 
 // src/submit/index.ts
 import * as fs24 from "fs/promises";
-import * as path40 from "path";
+import * as path41 from "path";
 
 // src/submit/types.ts
 var SubmitError = class extends Error {
@@ -9996,11 +10381,11 @@ var SubmitClient = class {
       throw new SubmitError(v.reason ?? "unknown", v.detail ?? "validation denied");
     }
     const localRepoPath = getRepoDir(repoId);
-    const targetDir = path40.join(localRepoPath, "skills", skillName);
+    const targetDir = path41.join(localRepoPath, "skills", skillName);
     await fs24.mkdir(targetDir, { recursive: true });
     for (const f of files) {
-      const full = path40.join(targetDir, f.path);
-      await fs24.mkdir(path40.dirname(full), { recursive: true });
+      const full = path41.join(targetDir, f.path);
+      await fs24.mkdir(path41.dirname(full), { recursive: true });
       const tmp = `${full}.${process.pid}.${Date.now()}.tmp`;
       await fs24.writeFile(tmp, f.content, "utf8");
       await fs24.rename(tmp, full);
@@ -10071,8 +10456,8 @@ function touchLastUsedAt(tools, id, when = /* @__PURE__ */ new Date()) {
 }
 
 // src/toolbox/ToolboxStore.ts
-import * as fsp17 from "fs/promises";
-import * as path41 from "path";
+import * as fsp18 from "fs/promises";
+import * as path42 from "path";
 import { setTimeout as delay2 } from "timers/promises";
 
 // src/toolbox/types.ts
@@ -10108,19 +10493,19 @@ var DEFAULT_LOCK_TIMEOUT_MS2 = 5e3;
 var DEFAULT_LOCK_RETRY_MS2 = 25;
 var LOCK_STALE_GRACE_MS2 = 200;
 var TMP_SUFFIX2 = ".tmp";
-var WORKSPACE_TOOLBOX_RELATIVE_PATH = path41.join(".github", ".serviceme-toolbox.json");
+var WORKSPACE_TOOLBOX_RELATIVE_PATH = path42.join(".github", ".serviceme-toolbox.json");
 var LEGACY_WORKSPACE_TOOLBOX_FILENAME = ".ms-devtools-toolbox.json";
 async function migrateLegacyWorkspaceToolboxFile(filePath) {
   if (!filePath) return;
-  const legacyPath = path41.join(path41.dirname(filePath), LEGACY_WORKSPACE_TOOLBOX_FILENAME);
+  const legacyPath = path42.join(path42.dirname(filePath), LEGACY_WORKSPACE_TOOLBOX_FILENAME);
   if (legacyPath === filePath) return;
   try {
-    await fsp17.access(filePath);
+    await fsp18.access(filePath);
     return;
   } catch {
   }
   try {
-    await fsp17.rename(legacyPath, filePath);
+    await fsp18.rename(legacyPath, filePath);
   } catch {
   }
 }
@@ -10130,7 +10515,7 @@ var FsToolboxFileBackend = class {
   }
   async exists(filePath) {
     try {
-      await fsp17.access(filePath);
+      await fsp18.access(filePath);
       return true;
     } catch {
       return false;
@@ -10139,7 +10524,7 @@ var FsToolboxFileBackend = class {
   async read(filePath) {
     let buf;
     try {
-      buf = await fsp17.readFile(filePath, "utf8");
+      buf = await fsp18.readFile(filePath, "utf8");
     } catch (err) {
       if (isNodeError2(err) && err.code === "ENOENT") return null;
       throw err;
@@ -10155,43 +10540,43 @@ var FsToolboxFileBackend = class {
   async backupCorruptedFile(filePath) {
     try {
       const backupPath = `${filePath}.corrupted.${Date.now()}.bak`;
-      await fsp17.copyFile(filePath, backupPath);
+      await fsp18.copyFile(filePath, backupPath);
       await this.purgeExcessBackups(filePath);
     } catch {
     }
   }
   async purgeExcessBackups(filePath) {
-    const dir = path41.dirname(filePath);
-    const base = path41.basename(filePath);
+    const dir = path42.dirname(filePath);
+    const base = path42.basename(filePath);
     let entries;
     try {
-      entries = await fsp17.readdir(dir);
+      entries = await fsp18.readdir(dir);
     } catch {
       return;
     }
-    const backups = entries.filter((n) => n.startsWith(base) && n.endsWith(".bak")).map((n) => ({ name: n, filePath: path41.join(dir, n) })).sort((a, b) => {
+    const backups = entries.filter((n) => n.startsWith(base) && n.endsWith(".bak")).map((n) => ({ name: n, filePath: path42.join(dir, n) })).sort((a, b) => {
       return a.name.localeCompare(b.name);
     });
     const excess = backups.length - this.maxBackupCount;
     if (excess <= 0) return;
     await Promise.all(
-      backups.slice(0, excess).map((b) => fsp17.rm(b.filePath).catch(() => void 0))
+      backups.slice(0, excess).map((b) => fsp18.rm(b.filePath).catch(() => void 0))
     );
   }
   async write(filePath, payload) {
-    await fsp17.mkdir(path41.dirname(filePath), { recursive: true });
+    await fsp18.mkdir(path42.dirname(filePath), { recursive: true });
     const tmpPath = `${filePath}${TMP_SUFFIX2}`;
     const bytes = Buffer.from(JSON.stringify(payload, null, "	"), "utf8");
-    await fsp17.rm(tmpPath, { force: true });
-    const handle = await fsp17.open(tmpPath, "w", FILE_MODE2);
+    await fsp18.rm(tmpPath, { force: true });
+    const handle = await fsp18.open(tmpPath, "w", FILE_MODE2);
     try {
       await handle.writeFile(bytes);
       await handle.sync();
     } finally {
       await handle.close();
     }
-    await fsp17.rename(tmpPath, filePath);
-    await fsp17.chmod(filePath, FILE_MODE2).catch(() => void 0);
+    await fsp18.rename(tmpPath, filePath);
+    await fsp18.chmod(filePath, FILE_MODE2).catch(() => void 0);
   }
 };
 function coercePersistedToolbox(parsed) {
@@ -10223,7 +10608,7 @@ var ToolboxFileLock = class {
   constructor(filePath, timeoutMs, retryMs) {
     this.acquired = false;
     this.dirPath = `${filePath}.lock`;
-    this.pidFilePath = path41.join(this.dirPath, "pid");
+    this.pidFilePath = path42.join(this.dirPath, "pid");
     this.timeoutMs = timeoutMs;
     this.retryMs = retryMs;
   }
@@ -10231,15 +10616,15 @@ var ToolboxFileLock = class {
     const start = Date.now();
     while (true) {
       try {
-        await fsp17.mkdir(this.dirPath, { mode: LOCK_DIR_MODE2 });
-        await fsp17.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
+        await fsp18.mkdir(this.dirPath, { mode: LOCK_DIR_MODE2 });
+        await fsp18.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
         this.acquired = true;
         return;
       } catch (err) {
         if (!isNodeError2(err) || err.code !== "EEXIST") throw err;
         const stale = await this.isStaleLock();
         if (stale) {
-          await fsp17.rm(this.dirPath, { recursive: true, force: true });
+          await fsp18.rm(this.dirPath, { recursive: true, force: true });
           continue;
         }
         if (Date.now() - start >= this.timeoutMs) {
@@ -10252,11 +10637,11 @@ var ToolboxFileLock = class {
   async isStaleLock() {
     let pidStr;
     try {
-      pidStr = await fsp17.readFile(this.pidFilePath, "utf8");
+      pidStr = await fsp18.readFile(this.pidFilePath, "utf8");
     } catch {
       try {
-        const stat15 = await fsp17.stat(this.dirPath);
-        return Date.now() - stat15.mtimeMs > LOCK_STALE_GRACE_MS2;
+        const stat16 = await fsp18.stat(this.dirPath);
+        return Date.now() - stat16.mtimeMs > LOCK_STALE_GRACE_MS2;
       } catch {
         return false;
       }
@@ -10268,12 +10653,12 @@ var ToolboxFileLock = class {
   async release() {
     if (!this.acquired) return;
     this.acquired = false;
-    await fsp17.rm(this.dirPath, { recursive: true, force: true });
+    await fsp18.rm(this.dirPath, { recursive: true, force: true });
   }
 };
 function defaultWorkspacePath() {
   if (process.env.SERVICEME_NO_WORKSPACE_TOOLBOX === "1") return null;
-  return path41.join(process.cwd(), WORKSPACE_TOOLBOX_RELATIVE_PATH);
+  return path42.join(process.cwd(), WORKSPACE_TOOLBOX_RELATIVE_PATH);
 }
 var ToolboxStore = class {
   constructor(opts = {}) {
@@ -10362,7 +10747,7 @@ var ToolboxStore = class {
   async clear(scope) {
     const filePath = this.filePathFor(scope);
     if (!filePath) return;
-    await fsp17.rm(filePath, { force: true });
+    await fsp18.rm(filePath, { force: true });
   }
   /** Test seam — resolve the user-scope file path. */
   getUserFilePath() {
@@ -10623,13 +11008,16 @@ export {
   assertSafeRepoId,
   bootstrapDefaults,
   bootstrapPhase5Placeholders,
+  buildContentIdentity,
   buildCopilotCustomizationView,
   buildDefaultReposFile,
+  buildDisabledIdentityMatcher,
   buildGitHubLocalEmail,
   buildGitProxyBase,
   buildSignedHeaders,
   copilotDoctor,
   copilotPrompt,
+  coveredTargetsOf,
   createConsoleLogger,
   createCopilotAuthRequiredError,
   createCopilotNotInstalledError,
@@ -10640,10 +11028,13 @@ export {
   createPluginCatalogService,
   createProjectTools,
   createReposStore,
+  dedupeAdoptionsByPluginManifests,
   defaultRepoSchema as defaultRepoConfigSchema,
   deriveCopilotUserStatus,
   deriveInstallationId,
+  detectUnmanagedWorkspaceContent,
   ensureDefaultsInstalled,
+  findPluginCoveringArtifact,
   findPluginMcpJson,
   findRepoHooksJson,
   fingerprintSource,
@@ -10697,6 +11088,7 @@ export {
   narrowRepoConfig,
   noopLogger,
   parseAgentToolPermissions,
+  parseContentIdentity,
   parseHooksJson,
   parseMcpJson,
   randomInstallationId,
@@ -10713,6 +11105,7 @@ export {
   resolveTaskExecutionPayload,
   resolveWorkspaceContentPlan,
   setUserHomeOverrides,
+  setWorkspacePluginArtifactsDisabled,
   sortByRecentFirst,
   sortByUserOrder,
   supportsPersonalIntegrationKind,
@@ -10720,6 +11113,7 @@ export {
   toArtifactSummary,
   toFileUrl,
   touchLastUsedAt,
+  unmanagedDetectionSignature,
   unzipFile,
   upsertWorkspaceContentSelection,
   userRepoSchema as userRepoConfigSchema,