@serviceme/devtools-core 0.1.5 → 0.1.7

package/dist/index.js

@@ -30,6 +30,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AgentCatalogClient: () => AgentCatalogClient,
+  AgentReconciler: () => AgentReconciler,
+  AgentStore: () => AgentStore,
   DaemonLogger: () => DaemonLogger,
   EnvironmentInspector: () => EnvironmentInspector,
   GithubCopilotCliExecutor: () => GithubCopilotCliExecutor,
@@ -39,6 +42,10 @@ __export(index_exports, {
   ProjectTools: () => ProjectTools,
   SchedulerDaemon: () => SchedulerDaemon,
   ShellExecutor: () => ShellExecutor,
+  SkillCatalogClient: () => SkillCatalogClient,
+  SkillReconciler: () => SkillReconciler,
+  SkillStore: () => SkillStore,
+  TOOL_RISK_MAP: () => TOOL_RISK_MAP,
   TaskConfigManager: () => TaskConfigManager,
   TaskExecutionEngine: () => TaskExecutionEngine,
   TaskLogManager: () => TaskLogManager,
@@ -56,6 +63,7 @@ __export(index_exports, {
   matchesCron: () => matchesCron,
   moveFiles: () => moveFiles,
   noopLogger: () => noopLogger,
+  parseAgentToolPermissions: () => parseAgentToolPermissions,
   parseIntervalMs: () => parseIntervalMs,
   resolveTaskExecutionPayload: () => resolveTaskExecutionPayload,
   unzipFile: () => unzipFile,
@@ -63,8 +71,314 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/copilot/doctor.ts
+// src/agents/AgentCatalogClient.ts
 var import_devtools_protocol = require("@serviceme/devtools-protocol");
+var AgentCatalogClient = class {
+  constructor(options = {}) {
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.baseUrl = options.baseUrl;
+  }
+  async getCatalog() {
+    if (!this.baseUrl) {
+      return {
+        agents: [],
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    const response = await this.fetchImpl(
+      `${this.baseUrl}/api/v1/marketplace/agents`
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch agents catalog: ${response.status}`);
+    }
+    const data = await response.json();
+    return {
+      agents: data.agents ?? [],
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async downloadAgent(remoteId) {
+    if (!this.baseUrl) {
+      throw (0, import_devtools_protocol.createServicemeError)(
+        "workspace_not_found",
+        "Agent catalog baseUrl is not configured."
+      );
+    }
+    const response = await this.fetchImpl(
+      `${this.baseUrl}/api/v1/marketplace/agents/download/${remoteId}`
+    );
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw (0, import_devtools_protocol.createServicemeError)(
+          "not_found",
+          `Agent '${remoteId}' not found`
+        );
+      }
+      throw new Error(
+        `Failed to download agent ${remoteId}: ${response.status}`
+      );
+    }
+    const payload = await response.json();
+    return payload.data?.files ?? [];
+  }
+};
+
+// src/permissions/agent-permissions.ts
+var TOOL_RISK_MAP = {
+  shell: "high",
+  terminal: "high",
+  run_in_terminal: "high",
+  execution_subagent: "high",
+  filesystem: "medium",
+  fetch: "medium",
+  fetch_webpage: "medium",
+  create_file: "medium",
+  replace_string_in_file: "medium",
+  multi_replace_string_in_file: "medium",
+  read_file: "low",
+  search: "low",
+  grep_search: "low",
+  file_search: "low",
+  semantic_search: "low",
+  list_dir: "low"
+};
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---/;
+var TOOLS_LINE_REGEX = /^tools:\s*$/m;
+var TOOLS_INLINE_REGEX = /^tools:\s*\[([^\]]*)\]/m;
+var LIST_ITEM_REGEX = /^\s*-\s+(.+)$/;
+function parseAgentToolPermissions(content) {
+  const fmMatch = content.match(FRONTMATTER_REGEX);
+  if (!fmMatch?.[1]) return [];
+  const frontmatter = fmMatch[1];
+  const inlineMatch = frontmatter.match(TOOLS_INLINE_REGEX);
+  if (inlineMatch?.[1] != null) {
+    const raw = inlineMatch[1];
+    return raw.split(",").map((t) => t.trim()).filter(Boolean).map((tool) => ({
+      tool,
+      riskLevel: TOOL_RISK_MAP[tool] ?? "medium"
+    }));
+  }
+  const blockMatch = frontmatter.match(TOOLS_LINE_REGEX);
+  if (!blockMatch?.[0]) return [];
+  const toolsStartIndex = frontmatter.indexOf(blockMatch[0]) + blockMatch[0].length;
+  const remaining = frontmatter.slice(toolsStartIndex);
+  const lines = remaining.split(/\r?\n/);
+  const tools = [];
+  for (const line of lines) {
+    const itemMatch = line.match(LIST_ITEM_REGEX);
+    if (itemMatch?.[1]) {
+      const tool = itemMatch[1].trim();
+      tools.push({ tool, riskLevel: TOOL_RISK_MAP[tool] ?? "medium" });
+    } else if (line.trim() !== "" && !line.startsWith(" ") && !line.startsWith("	")) {
+      break;
+    }
+  }
+  return tools;
+}
+
+// src/agents/AgentReconciler.ts
+var AgentReconciler = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async mutate(request) {
+    if (request.targetScope !== "workspace" && request.targetScope !== "user") {
+      throw new Error(`Invalid target scope: ${String(request.targetScope)}`);
+    }
+    if (request.action === "uninstall" || request.action === "move" || request.action === "removeExternal") {
+      return {
+        status: "success",
+        changed: true,
+        message: `Agent ${request.action} completed.`
+      };
+    }
+    if (request.action !== "install") {
+      return {
+        status: "blocked",
+        changed: false,
+        message: `Agent action is not supported by bridge reconciler: ${request.action}`
+      };
+    }
+    const catalog = await this.deps.catalogClient.getCatalog();
+    const remoteAgent = catalog.agents.find(
+      (agent) => this.deps.agentStore.normalizeRemoteAgentId(agent.id) === request.agentId
+    );
+    if (!remoteAgent) {
+      return {
+        status: "blocked",
+        changed: false,
+        message: "Agent not found in catalog."
+      };
+    }
+    if (!request.confirmed && this.hasHighRiskTool(remoteAgent.tools)) {
+      return {
+        status: "requires_confirmation",
+        changed: false,
+        message: "This agent uses high-risk tools that require confirmation.",
+        tools: remoteAgent.tools
+      };
+    }
+    return {
+      status: "success",
+      changed: true,
+      message: "Agent installed."
+    };
+  }
+  getPermissionSummary(agentId, agentName, content) {
+    const tools = parseAgentToolPermissions(content);
+    return {
+      agentId,
+      agentName,
+      tools,
+      highRiskCount: tools.filter((tool) => tool.riskLevel === "high").length,
+      mediumRiskCount: tools.filter((tool) => tool.riskLevel === "medium").length,
+      lowRiskCount: tools.filter((tool) => tool.riskLevel === "low").length
+    };
+  }
+  hasHighRiskTool(tools) {
+    return tools.some((tool) => TOOL_RISK_MAP[tool] === "high");
+  }
+};
+
+// src/agents/AgentStore.ts
+var fs = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+var WORKSPACE_AGENTS_ROOT_RELATIVE = ".github/agents";
+var WORKSPACE_AGENTS_STATE_RELATIVE = ".github/.ms-devtools-agents.yml";
+var SAFE_LOCAL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function assertSafeLocalAgentId(agentId) {
+  if (typeof agentId !== "string" || agentId.length === 0 || agentId === "." || agentId === ".." || agentId.includes("/") || agentId.includes("\\") || !SAFE_LOCAL_ID_PATTERN.test(agentId)) {
+    throw new Error(`Invalid agent id: ${agentId}`);
+  }
+  return agentId;
+}
+var AgentStore = class {
+  constructor(options) {
+    this.workspacePath = options.workspacePath;
+    this.userAgentsRoot = options.userAgentsRoot;
+    this.fileSystem = options.fileSystem ?? fs;
+    this.schemaVersion = options.schemaVersion ?? 1;
+  }
+  normalizeRemoteAgentId(remoteId) {
+    if (remoteId.startsWith("official/")) {
+      return assertSafeLocalAgentId(remoteId.slice("official/".length));
+    }
+    if (remoteId.startsWith("community/")) {
+      const lastSlash = remoteId.lastIndexOf("/");
+      return assertSafeLocalAgentId(remoteId.slice(lastSlash + 1));
+    }
+    return assertSafeLocalAgentId(remoteId);
+  }
+  getWorkspaceAgentsRootPath() {
+    return WORKSPACE_AGENTS_ROOT_RELATIVE;
+  }
+  getWorkspaceStateFilePath() {
+    return WORKSPACE_AGENTS_STATE_RELATIVE;
+  }
+  getUserAgentsRootPath() {
+    return this.userAgentsRoot;
+  }
+  async listWorkspaceAgentIds() {
+    return this.listAgentIds(
+      path.join(this.workspacePath, WORKSPACE_AGENTS_ROOT_RELATIVE)
+    );
+  }
+  async listUserAgentIds() {
+    return this.listAgentIds(this.userAgentsRoot);
+  }
+  async readState() {
+    try {
+      const raw = await this.fileSystem.readFile(
+        path.join(this.workspacePath, WORKSPACE_AGENTS_STATE_RELATIVE),
+        "utf-8"
+      );
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.schemaVersion !== "number" || !Array.isArray(parsed.installedAgents)) {
+        return null;
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  async writeState(state) {
+    const statePath = path.join(
+      this.workspacePath,
+      WORKSPACE_AGENTS_STATE_RELATIVE
+    );
+    await this.fileSystem.mkdir(path.dirname(statePath), { recursive: true });
+    await this.fileSystem.writeFile(
+      statePath,
+      JSON.stringify(state, null, 2),
+      "utf-8"
+    );
+  }
+  async addInstalledAgent(entry) {
+    const state = await this.readState() ?? {
+      schemaVersion: this.schemaVersion,
+      installedAgents: []
+    };
+    state.installedAgents = state.installedAgents.filter(
+      (agent) => agent.id !== entry.id
+    );
+    state.installedAgents.push(entry);
+    await this.writeState(state);
+  }
+  async removeInstalledAgent(agentId) {
+    const state = await this.readState();
+    if (!state) {
+      return;
+    }
+    state.installedAgents = state.installedAgents.filter(
+      (agent) => agent.id !== agentId
+    );
+    await this.writeState(state);
+  }
+  async writeAgentFiles(agentId, scope, files) {
+    const root = scope === "workspace" ? path.join(this.workspacePath, WORKSPACE_AGENTS_ROOT_RELATIVE) : this.userAgentsRoot;
+    const firstFile = files[0];
+    const isSingleFlatFile = files.length === 1 && firstFile !== void 0 && firstFile.path === `${agentId}.agent.md` && !firstFile.path.includes("/");
+    const targetDir = isSingleFlatFile ? root : path.join(root, agentId);
+    await this.fileSystem.mkdir(targetDir, { recursive: true });
+    for (const file of files) {
+      const filePath = path.join(targetDir, file.path);
+      await this.fileSystem.mkdir(path.dirname(filePath), { recursive: true });
+      await this.fileSystem.writeFile(filePath, file.content, "utf-8");
+      if (file.executable) {
+        try {
+          await this.fileSystem.chmod(filePath, 493);
+        } catch {
+        }
+      }
+    }
+  }
+  async listAgentIds(dir) {
+    try {
+      const entries = await this.fileSystem.readdir(dir, {
+        withFileTypes: true
+      });
+      const ids = [];
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          ids.push(entry.name);
+          continue;
+        }
+        if (entry.isFile() && entry.name.endsWith(".agent.md")) {
+          ids.push(entry.name.replace(/\.agent\.md$/, ""));
+        }
+      }
+      return ids.sort();
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/copilot/doctor.ts
+var import_devtools_protocol2 = require("@serviceme/devtools-protocol");
 
 // src/process/runCommand.ts
 var import_node_child_process = require("child_process");
@@ -208,20 +522,20 @@ async function copilotDoctor() {
   return { installed: true, version, authenticated };
 }
 function createCopilotNotInstalledError() {
-  return (0, import_devtools_protocol.createServicemeError)(
-    import_devtools_protocol.COPILOT_ERROR_CODES.NOT_INSTALLED,
+  return (0, import_devtools_protocol2.createServicemeError)(
+    import_devtools_protocol2.COPILOT_ERROR_CODES.NOT_INSTALLED,
     "GitHub Copilot CLI is not installed. Visit https://docs.github.com/en/copilot/using-github-copilot/using-github-copilot-in-the-command-line to install."
   );
 }
 function createCopilotAuthRequiredError() {
-  return (0, import_devtools_protocol.createServicemeError)(
-    import_devtools_protocol.COPILOT_ERROR_CODES.AUTH_REQUIRED,
+  return (0, import_devtools_protocol2.createServicemeError)(
+    import_devtools_protocol2.COPILOT_ERROR_CODES.AUTH_REQUIRED,
     "GitHub Copilot CLI requires authentication. Run `copilot auth login` to sign in."
   );
 }
 
 // src/copilot/prompt.ts
-var import_devtools_protocol2 = require("@serviceme/devtools-protocol");
+var import_devtools_protocol3 = require("@serviceme/devtools-protocol");
 var COPILOT_COMMAND2 = "copilot";
 var DEFAULT_TIMEOUT_MS = 12e4;
 function stripAnsi(text) {
@@ -255,8 +569,8 @@ async function copilotPrompt(options) {
     });
     const output = stripAnsi(result.stdout);
     if (output.includes("I'm sorry, but I cannot assist") && result.stderr?.includes("Stream completed without a response")) {
-      throw (0, import_devtools_protocol2.createServicemeError)(
-        import_devtools_protocol2.COPILOT_ERROR_CODES.AUTH_REQUIRED,
+      throw (0, import_devtools_protocol3.createServicemeError)(
+        import_devtools_protocol3.COPILOT_ERROR_CODES.AUTH_REQUIRED,
         "Copilot CLI returned a refusal response. This typically indicates an expired authentication token. Run `gh auth login` to re-authenticate.",
         { exitCode: 0, output, stderr: result.stderr }
       );
@@ -265,8 +579,8 @@ async function copilotPrompt(options) {
   } catch (error) {
     const err = error;
     if (err.code === "ETIMEDOUT") {
-      throw (0, import_devtools_protocol2.createServicemeError)(
-        import_devtools_protocol2.COPILOT_ERROR_CODES.TIMEOUT,
+      throw (0, import_devtools_protocol3.createServicemeError)(
+        import_devtools_protocol3.COPILOT_ERROR_CODES.TIMEOUT,
         `Copilot prompt timed out after ${String(timeout)}ms.`
       );
     }
@@ -274,8 +588,8 @@ async function copilotPrompt(options) {
     const output = stripAnsi(err.stdout ?? "");
     const stderr = err.stderr ?? err.message ?? "";
     if (output.includes("I'm sorry, but I cannot assist") || stderr.includes("Stream completed without a response")) {
-      throw (0, import_devtools_protocol2.createServicemeError)(
-        import_devtools_protocol2.COPILOT_ERROR_CODES.AUTH_REQUIRED,
+      throw (0, import_devtools_protocol3.createServicemeError)(
+        import_devtools_protocol3.COPILOT_ERROR_CODES.AUTH_REQUIRED,
         "Copilot CLI returned a refusal response. This typically indicates an expired authentication token. Run `gh auth login` to re-authenticate.",
         { exitCode, output, stderr }
       );
@@ -283,8 +597,8 @@ async function copilotPrompt(options) {
     if (exitCode !== 0 && output) {
       return { output, exitCode };
     }
-    throw (0, import_devtools_protocol2.createServicemeError)(
-      import_devtools_protocol2.COPILOT_ERROR_CODES.EXECUTION_FAILED,
+    throw (0, import_devtools_protocol3.createServicemeError)(
+      import_devtools_protocol3.COPILOT_ERROR_CODES.EXECUTION_FAILED,
       stderr || `Copilot exited with code ${String(exitCode)}.`,
       { exitCode, stderr }
     );
@@ -292,19 +606,25 @@ async function copilotPrompt(options) {
 }
 
 // src/env/environmentInspector.ts
-var import_devtools_protocol3 = require("@serviceme/devtools-protocol");
+var import_devtools_protocol4 = require("@serviceme/devtools-protocol");
 var DEFAULT_TOOL_CHECK_TIMEOUT_MS = 5e3;
 var TOOL_CHECK_TIMEOUT_MS = {
   nuget: 12e3,
   nvm: 8e3,
-  dotnet: 8e3
+  dotnet: 8e3,
+  // nvm4w/npm shims and globally-installed .cmd tools (pnpm, nrm) are slow to
+  // resolve on cold PATHs. Give them extra headroom so the version probe
+  // doesn't fall through to the generic 5s default.
+  npm: 15e3,
+  pnpm: 15e3,
+  nrm: 15e3
 };
 var ERROR_CODE_NOT_FOUND = 127;
 var ERROR_CODE_TIMEOUT = "ETIMEDOUT";
 var EnvironmentInspector = class {
   async checkEnvironment() {
     const results = await Promise.all(
-      import_devtools_protocol3.KNOWN_ENVIRONMENT_TOOLS.map(
+      import_devtools_protocol4.KNOWN_ENVIRONMENT_TOOLS.map(
         async (tool) => [tool, await this.checkTool(tool)]
       )
     );
@@ -312,7 +632,7 @@ var EnvironmentInspector = class {
   }
   async checkTool(toolName) {
     if (!/^[a-zA-Z0-9-]+$/.test(toolName)) {
-      throw (0, import_devtools_protocol3.createServicemeError)("invalid_params", "Invalid tool name.");
+      throw (0, import_devtools_protocol4.createServicemeError)("invalid_params", "Invalid tool name.");
     }
     try {
       if (toolName === "nvm") {
@@ -344,8 +664,29 @@ var EnvironmentInspector = class {
       return void 0;
     }
   }
+  /**
+   * On Windows, prefer the `.cmd` shim for npm/pnpm/nrm. nvm4w registers
+   * BOTH an extensionless entry (pointing to node.exe) and a `<tool>.cmd`
+   * wrapper; `where` returns them in that order, and the extensionless one
+   * would just print node's own version.
+   */
+  async getToolShimPath(toolName) {
+    try {
+      const result = await runCommand("where", {
+        args: [toolName],
+        timeoutMs: this.getToolTimeout(toolName)
+      });
+      const candidates = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+      const cmdShim = candidates.find(
+        (line) => line.toLowerCase().endsWith(".cmd")
+      );
+      return cmdShim ?? candidates[0];
+    } catch {
+      return void 0;
+    }
+  }
   async getToolVersion(toolName) {
-    const invocation = this.getVersionInvocation(toolName);
+    const invocation = await this.getVersionInvocation(toolName);
     const result = await runCommand(invocation.command, {
       args: invocation.args,
       timeoutMs: this.getToolTimeout(toolName)
@@ -420,12 +761,19 @@ var EnvironmentInspector = class {
       return this.handleToolCheckError(error);
     }
   }
-  getVersionInvocation(toolName) {
+  async getVersionInvocation(toolName) {
     const isWindows = process.platform === "win32";
     if (isWindows && ["npm", "pnpm", "nrm"].includes(toolName)) {
+      const shim = await this.getToolShimPath(toolName);
+      if (shim) {
+        return {
+          command: "cmd.exe",
+          args: ["/c", shim, "--version"]
+        };
+      }
       return {
         command: "cmd.exe",
-        args: ["/d", "/s", "/c", `${toolName} --version`]
+        args: ["/c", toolName, "--version"]
       };
     }
     const commands = {
@@ -468,7 +816,7 @@ var EnvironmentInspector = class {
     const execError = error;
     const message = execError.message || String(error);
     const code = execError.code;
-    const isNotFound = message.includes("command not found") || message.includes("not recognized") || message.includes("ENOENT") || code === "ENOENT" || code === ERROR_CODE_NOT_FOUND;
+    const isNotFound = message.includes("command not found") || message.includes("not recognized") || message.includes("ENOENT") || message.includes("EACCES") || code === "ENOENT" || code === "EACCES" || code === ERROR_CODE_NOT_FOUND;
     const isTimeout = code === ERROR_CODE_TIMEOUT || message.toLowerCase().includes("timed out");
     return {
       installed: false,
@@ -478,9 +826,9 @@ var EnvironmentInspector = class {
 };
 
 // src/image/imageTools.ts
-var fs = __toESM(require("fs/promises"));
-var path = __toESM(require("path"));
-var import_devtools_protocol4 = require("@serviceme/devtools-protocol");
+var fs2 = __toESM(require("fs/promises"));
+var path2 = __toESM(require("path"));
+var import_devtools_protocol5 = require("@serviceme/devtools-protocol");
 var SUPPORTED_FORMATS = [
   ".jpg",
   ".jpeg",
@@ -500,7 +848,7 @@ var ImageTools = class {
       if (!await this.pathExists(filePath)) {
         return { valid: false };
       }
-      if (!SUPPORTED_FORMATS.includes(path.extname(filePath).toLowerCase())) {
+      if (!SUPPORTED_FORMATS.includes(path2.extname(filePath).toLowerCase())) {
         return { valid: false };
       }
       await this.getInfo(filePath, sharpModulePath);
@@ -512,7 +860,7 @@ var ImageTools = class {
   async getInfo(imagePath, sharpModulePath) {
     const sharp = this.loadSharp(sharpModulePath);
     const metadata = await sharp(imagePath).metadata();
-    const stats = await fs.stat(imagePath);
+    const stats = await fs2.stat(imagePath);
     return {
       width: metadata.width ?? 0,
       height: metadata.height ?? 0,
@@ -524,12 +872,12 @@ var ImageTools = class {
   async compress(imagePath, options) {
     const validation = await this.validate(imagePath, options.sharpModulePath);
     if (!validation.valid) {
-      throw (0, import_devtools_protocol4.createServicemeError)(
+      throw (0, import_devtools_protocol5.createServicemeError)(
         "invalid_params",
         `Invalid image file: ${imagePath}`
       );
     }
-    const originalStats = await fs.stat(imagePath);
+    const originalStats = await fs2.stat(imagePath);
     const originalSize = originalStats.size;
     const outputPath = this.getOutputPath(imagePath, options);
     const compressedBuffer = await this.compressWithSharp(imagePath, options);
@@ -544,7 +892,7 @@ var ImageTools = class {
         outputPath: imagePath
       };
     }
-    await fs.writeFile(outputPath, compressedBuffer);
+    await fs2.writeFile(outputPath, compressedBuffer);
     return {
       originalSize,
       compressedSize,
@@ -555,7 +903,7 @@ var ImageTools = class {
   async compressWithSharp(imagePath, options) {
     const sharp = this.loadSharp(options.sharpModulePath);
     let pipeline = sharp(imagePath);
-    switch (options.format ?? path.extname(imagePath).toLowerCase().slice(1)) {
+    switch (options.format ?? path2.extname(imagePath).toLowerCase().slice(1)) {
       case "jpg":
       case "jpeg":
         pipeline = pipeline.jpeg({ quality: options.quality });
@@ -581,14 +929,14 @@ var ImageTools = class {
     if (options.replaceOriginImage) {
       return inputPath;
     }
-    const dir = path.dirname(inputPath);
-    const ext = path.extname(inputPath);
-    const name = path.basename(inputPath, ext);
-    return path.join(dir, `${name}_compressed${ext}`);
+    const dir = path2.dirname(inputPath);
+    const ext = path2.extname(inputPath);
+    const name = path2.basename(inputPath, ext);
+    return path2.join(dir, `${name}_compressed${ext}`);
   }
   async pathExists(targetPath) {
     try {
-      await fs.access(targetPath);
+      await fs2.access(targetPath);
       return true;
     } catch {
       return false;
@@ -598,7 +946,7 @@ var ImageTools = class {
     try {
       return sharpModulePath ? require(sharpModulePath) : require("sharp");
     } catch (error) {
-      throw (0, import_devtools_protocol4.createServicemeError)(
+      throw (0, import_devtools_protocol5.createServicemeError)(
         "internal_error",
         `sharp is required for image operations: ${error instanceof Error ? error.message : String(error)}`
       );
@@ -610,13 +958,13 @@ function createImageTools() {
 }
 
 // src/json/jsonTools.ts
-var import_devtools_protocol5 = require("@serviceme/devtools-protocol");
+var import_devtools_protocol6 = require("@serviceme/devtools-protocol");
 var import_comment_json = require("comment-json");
 var import_json5 = __toESM(require("json5"));
 function createJsonTools() {
   return {
     sort(text, options) {
-      const finalOptions = { ...import_devtools_protocol5.DEFAULT_JSON_SORT_OPTIONS, ...options };
+      const finalOptions = { ...import_devtools_protocol6.DEFAULT_JSON_SORT_OPTIONS, ...options };
       const json = parseJson(text);
       const sorted = sortObject(json, finalOptions);
       return JSON.stringify(sorted, null, detectIndent(text));
@@ -652,7 +1000,7 @@ function parseJson(text) {
     } catch {
     }
   }
-  throw (0, import_devtools_protocol5.createServicemeError)("json_invalid_input", "Invalid JSON format.");
+  throw (0, import_devtools_protocol6.createServicemeError)("json_invalid_input", "Invalid JSON format.");
 }
 function sortObject(obj, options) {
   if (Array.isArray(obj)) {
@@ -744,9 +1092,9 @@ function createConsoleLogger(prefix = "serviceme") {
 }
 
 // src/project/projectTools.ts
-var fs2 = __toESM(require("fs/promises"));
-var path2 = __toESM(require("path"));
-var import_devtools_protocol6 = require("@serviceme/devtools-protocol");
+var fs3 = __toESM(require("fs/promises"));
+var path3 = __toESM(require("path"));
+var import_devtools_protocol7 = require("@serviceme/devtools-protocol");
 
 // src/utils/fileUtils.ts
 var import_node_fs = require("fs");
@@ -866,10 +1214,10 @@ var moveFiles = async (sourceDir, destDir, overwrite = false) => {
 var ProjectTools = class {
   async extractTemplate(zipPath, workspacePath, tempExtractDir, input) {
     await unzipFile(zipPath, tempExtractDir);
-    let sourceDir = path2.join(tempExtractDir, input.extractedDirName);
+    let sourceDir = path3.join(tempExtractDir, input.extractedDirName);
     let actualDirName = input.extractedDirName;
     if (!await this.pathExists(sourceDir)) {
-      const entries = await fs2.readdir(tempExtractDir, { withFileTypes: true });
+      const entries = await fs3.readdir(tempExtractDir, { withFileTypes: true });
       const directories = entries.filter(
         (entry) => entry.isDirectory() && !entry.name.startsWith(".")
       );
@@ -881,7 +1229,7 @@ var ProjectTools = class {
       );
       if (selectedDirectory) {
         actualDirName = selectedDirectory;
-        sourceDir = path2.join(tempExtractDir, actualDirName);
+        sourceDir = path3.join(tempExtractDir, actualDirName);
       } else if (directories.length === 0) {
         throw new Error(
           `No directory found after extraction. Expected directory: ${input.extractedDirName}`
@@ -902,7 +1250,7 @@ var ProjectTools = class {
   }
   async installDependencies(workspacePath, command) {
     if (!command) {
-      throw (0, import_devtools_protocol6.createServicemeError)("invalid_params", "Expected install command.");
+      throw (0, import_devtools_protocol7.createServicemeError)("invalid_params", "Expected install command.");
     }
     await runCommand(command, {
       cwd: workspacePath,
@@ -939,7 +1287,7 @@ var ProjectTools = class {
     } else {
       for (const scriptPath of scripts) {
         try {
-          await fs2.chmod(scriptPath, 493);
+          await fs3.chmod(scriptPath, 493);
           updatedCount += 1;
         } catch {
         }
@@ -965,13 +1313,16 @@ var ProjectTools = class {
   }
   async runScaffoldPrune(workspacePath, preset) {
     if (!preset) {
-      throw (0, import_devtools_protocol6.createServicemeError)("invalid_params", "Expected scaffold preset.");
+      throw (0, import_devtools_protocol7.createServicemeError)("invalid_params", "Expected scaffold preset.");
     }
-    const commands = [
-      `pnpm run scaffold:prune -- --preset ${preset} --project-root .`,
-      `pnpm run scaffold:init-metadata -- --preset ${preset} --project-root . --force`
-    ];
+    await this.ensurePresetManifest(workspacePath, preset);
+    const pruneCommand = `pnpm run scaffold:prune -- --preset ${preset} --project-root .`;
+    const initMetadataCommand = `pnpm run scaffold:init-metadata -- --preset ${preset} --project-root . --force`;
+    const commands = [pruneCommand, initMetadataCommand];
     for (const command of commands) {
+      if (command === initMetadataCommand) {
+        await this.ensurePresetManifest(workspacePath, preset);
+      }
       await runCommand(command, {
         cwd: workspacePath,
         shell: true
@@ -983,16 +1334,54 @@ var ProjectTools = class {
       commands
     };
   }
+  async ensurePresetManifest(workspacePath, preset) {
+    const presetManifestPath = path3.join(
+      workspacePath,
+      ".ms-scaffold",
+      "presets",
+      `${preset}.json`
+    );
+    if (await this.pathExists(presetManifestPath)) {
+      return;
+    }
+    const projectModePath = path3.join(
+      workspacePath,
+      ".ms-scaffold",
+      "project-mode.json"
+    );
+    if (!await this.pathExists(projectModePath)) {
+      return;
+    }
+    const projectModeRaw = await fs3.readFile(projectModePath, "utf8");
+    const projectMode = JSON.parse(projectModeRaw);
+    const synthesizedPreset = {
+      preset,
+      selectedModules: Array.isArray(projectMode.selectedModules) ? projectMode.selectedModules : [],
+      prunedModules: Array.isArray(projectMode.prunedModules) ? projectMode.prunedModules : [],
+      exclude: [],
+      recommendedFollowUps: [],
+      managedFiles: [],
+      mergeManagedFiles: [],
+      userOwnedPaths: []
+    };
+    await fs3.mkdir(path3.dirname(presetManifestPath), { recursive: true });
+    await fs3.writeFile(
+      presetManifestPath,
+      `${JSON.stringify(synthesizedPreset, null, 2)}
+`,
+      "utf8"
+    );
+  }
   async findScripts(dir, extensions) {
     const results = [];
     let entries;
     try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
+      entries = await fs3.readdir(dir, { withFileTypes: true });
     } catch {
       return results;
     }
     for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
+      const fullPath = path3.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))) {
@@ -1003,7 +1392,7 @@ var ProjectTools = class {
   }
   async pathExists(targetPath) {
     try {
-      await fs2.access(targetPath);
+      await fs3.access(targetPath);
       return true;
     } catch {
       return false;
@@ -1022,7 +1411,7 @@ var ProjectTools = class {
     const matches = [];
     for (const directoryName of directoryNames) {
       if (await this.directoryMatchesProjectPattern(
-        path2.join(tempExtractDir, directoryName),
+        path3.join(tempExtractDir, directoryName),
         projectFilePattern
       )) {
         matches.push(directoryName);
@@ -1034,7 +1423,7 @@ var ProjectTools = class {
     return null;
   }
   async directoryMatchesProjectPattern(directoryPath, projectFilePattern) {
-    const entries = await fs2.readdir(directoryPath);
+    const entries = await fs3.readdir(directoryPath);
     if (projectFilePattern.includes("*")) {
       const regex = new RegExp(`^${projectFilePattern.replace("*", ".*")}$`);
       return entries.some((entry) => regex.test(entry));
@@ -1047,17 +1436,17 @@ function createProjectTools() {
 }
 
 // src/scheduled-tasks/daemon/DaemonLogger.ts
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
 var CONFIG_DIR = ".serviceme";
 var LOG_FILE = "scheduler.log";
 var MAX_LOG_SIZE = 1024 * 1024;
 var DaemonLogger = class {
   constructor(workspacePath) {
-    this.logPath = path3.join(workspacePath, CONFIG_DIR, LOG_FILE);
-    const dir = path3.dirname(this.logPath);
-    if (!fs3.existsSync(dir)) {
-      fs3.mkdirSync(dir, { recursive: true });
+    this.logPath = path4.join(workspacePath, CONFIG_DIR, LOG_FILE);
+    const dir = path4.dirname(this.logPath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
     }
   }
   getLogPath() {
@@ -1068,16 +1457,16 @@ var DaemonLogger = class {
     const line = `[${ts}] [${level.toUpperCase()}] ${message}
 `;
     this.rotateIfNeeded();
-    fs3.appendFileSync(this.logPath, line, "utf-8");
+    fs4.appendFileSync(this.logPath, line, "utf-8");
   }
   rotateIfNeeded() {
     try {
-      const stats = fs3.statSync(this.logPath);
+      const stats = fs4.statSync(this.logPath);
       if (stats.size > MAX_LOG_SIZE) {
-        const content = fs3.readFileSync(this.logPath, "utf-8");
+        const content = fs4.readFileSync(this.logPath, "utf-8");
         const halfIdx = content.indexOf("\n", Math.floor(content.length / 2));
         if (halfIdx > 0) {
-          fs3.writeFileSync(this.logPath, content.slice(halfIdx + 1), "utf-8");
+          fs4.writeFileSync(this.logPath, content.slice(halfIdx + 1), "utf-8");
         }
       }
     } catch {
@@ -1086,33 +1475,33 @@ var DaemonLogger = class {
 };
 
 // src/scheduled-tasks/daemon/PidManager.ts
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 var CONFIG_DIR2 = ".serviceme";
 var PID_FILE = "scheduler.pid";
 var PidManager = class {
   constructor(workspacePath) {
-    this.pidPath = path4.join(workspacePath, CONFIG_DIR2, PID_FILE);
+    this.pidPath = path5.join(workspacePath, CONFIG_DIR2, PID_FILE);
   }
   getPidPath() {
     return this.pidPath;
   }
   writePid(pid) {
-    const dir = path4.dirname(this.pidPath);
-    if (!fs4.existsSync(dir)) {
-      fs4.mkdirSync(dir, { recursive: true });
+    const dir = path5.dirname(this.pidPath);
+    if (!fs5.existsSync(dir)) {
+      fs5.mkdirSync(dir, { recursive: true });
     }
-    fs4.writeFileSync(this.pidPath, String(pid), "utf-8");
+    fs5.writeFileSync(this.pidPath, String(pid), "utf-8");
   }
   readPid() {
-    if (!fs4.existsSync(this.pidPath)) return null;
-    const raw = fs4.readFileSync(this.pidPath, "utf-8").trim();
+    if (!fs5.existsSync(this.pidPath)) return null;
+    const raw = fs5.readFileSync(this.pidPath, "utf-8").trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isNaN(pid) ? null : pid;
   }
   removePid() {
-    if (fs4.existsSync(this.pidPath)) {
-      fs4.unlinkSync(this.pidPath);
+    if (fs5.existsSync(this.pidPath)) {
+      fs5.unlinkSync(this.pidPath);
     }
   }
   isProcessRunning(pid) {
@@ -1133,12 +1522,12 @@ var PidManager = class {
 };
 
 // src/scheduled-tasks/daemon/SchedulerDaemon.ts
-var fs9 = __toESM(require("fs"));
+var fs10 = __toESM(require("fs"));
 var os = __toESM(require("os"));
 
 // src/scheduled-tasks/executors/GithubCopilotCliExecutor.ts
 var import_node_child_process2 = require("child_process");
-var fs5 = __toESM(require("fs"));
+var fs6 = __toESM(require("fs"));
 
 // src/scheduled-tasks/executors/timeout.ts
 function resolveConfiguredTimeoutMs(timeoutSeconds, defaultTimeoutMs) {
@@ -1173,7 +1562,7 @@ function redactArgs(args) {
 function writeDiagnostic(message) {
   const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
   if (logPath) {
-    fs5.appendFileSync(logPath, message);
+    fs6.appendFileSync(logPath, message);
     return;
   }
   process.stderr.write(message);
@@ -1383,15 +1772,15 @@ ${body}`.trim()
 
 // src/scheduled-tasks/executors/ShellExecutor.ts
 var import_node_child_process3 = require("child_process");
-var fs6 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var MAX_OUTPUT_BYTES2 = 1024 * 1024;
 var DEFAULT_TIMEOUT_MS4 = 6e4;
 var POSIX_SHELL_CANDIDATES = ["bash.exe", "sh.exe"];
 function resolveShellExecution(script, options = {}) {
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
-  const fileExists = options.fileExists ?? fs6.existsSync;
+  const fileExists = options.fileExists ?? fs7.existsSync;
   if (platform === "win32") {
     const posixShell = usesPosixShellSyntax(script) ? findWindowsPosixShell(env, fileExists) : null;
     if (posixShell) {
@@ -1436,10 +1825,10 @@ function findWindowsPosixShell(env, fileExists) {
     if (fileExists(candidate)) return candidate;
   }
   const pathValue = env.Path ?? env.PATH ?? "";
-  for (const dir of pathValue.split(path5.win32.delimiter)) {
+  for (const dir of pathValue.split(path6.win32.delimiter)) {
     if (!dir) continue;
     for (const executable of POSIX_SHELL_CANDIDATES) {
-      const candidate = path5.win32.join(dir, executable);
+      const candidate = path6.win32.join(dir, executable);
       if (fileExists(candidate) && !isWindowsWslLauncher(candidate)) {
         return candidate;
       }
@@ -1448,13 +1837,13 @@ function findWindowsPosixShell(env, fileExists) {
   return null;
 }
 function isWindowsWslLauncher(candidate) {
-  const normalized = path5.win32.normalize(candidate).toLowerCase();
+  const normalized = path6.win32.normalize(candidate).toLowerCase();
   return normalized.endsWith("\\windows\\system32\\bash.exe") || normalized.endsWith("\\windows\\syswow64\\bash.exe");
 }
 function writeDiagnostic2(message) {
   const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
   if (logPath) {
-    fs6.appendFileSync(logPath, message);
+    fs7.appendFileSync(logPath, message);
     return;
   }
   process.stderr.write(message);
@@ -1601,9 +1990,9 @@ function getExecutor(taskType) {
 
 // src/scheduled-tasks/TaskConfigManager.ts
 var import_node_crypto = require("crypto");
-var fs7 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
-var import_devtools_protocol7 = require("@serviceme/devtools-protocol");
+var fs8 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var import_devtools_protocol8 = require("@serviceme/devtools-protocol");
 var CONFIG_DIR3 = ".serviceme";
 var CONFIG_FILE = "scheduled-tasks.json";
 function emptyConfig() {
@@ -1614,7 +2003,7 @@ function isRecord(value) {
 }
 function requireNonEmptyString(payload, field, taskType) {
   if (!isRecord(payload) || typeof payload[field] !== "string" || !payload[field].trim()) {
-    throw (0, import_devtools_protocol7.createServicemeError)(
+    throw (0, import_devtools_protocol8.createServicemeError)(
       "invalid_payload",
       `${taskType} payload ${field} is required`
     );
@@ -1639,27 +2028,27 @@ function validateTaskPayload(taskType, payload) {
 }
 var TaskConfigManager = class {
   constructor(workspacePath) {
-    this.configPath = path6.join(workspacePath, CONFIG_DIR3, CONFIG_FILE);
+    this.configPath = path7.join(workspacePath, CONFIG_DIR3, CONFIG_FILE);
   }
   getConfigPath() {
     return this.configPath;
   }
   readConfig() {
-    if (!fs7.existsSync(this.configPath)) {
+    if (!fs8.existsSync(this.configPath)) {
       return emptyConfig();
     }
-    const raw = fs7.readFileSync(this.configPath, "utf-8");
+    const raw = fs8.readFileSync(this.configPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   }
   writeConfig(config) {
-    const dir = path6.dirname(this.configPath);
-    if (!fs7.existsSync(dir)) {
-      fs7.mkdirSync(dir, { recursive: true });
+    const dir = path7.dirname(this.configPath);
+    if (!fs8.existsSync(dir)) {
+      fs8.mkdirSync(dir, { recursive: true });
     }
     const tmp = `${this.configPath}.tmp`;
-    fs7.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
-    fs7.renameSync(tmp, this.configPath);
+    fs8.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
+    fs8.renameSync(tmp, this.configPath);
   }
   listTasks() {
     return this.readConfig().tasks;
@@ -1930,8 +2319,8 @@ var TaskExecutionEngine = class {
 
 // src/scheduled-tasks/TaskLogManager.ts
 var import_node_crypto2 = require("crypto");
-var fs8 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var CONFIG_DIR4 = ".serviceme";
 var LOG_FILE2 = "scheduled-tasks-log.json";
 var MAX_LOGS = 200;
@@ -1956,17 +2345,17 @@ function validateAndRepairLogFile(raw) {
 }
 var TaskLogManager = class {
   constructor(workspacePath) {
-    this.logPath = path7.join(workspacePath, CONFIG_DIR4, LOG_FILE2);
+    this.logPath = path8.join(workspacePath, CONFIG_DIR4, LOG_FILE2);
   }
   getLogPath() {
     return this.logPath;
   }
   readLogFile() {
-    if (!fs8.existsSync(this.logPath)) {
+    if (!fs9.existsSync(this.logPath)) {
       return emptyLogFile();
     }
     try {
-      const raw = fs8.readFileSync(this.logPath, "utf-8");
+      const raw = fs9.readFileSync(this.logPath, "utf-8");
       const parsed = JSON.parse(raw);
       const file = validateAndRepairLogFile(parsed);
       if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.logs) || parsed.logs.length !== file.logs.length) {
@@ -1982,21 +2371,21 @@ var TaskLogManager = class {
   }
   backupCorruptedFile() {
     try {
-      if (fs8.existsSync(this.logPath)) {
+      if (fs9.existsSync(this.logPath)) {
         const backupPath = `${this.logPath}.corrupted.${Date.now()}`;
-        fs8.copyFileSync(this.logPath, backupPath);
+        fs9.copyFileSync(this.logPath, backupPath);
       }
     } catch {
     }
   }
   writeLogFile(file) {
-    const dir = path7.dirname(this.logPath);
-    if (!fs8.existsSync(dir)) {
-      fs8.mkdirSync(dir, { recursive: true });
+    const dir = path8.dirname(this.logPath);
+    if (!fs9.existsSync(dir)) {
+      fs9.mkdirSync(dir, { recursive: true });
     }
     const tmp = `${this.logPath}.tmp`;
-    fs8.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
-    fs8.renameSync(tmp, this.logPath);
+    fs9.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
+    fs9.renameSync(tmp, this.logPath);
   }
   appendLog(input) {
     const file = this.readLogFile();
@@ -2107,8 +2496,8 @@ var SchedulerDaemon = class {
     const configPath = this.configManager.getConfigPath();
     const dir = configPath.substring(0, configPath.lastIndexOf("/"));
     try {
-      if (fs9.existsSync(dir)) {
-        this.watcher = fs9.watch(dir, (_eventType, filename) => {
+      if (fs10.existsSync(dir)) {
+        this.watcher = fs10.watch(dir, (_eventType, filename) => {
           if (filename === "scheduled-tasks.json") {
             this.logger.log("info", "Config file changed, reconciling...");
           }
@@ -2260,8 +2649,215 @@ function matchCronField(field, value) {
   const values = field.split(",");
   return values.some((v) => Number.parseInt(v, 10) === value);
 }
+
+// src/skills/SkillCatalogClient.ts
+var import_devtools_protocol9 = require("@serviceme/devtools-protocol");
+var SkillCatalogClient = class {
+  constructor(options = {}) {
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.baseUrl = options.baseUrl;
+  }
+  async getCatalog() {
+    if (!this.baseUrl) {
+      return {
+        skills: [],
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    const response = await this.fetchImpl(
+      `${this.baseUrl}/api/v1/marketplace/skills`
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch skills catalog: ${response.status}`);
+    }
+    const data = await response.json();
+    return {
+      skills: data.skills ?? [],
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async downloadSkill(remoteId) {
+    if (!this.baseUrl) {
+      throw (0, import_devtools_protocol9.createServicemeError)(
+        "workspace_not_found",
+        "Skill catalog baseUrl is not configured."
+      );
+    }
+    const response = await this.fetchImpl(
+      `${this.baseUrl}/api/v1/marketplace/skills/download/${remoteId}`
+    );
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw (0, import_devtools_protocol9.createServicemeError)(
+          "not_found",
+          `Skill '${remoteId}' not found`
+        );
+      }
+      throw new Error(
+        `Failed to download skill ${remoteId}: ${response.status}`
+      );
+    }
+    const payload = await response.json();
+    return payload.data?.files ?? [];
+  }
+};
+
+// src/skills/SkillReconciler.ts
+var SkillReconciler = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async mutate(request) {
+    if (request.targetScope !== "workspace" && request.targetScope !== "user") {
+      throw new Error(`Invalid target scope: ${String(request.targetScope)}`);
+    }
+    if (request.action === "uninstall" || request.action === "move" || request.action === "removeExternal") {
+      return {
+        status: "success",
+        changed: true,
+        message: `Skill ${request.action} completed.`
+      };
+    }
+    if (request.action !== "install") {
+      return {
+        status: "blocked",
+        changed: false,
+        message: `Skill action is not supported by bridge reconciler: ${request.action}`
+      };
+    }
+    const catalog = await this.deps.catalogClient.getCatalog();
+    const remoteSkill = catalog.skills.find(
+      (skill) => this.deps.skillStore.normalizeRemoteSkillId(skill.id) === request.skillId
+    );
+    if (!remoteSkill) {
+      return {
+        status: "blocked",
+        changed: false,
+        message: "Skill not found in catalog."
+      };
+    }
+    if (!request.confirmed && (remoteSkill.hasScripts || remoteSkill.hasHooks)) {
+      return {
+        status: "requires_confirmation",
+        changed: false,
+        hasScripts: Boolean(remoteSkill.hasScripts),
+        hasHooks: Boolean(remoteSkill.hasHooks),
+        message: "This skill contains executable scripts that require confirmation."
+      };
+    }
+    return {
+      status: "success",
+      changed: true,
+      message: "Skill installed."
+    };
+  }
+};
+
+// src/skills/SkillStore.ts
+var fs11 = __toESM(require("fs/promises"));
+var path9 = __toESM(require("path"));
+var USER_SKILL_MARKER_FILE = ".ms-devtools-skill.json";
+var WORKSPACE_SKILLS_ROOT_RELATIVE = ".github/skills";
+var WORKSPACE_SKILLS_MARKER_RELATIVE = ".github/.ms-devtools-skills.yml";
+var SAFE_LOCAL_ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function assertSafeLocalSkillId(skillId) {
+  if (typeof skillId !== "string" || skillId.length === 0 || skillId === "." || skillId === ".." || skillId.includes("/") || skillId.includes("\\") || !SAFE_LOCAL_ID_PATTERN2.test(skillId)) {
+    throw new Error(`Invalid skill id: ${skillId}`);
+  }
+  return skillId;
+}
+var SkillStore = class {
+  constructor(options) {
+    this.workspacePath = options.workspacePath;
+    this.userSkillsRoot = options.userSkillsRoot;
+    this.fileSystem = options.fileSystem ?? fs11;
+  }
+  normalizeRemoteSkillId(remoteId) {
+    if (remoteId.startsWith("official/")) {
+      return assertSafeLocalSkillId(remoteId.slice("official/".length));
+    }
+    if (remoteId.startsWith("community/")) {
+      const lastSlash = remoteId.lastIndexOf("/");
+      return assertSafeLocalSkillId(remoteId.slice(lastSlash + 1));
+    }
+    return assertSafeLocalSkillId(remoteId);
+  }
+  getWorkspaceSkillPath(skillId) {
+    return `${WORKSPACE_SKILLS_ROOT_RELATIVE}/${skillId}`;
+  }
+  getWorkspaceMarkerPath() {
+    return WORKSPACE_SKILLS_MARKER_RELATIVE;
+  }
+  getUserSkillPath(skillId) {
+    return path9.join(this.userSkillsRoot, skillId);
+  }
+  async listWorkspaceSkillIds() {
+    const skillsRootPath = path9.join(
+      this.workspacePath,
+      WORKSPACE_SKILLS_ROOT_RELATIVE
+    );
+    try {
+      const entries = await this.fileSystem.readdir(skillsRootPath, {
+        withFileTypes: true
+      });
+      return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort();
+    } catch {
+      return [];
+    }
+  }
+  async listUserSkillIds() {
+    try {
+      const entries = await this.fileSystem.readdir(this.userSkillsRoot, {
+        withFileTypes: true
+      });
+      return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort();
+    } catch {
+      return [];
+    }
+  }
+  async writeManagedUserSkillMarker(skillId) {
+    const targetDir = this.getUserSkillPath(skillId);
+    await this.fileSystem.mkdir(targetDir, { recursive: true });
+    await this.fileSystem.writeFile(
+      path9.join(targetDir, USER_SKILL_MARKER_FILE),
+      JSON.stringify({ skillId, installedBy: "ms-devtools" }, null, 2),
+      "utf-8"
+    );
+  }
+  async isManagedUserSkill(skillId) {
+    try {
+      const marker = await this.fileSystem.readFile(
+        path9.join(this.getUserSkillPath(skillId), USER_SKILL_MARKER_FILE),
+        "utf-8"
+      );
+      const parsed = JSON.parse(marker);
+      return parsed.skillId === skillId;
+    } catch {
+      return false;
+    }
+  }
+  async writeSkillFiles(skillId, scope, files) {
+    const root = scope === "workspace" ? path9.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE) : this.userSkillsRoot;
+    const targetDir = path9.join(root, skillId);
+    await this.fileSystem.mkdir(targetDir, { recursive: true });
+    for (const file of files) {
+      const filePath = path9.join(targetDir, file.path);
+      await this.fileSystem.mkdir(path9.dirname(filePath), { recursive: true });
+      await this.fileSystem.writeFile(filePath, file.content, "utf-8");
+      if (file.executable) {
+        try {
+          await this.fileSystem.chmod(filePath, 493);
+        } catch {
+        }
+      }
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AgentCatalogClient,
+  AgentReconciler,
+  AgentStore,
   DaemonLogger,
   EnvironmentInspector,
   GithubCopilotCliExecutor,
@@ -2271,6 +2867,10 @@ function matchCronField(field, value) {
   ProjectTools,
   SchedulerDaemon,
   ShellExecutor,
+  SkillCatalogClient,
+  SkillReconciler,
+  SkillStore,
+  TOOL_RISK_MAP,
   TaskConfigManager,
   TaskExecutionEngine,
   TaskLogManager,
@@ -2288,6 +2888,7 @@ function matchCronField(field, value) {
   matchesCron,
   moveFiles,
   noopLogger,
+  parseAgentToolPermissions,
   parseIntervalMs,
   resolveTaskExecutionPayload,
   unzipFile,