@serviceme/devtools-cli 0.1.5 → 0.1.6

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 'use strict';
 
+var fs12 = require('fs/promises');
+var path11 = require('path');
 var child_process = require('child_process');
-var fs2 = require('fs/promises');
-var path = require('path');
-var fs8 = require('fs');
+var fs9 = require('fs');
 var crypto = require('crypto');
 var os = require('os');
 var readline = require('readline');
@@ -27,9 +27,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var fs8__namespace = /*#__PURE__*/_interopNamespace(fs8);
+var fs12__namespace = /*#__PURE__*/_interopNamespace(fs12);
+var path11__namespace = /*#__PURE__*/_interopNamespace(path11);
+var fs9__namespace = /*#__PURE__*/_interopNamespace(fs9);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 
@@ -72,12 +72,24 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../../packages/serviceme-protocol/src/agent.ts
+var init_agent = __esm({
+  "../../packages/serviceme-protocol/src/agent.ts"() {
+  }
+});
+
 // ../../packages/serviceme-protocol/src/scheduled-tasks.ts
 var init_scheduled_tasks = __esm({
   "../../packages/serviceme-protocol/src/scheduled-tasks.ts"() {
   }
 });
 
+// ../../packages/serviceme-protocol/src/skill.ts
+var init_skill = __esm({
+  "../../packages/serviceme-protocol/src/skill.ts"() {
+  }
+});
+
 // ../../packages/serviceme-protocol/src/bridge.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -97,7 +109,9 @@ function isBridgeRequest(value) {
 var SERVICEME_PROTOCOL_VERSION, BRIDGE_METHODS;
 var init_bridge = __esm({
   "../../packages/serviceme-protocol/src/bridge.ts"() {
+    init_agent();
     init_scheduled_tasks();
+    init_skill();
     SERVICEME_PROTOCOL_VERSION = 2;
     BRIDGE_METHODS = [
       "system.hello",
@@ -105,7 +119,14 @@ var init_bridge = __esm({
       "system.shutdown",
       "task.execute",
       "task.cancel",
-      "task.list-running"
+      "task.list-running",
+      "skill.marketplace-state",
+      "skill.mutate",
+      "skill.reconcile",
+      "skill.publishable",
+      "agent.marketplace-state",
+      "agent.mutate",
+      "agent.permissions"
     ];
   }
 });
@@ -325,6 +346,7 @@ var init_project = __esm({
 // ../../packages/serviceme-protocol/src/index.ts
 var init_src = __esm({
   "../../packages/serviceme-protocol/src/index.ts"() {
+    init_agent();
     init_bridge();
     init_cli();
     init_copilot();
@@ -335,6 +357,328 @@ var init_src = __esm({
     init_metadata();
     init_project();
     init_scheduled_tasks();
+    init_skill();
+  }
+});
+
+// ../../packages/serviceme-core/src/agents/AgentCatalogClient.ts
+var AgentCatalogClient;
+var init_AgentCatalogClient = __esm({
+  "../../packages/serviceme-core/src/agents/AgentCatalogClient.ts"() {
+    AgentCatalogClient = class {
+      constructor(options2 = {}) {
+        this.fetchImpl = options2.fetchImpl ?? fetch;
+        this.baseUrl = options2.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()
+        };
+      }
+    };
+  }
+});
+
+// ../../packages/serviceme-core/src/permissions/agent-permissions.ts
+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 line2 of lines) {
+    const itemMatch = line2.match(LIST_ITEM_REGEX);
+    if (itemMatch?.[1]) {
+      const tool = itemMatch[1].trim();
+      tools.push({ tool, riskLevel: TOOL_RISK_MAP[tool] ?? "medium" });
+    } else if (line2.trim() !== "" && !line2.startsWith(" ") && !line2.startsWith("	")) {
+      break;
+    }
+  }
+  return tools;
+}
+var TOOL_RISK_MAP, FRONTMATTER_REGEX, TOOLS_LINE_REGEX, TOOLS_INLINE_REGEX, LIST_ITEM_REGEX;
+var init_agent_permissions = __esm({
+  "../../packages/serviceme-core/src/permissions/agent-permissions.ts"() {
+    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"
+    };
+    FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---/;
+    TOOLS_LINE_REGEX = /^tools:\s*$/m;
+    TOOLS_INLINE_REGEX = /^tools:\s*\[([^\]]*)\]/m;
+    LIST_ITEM_REGEX = /^\s*-\s+(.+)$/;
+  }
+});
+
+// ../../packages/serviceme-core/src/permissions/index.ts
+var init_permissions = __esm({
+  "../../packages/serviceme-core/src/permissions/index.ts"() {
+    init_agent_permissions();
+  }
+});
+
+// ../../packages/serviceme-core/src/agents/AgentReconciler.ts
+var AgentReconciler;
+var init_AgentReconciler = __esm({
+  "../../packages/serviceme-core/src/agents/AgentReconciler.ts"() {
+    init_permissions();
+    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");
+      }
+    };
+  }
+});
+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 WORKSPACE_AGENTS_ROOT_RELATIVE, WORKSPACE_AGENTS_STATE_RELATIVE, SAFE_LOCAL_ID_PATTERN, AgentStore;
+var init_AgentStore = __esm({
+  "../../packages/serviceme-core/src/agents/AgentStore.ts"() {
+    WORKSPACE_AGENTS_ROOT_RELATIVE = ".github/agents";
+    WORKSPACE_AGENTS_STATE_RELATIVE = ".github/.ms-devtools-agents.yml";
+    SAFE_LOCAL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+    AgentStore = class {
+      constructor(options2) {
+        this.workspacePath = options2.workspacePath;
+        this.userAgentsRoot = options2.userAgentsRoot;
+        this.fileSystem = options2.fileSystem ?? fs12__namespace;
+        this.schemaVersion = options2.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(
+          path11__namespace.join(this.workspacePath, WORKSPACE_AGENTS_ROOT_RELATIVE)
+        );
+      }
+      async listUserAgentIds() {
+        return this.listAgentIds(this.userAgentsRoot);
+      }
+      async readState() {
+        try {
+          const raw = await this.fileSystem.readFile(
+            path11__namespace.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 = path11__namespace.join(
+          this.workspacePath,
+          WORKSPACE_AGENTS_STATE_RELATIVE
+        );
+        await this.fileSystem.mkdir(path11__namespace.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 root2 = scope === "workspace" ? path11__namespace.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 ? root2 : path11__namespace.join(root2, agentId);
+        await this.fileSystem.mkdir(targetDir, { recursive: true });
+        for (const file of files) {
+          const filePath = path11__namespace.join(targetDir, file.path);
+          await this.fileSystem.mkdir(path11__namespace.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 [];
+        }
+      }
+    };
+  }
+});
+
+// ../../packages/serviceme-core/src/agents/types.ts
+var init_types = __esm({
+  "../../packages/serviceme-core/src/agents/types.ts"() {
+  }
+});
+
+// ../../packages/serviceme-core/src/agents/index.ts
+var init_agents = __esm({
+  "../../packages/serviceme-core/src/agents/index.ts"() {
+    init_AgentCatalogClient();
+    init_AgentReconciler();
+    init_AgentStore();
+    init_types();
   }
 });
 function terminateCommandProcess(child) {
@@ -595,7 +939,13 @@ var init_environmentInspector = __esm({
     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
     };
     ERROR_CODE_NOT_FOUND = 127;
     ERROR_CODE_TIMEOUT = "ETIMEDOUT";
@@ -642,8 +992,29 @@ var init_environmentInspector = __esm({
           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((line2) => line2.trim()).filter((line2) => line2.length > 0);
+          const cmdShim = candidates.find(
+            (line2) => line2.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)
@@ -718,12 +1089,19 @@ var init_environmentInspector = __esm({
           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 = {
@@ -802,7 +1180,7 @@ var init_imageTools = __esm({
           if (!await this.pathExists(filePath)) {
             return { valid: false };
           }
-          if (!SUPPORTED_FORMATS.includes(path__namespace.extname(filePath).toLowerCase())) {
+          if (!SUPPORTED_FORMATS.includes(path11__namespace.extname(filePath).toLowerCase())) {
             return { valid: false };
           }
           await this.getInfo(filePath, sharpModulePath);
@@ -814,7 +1192,7 @@ var init_imageTools = __esm({
       async getInfo(imagePath, sharpModulePath) {
         const sharp = this.loadSharp(sharpModulePath);
         const metadata = await sharp(imagePath).metadata();
-        const stats = await fs2__namespace.stat(imagePath);
+        const stats = await fs12__namespace.stat(imagePath);
         return {
           width: metadata.width ?? 0,
           height: metadata.height ?? 0,
@@ -831,7 +1209,7 @@ var init_imageTools = __esm({
             `Invalid image file: ${imagePath}`
           );
         }
-        const originalStats = await fs2__namespace.stat(imagePath);
+        const originalStats = await fs12__namespace.stat(imagePath);
         const originalSize = originalStats.size;
         const outputPath = this.getOutputPath(imagePath, options2);
         const compressedBuffer = await this.compressWithSharp(imagePath, options2);
@@ -846,7 +1224,7 @@ var init_imageTools = __esm({
             outputPath: imagePath
           };
         }
-        await fs2__namespace.writeFile(outputPath, compressedBuffer);
+        await fs12__namespace.writeFile(outputPath, compressedBuffer);
         return {
           originalSize,
           compressedSize,
@@ -857,7 +1235,7 @@ var init_imageTools = __esm({
       async compressWithSharp(imagePath, options2) {
         const sharp = this.loadSharp(options2.sharpModulePath);
         let pipeline = sharp(imagePath);
-        switch (options2.format ?? path__namespace.extname(imagePath).toLowerCase().slice(1)) {
+        switch (options2.format ?? path11__namespace.extname(imagePath).toLowerCase().slice(1)) {
           case "jpg":
           case "jpeg":
             pipeline = pipeline.jpeg({ quality: options2.quality });
@@ -883,14 +1261,14 @@ var init_imageTools = __esm({
         if (options2.replaceOriginImage) {
           return inputPath;
         }
-        const dir = path__namespace.dirname(inputPath);
-        const ext = path__namespace.extname(inputPath);
-        const name = path__namespace.basename(inputPath, ext);
-        return path__namespace.join(dir, `${name}_compressed${ext}`);
+        const dir = path11__namespace.dirname(inputPath);
+        const ext = path11__namespace.extname(inputPath);
+        const name = path11__namespace.basename(inputPath, ext);
+        return path11__namespace.join(dir, `${name}_compressed${ext}`);
       }
       async pathExists(targetPath) {
         try {
-          await fs2__namespace.access(targetPath);
+          await fs12__namespace.access(targetPath);
           return true;
         } catch {
           return false;
@@ -1397,8 +1775,8 @@ var require_esprima = __commonJS({
                 return result;
               };
               JSXParser2.prototype.lexJSX = function() {
-                var cp = this.scanner.source.charCodeAt(this.scanner.index);
-                if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {
+                var cp5 = this.scanner.source.charCodeAt(this.scanner.index);
+                if (cp5 === 60 || cp5 === 62 || cp5 === 47 || cp5 === 58 || cp5 === 61 || cp5 === 123 || cp5 === 125) {
                   var value = this.scanner.source[this.scanner.index++];
                   return {
                     type: 7,
@@ -1409,7 +1787,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp === 34 || cp === 39) {
+                if (cp5 === 34 || cp5 === 39) {
                   var start = this.scanner.index;
                   var quote = this.scanner.source[this.scanner.index++];
                   var str = "";
@@ -1432,7 +1810,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp === 46) {
+                if (cp5 === 46) {
                   var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1);
                   var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2);
                   var value = n1 === 46 && n2 === 46 ? "..." : ".";
@@ -1447,7 +1825,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp === 96) {
+                if (cp5 === 96) {
                   return {
                     type: 10,
                     value: "",
@@ -1457,7 +1835,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (character_1.Character.isIdentifierStart(cp) && cp !== 92) {
+                if (character_1.Character.isIdentifierStart(cp5) && cp5 !== 92) {
                   var start = this.scanner.index;
                   ++this.scanner.index;
                   while (!this.scanner.eof()) {
@@ -1786,33 +2164,33 @@ var require_esprima = __commonJS({
             };
             exports2.Character = {
               /* tslint:disable:no-bitwise */
-              fromCodePoint: function(cp) {
-                return cp < 65536 ? String.fromCharCode(cp) : String.fromCharCode(55296 + (cp - 65536 >> 10)) + String.fromCharCode(56320 + (cp - 65536 & 1023));
+              fromCodePoint: function(cp5) {
+                return cp5 < 65536 ? String.fromCharCode(cp5) : String.fromCharCode(55296 + (cp5 - 65536 >> 10)) + String.fromCharCode(56320 + (cp5 - 65536 & 1023));
               },
               // https://tc39.github.io/ecma262/#sec-white-space
-              isWhiteSpace: function(cp) {
-                return cp === 32 || cp === 9 || cp === 11 || cp === 12 || cp === 160 || cp >= 5760 && [5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(cp) >= 0;
+              isWhiteSpace: function(cp5) {
+                return cp5 === 32 || cp5 === 9 || cp5 === 11 || cp5 === 12 || cp5 === 160 || cp5 >= 5760 && [5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(cp5) >= 0;
               },
               // https://tc39.github.io/ecma262/#sec-line-terminators
-              isLineTerminator: function(cp) {
-                return cp === 10 || cp === 13 || cp === 8232 || cp === 8233;
+              isLineTerminator: function(cp5) {
+                return cp5 === 10 || cp5 === 13 || cp5 === 8232 || cp5 === 8233;
               },
               // https://tc39.github.io/ecma262/#sec-names-and-keywords
-              isIdentifierStart: function(cp) {
-                return cp === 36 || cp === 95 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 92 || cp >= 128 && Regex.NonAsciiIdentifierStart.test(exports2.Character.fromCodePoint(cp));
+              isIdentifierStart: function(cp5) {
+                return cp5 === 36 || cp5 === 95 || cp5 >= 65 && cp5 <= 90 || cp5 >= 97 && cp5 <= 122 || cp5 === 92 || cp5 >= 128 && Regex.NonAsciiIdentifierStart.test(exports2.Character.fromCodePoint(cp5));
               },
-              isIdentifierPart: function(cp) {
-                return cp === 36 || cp === 95 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp >= 48 && cp <= 57 || cp === 92 || cp >= 128 && Regex.NonAsciiIdentifierPart.test(exports2.Character.fromCodePoint(cp));
+              isIdentifierPart: function(cp5) {
+                return cp5 === 36 || cp5 === 95 || cp5 >= 65 && cp5 <= 90 || cp5 >= 97 && cp5 <= 122 || cp5 >= 48 && cp5 <= 57 || cp5 === 92 || cp5 >= 128 && Regex.NonAsciiIdentifierPart.test(exports2.Character.fromCodePoint(cp5));
               },
               // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
-              isDecimalDigit: function(cp) {
-                return cp >= 48 && cp <= 57;
+              isDecimalDigit: function(cp5) {
+                return cp5 >= 48 && cp5 <= 57;
               },
-              isHexDigit: function(cp) {
-                return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 70 || cp >= 97 && cp <= 102;
+              isHexDigit: function(cp5) {
+                return cp5 >= 48 && cp5 <= 57 || cp5 >= 65 && cp5 <= 70 || cp5 >= 97 && cp5 <= 102;
               },
-              isOctalDigit: function(cp) {
-                return cp >= 48 && cp <= 55;
+              isOctalDigit: function(cp5) {
+                return cp5 >= 48 && cp5 <= 55;
               }
             };
           },
@@ -5862,15 +6240,15 @@ var require_esprima = __commonJS({
                 }
               };
               Scanner2.prototype.codePointAt = function(i) {
-                var cp = this.source.charCodeAt(i);
-                if (cp >= 55296 && cp <= 56319) {
+                var cp5 = this.source.charCodeAt(i);
+                if (cp5 >= 55296 && cp5 <= 56319) {
                   var second = this.source.charCodeAt(i + 1);
                   if (second >= 56320 && second <= 57343) {
-                    var first = cp;
-                    cp = (first - 55296) * 1024 + second - 56320 + 65536;
+                    var first = cp5;
+                    cp5 = (first - 55296) * 1024 + second - 56320 + 65536;
                   }
                 }
-                return cp;
+                return cp5;
               };
               Scanner2.prototype.scanHexEscape = function(prefix) {
                 var len = prefix === "u" ? 4 : 2;
@@ -5922,11 +6300,11 @@ var require_esprima = __commonJS({
                 return this.source.slice(start, this.index);
               };
               Scanner2.prototype.getComplexIdentifier = function() {
-                var cp = this.codePointAt(this.index);
-                var id = character_1.Character.fromCodePoint(cp);
+                var cp5 = this.codePointAt(this.index);
+                var id = character_1.Character.fromCodePoint(cp5);
                 this.index += id.length;
                 var ch;
-                if (cp === 92) {
+                if (cp5 === 92) {
                   if (this.source.charCodeAt(this.index) !== 117) {
                     this.throwUnexpectedToken();
                   }
@@ -5943,14 +6321,14 @@ var require_esprima = __commonJS({
                   id = ch;
                 }
                 while (!this.eof()) {
-                  cp = this.codePointAt(this.index);
-                  if (!character_1.Character.isIdentifierPart(cp)) {
+                  cp5 = this.codePointAt(this.index);
+                  if (!character_1.Character.isIdentifierPart(cp5)) {
                     break;
                   }
-                  ch = character_1.Character.fromCodePoint(cp);
+                  ch = character_1.Character.fromCodePoint(cp5);
                   id += ch;
                   this.index += ch.length;
-                  if (cp === 92) {
+                  if (cp5 === 92) {
                     id = id.substr(0, id.length - 1);
                     if (this.source.charCodeAt(this.index) !== 117) {
                       this.throwUnexpectedToken();
@@ -6576,29 +6954,29 @@ var require_esprima = __commonJS({
                     end: this.index
                   };
                 }
-                var cp = this.source.charCodeAt(this.index);
-                if (character_1.Character.isIdentifierStart(cp)) {
+                var cp5 = this.source.charCodeAt(this.index);
+                if (character_1.Character.isIdentifierStart(cp5)) {
                   return this.scanIdentifier();
                 }
-                if (cp === 40 || cp === 41 || cp === 59) {
+                if (cp5 === 40 || cp5 === 41 || cp5 === 59) {
                   return this.scanPunctuator();
                 }
-                if (cp === 39 || cp === 34) {
+                if (cp5 === 39 || cp5 === 34) {
                   return this.scanStringLiteral();
                 }
-                if (cp === 46) {
+                if (cp5 === 46) {
                   if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {
                     return this.scanNumericLiteral();
                   }
                   return this.scanPunctuator();
                 }
-                if (character_1.Character.isDecimalDigit(cp)) {
+                if (character_1.Character.isDecimalDigit(cp5)) {
                   return this.scanNumericLiteral();
                 }
-                if (cp === 96 || cp === 125 && this.curlyStack[this.curlyStack.length - 1] === "${") {
+                if (cp5 === 96 || cp5 === 125 && this.curlyStack[this.curlyStack.length - 1] === "${") {
                   return this.scanTemplate();
                 }
-                if (cp >= 55296 && cp < 57343) {
+                if (cp5 >= 55296 && cp5 < 57343) {
                   if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {
                     return this.scanIdentifier();
                   }
@@ -8776,10 +9154,10 @@ var require_stringify = __commonJS({
       replacer = null;
       indent = EMPTY;
     };
-    var join9 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + LF + gap : two ? two.trimRight() + LF + gap : EMPTY;
+    var join15 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + LF + gap : two ? two.trimRight() + LF + gap : EMPTY;
     var join_content = (inside, value, gap) => {
       const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-      return join9(comment, inside, gap);
+      return join15(comment, inside, gap);
     };
     var array_stringify = (value, gap) => {
       const deeper_gap = gap + indent;
@@ -8790,7 +9168,7 @@ var require_stringify = __commonJS({
         if (i !== 0) {
           inside += COMMA;
         }
-        const before = join9(
+        const before = join15(
           after_comma,
           process_comments(value, BEFORE(i), deeper_gap),
           deeper_gap
@@ -8800,7 +9178,7 @@ var require_stringify = __commonJS({
         inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
         after_comma = process_comments(value, AFTER(i), deeper_gap);
       }
-      inside += join9(
+      inside += join15(
         after_comma,
         process_comments(value, PREFIX_AFTER, deeper_gap),
         deeper_gap
@@ -8825,7 +9203,7 @@ var require_stringify = __commonJS({
           inside += COMMA;
         }
         first = false;
-        const before = join9(
+        const before = join15(
           after_comma,
           process_comments(value, BEFORE(key2), deeper_gap),
           deeper_gap
@@ -8835,7 +9213,7 @@ var require_stringify = __commonJS({
         after_comma = process_comments(value, AFTER(key2), deeper_gap);
       };
       keys.forEach(iteratee);
-      inside += join9(
+      inside += join15(
         after_comma,
         process_comments(value, PREFIX_AFTER, deeper_gap),
         deeper_gap
@@ -10213,7 +10591,7 @@ var require_pend = __commonJS({
 // ../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/fd-slicer.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/fd-slicer.js"(exports$1) {
-    var fs13 = __require("fs");
+    var fs19 = __require("fs");
     var util2 = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -10238,7 +10616,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer2, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs13.read(self.fd, buffer2, offset, length, position, function(err, bytesRead, buffer3) {
+        fs19.read(self.fd, buffer2, offset, length, position, function(err, bytesRead, buffer3) {
           cb();
           callback(err, bytesRead, buffer3);
         });
@@ -10247,7 +10625,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer2, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs13.write(self.fd, buffer2, offset, length, position, function(err, written, buffer3) {
+        fs19.write(self.fd, buffer2, offset, length, position, function(err, written, buffer3) {
           cb();
           callback(err, written, buffer3);
         });
@@ -10268,7 +10646,7 @@ var require_fd_slicer = __commonJS({
       if (self.refCount > 0) return;
       if (self.refCount < 0) throw new Error("invalid unref");
       if (self.autoClose) {
-        fs13.close(self.fd, onCloseDone);
+        fs19.close(self.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -10305,7 +10683,7 @@ var require_fd_slicer = __commonJS({
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
         var buffer2 = Buffer.allocUnsafe(toRead);
-        fs13.read(self.context.fd, buffer2, 0, toRead, self.pos, function(err, bytesRead) {
+        fs19.read(self.context.fd, buffer2, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -10352,7 +10730,7 @@ var require_fd_slicer = __commonJS({
       }
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
-        fs13.write(self.context.fd, buffer2, 0, buffer2.length, self.pos, function(err2, bytes) {
+        fs19.write(self.context.fd, buffer2, 0, buffer2.length, self.pos, function(err2, bytes) {
           if (err2) {
             self.destroy();
             cb();
@@ -10790,7 +11168,7 @@ var require_buffer_crc32 = __commonJS({
 // ../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/index.js"(exports$1) {
-    var fs13 = __require("fs");
+    var fs19 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -10811,7 +11189,7 @@ var require_yauzl = __commonJS({
     exports$1.Entry = Entry;
     exports$1.LocalFileHeader = LocalFileHeader;
     exports$1.RandomAccessReader = RandomAccessReader;
-    function open2(path9, options2, callback) {
+    function open2(path15, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -10823,10 +11201,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs13.open(path9, "r", function(err, fd) {
+      fs19.open(path15, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options2, function(err2, zipfile) {
-          if (err2) fs13.close(fd, defaultCallback);
+          if (err2) fs19.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -10843,7 +11221,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs13.fstat(fd, function(err, stats) {
+      fs19.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -11541,12 +11919,12 @@ var init_fileUtils = __esm({
             zipfile.readEntry();
             zipfile.on("entry", (entry) => {
               if (/\/$/.test(entry.fileName)) {
-                void fs2.mkdir(path.join(dest, entry.fileName), { recursive: true }).then(() => {
+                void fs12.mkdir(path11.join(dest, entry.fileName), { recursive: true }).then(() => {
                   zipfile.readEntry();
                 }).catch(reject);
               } else {
-                const outputPath = path.join(dest, entry.fileName);
-                void fs2.mkdir(path.dirname(outputPath), { recursive: true }).then(() => {
+                const outputPath = path11.join(dest, entry.fileName);
+                void fs12.mkdir(path11.dirname(outputPath), { recursive: true }).then(() => {
                   zipfile.openReadStream(
                     entry,
                     (streamError, readStream) => {
@@ -11555,7 +11933,7 @@ var init_fileUtils = __esm({
                         return reject(
                           new Error("Failed to open zip entry stream.")
                         );
-                      const writeStream = fs8.createWriteStream(outputPath);
+                      const writeStream = fs9.createWriteStream(outputPath);
                       readStream.on("error", reject);
                       writeStream.on("error", reject);
                       writeStream.on("close", () => {
@@ -11579,58 +11957,58 @@ var init_fileUtils = __esm({
     };
     tryLstat = async (targetPath) => {
       try {
-        return await fs2.lstat(targetPath);
+        return await fs12.lstat(targetPath);
       } catch {
         return null;
       }
     };
     mergeEntry = async (sourcePath, destPath, overwrite) => {
-      const sourceStat = await fs2.lstat(sourcePath);
+      const sourceStat = await fs12.lstat(sourcePath);
       const destStat = await tryLstat(destPath);
       if (sourceStat.isDirectory()) {
         if (destStat && !destStat.isDirectory()) {
           if (!overwrite) {
-            await fs2.rm(sourcePath, { recursive: true, force: true });
+            await fs12.rm(sourcePath, { recursive: true, force: true });
             return;
           }
-          await fs2.rm(destPath, { recursive: true, force: true });
+          await fs12.rm(destPath, { recursive: true, force: true });
         }
-        await fs2.mkdir(destPath, { recursive: true });
-        const children = await fs2.readdir(sourcePath);
+        await fs12.mkdir(destPath, { recursive: true });
+        const children = await fs12.readdir(sourcePath);
         for (const child of children) {
           await mergeEntry(
-            path.join(sourcePath, child),
-            path.join(destPath, child),
+            path11.join(sourcePath, child),
+            path11.join(destPath, child),
             overwrite
           );
         }
-        await fs2.rm(sourcePath, { recursive: true, force: true });
+        await fs12.rm(sourcePath, { recursive: true, force: true });
         return;
       }
       if (destStat) {
         if (!overwrite) {
-          await fs2.rm(sourcePath, { recursive: true, force: true });
+          await fs12.rm(sourcePath, { recursive: true, force: true });
           return;
         }
-        await fs2.rm(destPath, { recursive: true, force: true });
+        await fs12.rm(destPath, { recursive: true, force: true });
       }
       try {
-        await fs2.rename(sourcePath, destPath);
+        await fs12.rename(sourcePath, destPath);
       } catch {
-        await fs2.copyFile(sourcePath, destPath);
-        await fs2.rm(sourcePath, { recursive: true, force: true });
+        await fs12.copyFile(sourcePath, destPath);
+        await fs12.rm(sourcePath, { recursive: true, force: true });
       }
     };
     moveFiles = async (sourceDir, destDir, overwrite = false) => {
-      await fs2.mkdir(destDir, { recursive: true });
-      const files = await fs2.readdir(sourceDir);
+      await fs12.mkdir(destDir, { recursive: true });
+      const files = await fs12.readdir(sourceDir);
       for (const file of files) {
-        const sourceFile = path.join(sourceDir, file);
-        const destFile = path.join(destDir, file);
+        const sourceFile = path11.join(sourceDir, file);
+        const destFile = path11.join(destDir, file);
         if (!overwrite) {
           try {
-            await fs2.access(destFile, fs8.constants.F_OK);
-            await fs2.rm(sourceFile, { recursive: true, force: true });
+            await fs12.access(destFile, fs9.constants.F_OK);
+            await fs12.rm(sourceFile, { recursive: true, force: true });
             continue;
           } catch {
           }
@@ -11652,10 +12030,10 @@ var init_projectTools = __esm({
     ProjectTools = class {
       async extractTemplate(zipPath, workspacePath, tempExtractDir, input) {
         await unzipFile(zipPath, tempExtractDir);
-        let sourceDir = path__namespace.join(tempExtractDir, input.extractedDirName);
+        let sourceDir = path11__namespace.join(tempExtractDir, input.extractedDirName);
         let actualDirName = input.extractedDirName;
         if (!await this.pathExists(sourceDir)) {
-          const entries = await fs2__namespace.readdir(tempExtractDir, { withFileTypes: true });
+          const entries = await fs12__namespace.readdir(tempExtractDir, { withFileTypes: true });
           const directories = entries.filter(
             (entry) => entry.isDirectory() && !entry.name.startsWith(".")
           );
@@ -11667,7 +12045,7 @@ var init_projectTools = __esm({
           );
           if (selectedDirectory) {
             actualDirName = selectedDirectory;
-            sourceDir = path__namespace.join(tempExtractDir, actualDirName);
+            sourceDir = path11__namespace.join(tempExtractDir, actualDirName);
           } else if (directories.length === 0) {
             throw new Error(
               `No directory found after extraction. Expected directory: ${input.extractedDirName}`
@@ -11725,7 +12103,7 @@ var init_projectTools = __esm({
         } else {
           for (const scriptPath of scripts) {
             try {
-              await fs2__namespace.chmod(scriptPath, 493);
+              await fs12__namespace.chmod(scriptPath, 493);
               updatedCount += 1;
             } catch {
             }
@@ -11773,12 +12151,12 @@ var init_projectTools = __esm({
         const results = [];
         let entries;
         try {
-          entries = await fs2__namespace.readdir(dir, { withFileTypes: true });
+          entries = await fs12__namespace.readdir(dir, { withFileTypes: true });
         } catch {
           return results;
         }
         for (const entry of entries) {
-          const fullPath = path__namespace.join(dir, entry.name);
+          const fullPath = path11__namespace.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))) {
@@ -11789,7 +12167,7 @@ var init_projectTools = __esm({
       }
       async pathExists(targetPath) {
         try {
-          await fs2__namespace.access(targetPath);
+          await fs12__namespace.access(targetPath);
           return true;
         } catch {
           return false;
@@ -11808,7 +12186,7 @@ var init_projectTools = __esm({
         const matches = [];
         for (const directoryName of directoryNames) {
           if (await this.directoryMatchesProjectPattern(
-            path__namespace.join(tempExtractDir, directoryName),
+            path11__namespace.join(tempExtractDir, directoryName),
             projectFilePattern
           )) {
             matches.push(directoryName);
@@ -11820,7 +12198,7 @@ var init_projectTools = __esm({
         return null;
       }
       async directoryMatchesProjectPattern(directoryPath, projectFilePattern) {
-        const entries = await fs2__namespace.readdir(directoryPath);
+        const entries = await fs12__namespace.readdir(directoryPath);
         if (projectFilePattern.includes("*")) {
           const regex = new RegExp(`^${projectFilePattern.replace("*", ".*")}$`);
           return entries.some((entry) => regex.test(entry));
@@ -11838,10 +12216,10 @@ var init_DaemonLogger = __esm({
     MAX_LOG_SIZE = 1024 * 1024;
     DaemonLogger = class {
       constructor(workspacePath) {
-        this.logPath = path__namespace.join(workspacePath, CONFIG_DIR, LOG_FILE);
-        const dir = path__namespace.dirname(this.logPath);
-        if (!fs8__namespace.existsSync(dir)) {
-          fs8__namespace.mkdirSync(dir, { recursive: true });
+        this.logPath = path11__namespace.join(workspacePath, CONFIG_DIR, LOG_FILE);
+        const dir = path11__namespace.dirname(this.logPath);
+        if (!fs9__namespace.existsSync(dir)) {
+          fs9__namespace.mkdirSync(dir, { recursive: true });
         }
       }
       getLogPath() {
@@ -11852,16 +12230,16 @@ var init_DaemonLogger = __esm({
         const line2 = `[${ts}] [${level.toUpperCase()}] ${message}
 `;
         this.rotateIfNeeded();
-        fs8__namespace.appendFileSync(this.logPath, line2, "utf-8");
+        fs9__namespace.appendFileSync(this.logPath, line2, "utf-8");
       }
       rotateIfNeeded() {
         try {
-          const stats = fs8__namespace.statSync(this.logPath);
+          const stats = fs9__namespace.statSync(this.logPath);
           if (stats.size > MAX_LOG_SIZE) {
-            const content = fs8__namespace.readFileSync(this.logPath, "utf-8");
+            const content = fs9__namespace.readFileSync(this.logPath, "utf-8");
             const halfIdx = content.indexOf("\n", Math.floor(content.length / 2));
             if (halfIdx > 0) {
-              fs8__namespace.writeFileSync(this.logPath, content.slice(halfIdx + 1), "utf-8");
+              fs9__namespace.writeFileSync(this.logPath, content.slice(halfIdx + 1), "utf-8");
             }
           }
         } catch {
@@ -11877,27 +12255,27 @@ var init_PidManager = __esm({
     PID_FILE = "scheduler.pid";
     PidManager = class {
       constructor(workspacePath) {
-        this.pidPath = path__namespace.join(workspacePath, CONFIG_DIR2, PID_FILE);
+        this.pidPath = path11__namespace.join(workspacePath, CONFIG_DIR2, PID_FILE);
       }
       getPidPath() {
         return this.pidPath;
       }
       writePid(pid) {
-        const dir = path__namespace.dirname(this.pidPath);
-        if (!fs8__namespace.existsSync(dir)) {
-          fs8__namespace.mkdirSync(dir, { recursive: true });
+        const dir = path11__namespace.dirname(this.pidPath);
+        if (!fs9__namespace.existsSync(dir)) {
+          fs9__namespace.mkdirSync(dir, { recursive: true });
         }
-        fs8__namespace.writeFileSync(this.pidPath, String(pid), "utf-8");
+        fs9__namespace.writeFileSync(this.pidPath, String(pid), "utf-8");
       }
       readPid() {
-        if (!fs8__namespace.existsSync(this.pidPath)) return null;
-        const raw = fs8__namespace.readFileSync(this.pidPath, "utf-8").trim();
+        if (!fs9__namespace.existsSync(this.pidPath)) return null;
+        const raw = fs9__namespace.readFileSync(this.pidPath, "utf-8").trim();
         const pid = Number.parseInt(raw, 10);
         return Number.isNaN(pid) ? null : pid;
       }
       removePid() {
-        if (fs8__namespace.existsSync(this.pidPath)) {
-          fs8__namespace.unlinkSync(this.pidPath);
+        if (fs9__namespace.existsSync(this.pidPath)) {
+          fs9__namespace.unlinkSync(this.pidPath);
         }
       }
       isProcessRunning(pid) {
@@ -11952,7 +12330,7 @@ function redactArgs(args) {
 function writeDiagnostic(message) {
   const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
   if (logPath) {
-    fs8__namespace.appendFileSync(logPath, message);
+    fs9__namespace.appendFileSync(logPath, message);
     return;
   }
   process.stderr.write(message);
@@ -12177,7 +12555,7 @@ ${body}`.trim()
 function resolveShellExecution(script, options2 = {}) {
   const platform = options2.platform ?? process.platform;
   const env = options2.env ?? process.env;
-  const fileExists = options2.fileExists ?? fs8__namespace.existsSync;
+  const fileExists = options2.fileExists ?? fs9__namespace.existsSync;
   if (platform === "win32") {
     const posixShell = usesPosixShellSyntax(script) ? findWindowsPosixShell(env, fileExists) : null;
     if (posixShell) {
@@ -12222,10 +12600,10 @@ function findWindowsPosixShell(env, fileExists) {
     if (fileExists(candidate)) return candidate;
   }
   const pathValue = env.Path ?? env.PATH ?? "";
-  for (const dir of pathValue.split(path__namespace.win32.delimiter)) {
+  for (const dir of pathValue.split(path11__namespace.win32.delimiter)) {
     if (!dir) continue;
     for (const executable of POSIX_SHELL_CANDIDATES) {
-      const candidate = path__namespace.win32.join(dir, executable);
+      const candidate = path11__namespace.win32.join(dir, executable);
       if (fileExists(candidate) && !isWindowsWslLauncher(candidate)) {
         return candidate;
       }
@@ -12234,13 +12612,13 @@ function findWindowsPosixShell(env, fileExists) {
   return null;
 }
 function isWindowsWslLauncher(candidate) {
-  const normalized = path__namespace.win32.normalize(candidate).toLowerCase();
+  const normalized = path11__namespace.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) {
-    fs8__namespace.appendFileSync(logPath, message);
+    fs9__namespace.appendFileSync(logPath, message);
     return;
   }
   process.stderr.write(message);
@@ -12379,7 +12757,7 @@ var init_ShellExecutor = __esm({
 function isStreamingTaskExecutor(executor) {
   return "executeStreaming" in executor && typeof executor.executeStreaming === "function";
 }
-var init_types = __esm({
+var init_types2 = __esm({
   "../../packages/serviceme-core/src/scheduled-tasks/executors/types.ts"() {
   }
 });
@@ -12398,7 +12776,7 @@ var init_executors = __esm({
     init_GithubCopilotCliExecutor();
     init_HttpRequestExecutor();
     init_ShellExecutor();
-    init_types();
+    init_types2();
     executors = {
       shell: new ShellExecutor(),
       http_request: new HttpRequestExecutor(),
@@ -12445,27 +12823,27 @@ var init_TaskConfigManager = __esm({
     CONFIG_FILE = "scheduled-tasks.json";
     TaskConfigManager = class {
       constructor(workspacePath) {
-        this.configPath = path__namespace.join(workspacePath, CONFIG_DIR3, CONFIG_FILE);
+        this.configPath = path11__namespace.join(workspacePath, CONFIG_DIR3, CONFIG_FILE);
       }
       getConfigPath() {
         return this.configPath;
       }
       readConfig() {
-        if (!fs8__namespace.existsSync(this.configPath)) {
+        if (!fs9__namespace.existsSync(this.configPath)) {
           return emptyConfig();
         }
-        const raw = fs8__namespace.readFileSync(this.configPath, "utf-8");
+        const raw = fs9__namespace.readFileSync(this.configPath, "utf-8");
         const parsed = JSON.parse(raw);
         return parsed;
       }
       writeConfig(config) {
-        const dir = path__namespace.dirname(this.configPath);
-        if (!fs8__namespace.existsSync(dir)) {
-          fs8__namespace.mkdirSync(dir, { recursive: true });
+        const dir = path11__namespace.dirname(this.configPath);
+        if (!fs9__namespace.existsSync(dir)) {
+          fs9__namespace.mkdirSync(dir, { recursive: true });
         }
         const tmp = `${this.configPath}.tmp`;
-        fs8__namespace.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
-        fs8__namespace.renameSync(tmp, this.configPath);
+        fs9__namespace.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
+        fs9__namespace.renameSync(tmp, this.configPath);
       }
       listTasks() {
         return this.readConfig().tasks;
@@ -12576,7 +12954,7 @@ function resolveTaskExecutionPayload(taskType, payload, workspacePath) {
 var TaskExecutionEngine;
 var init_TaskExecutionEngine = __esm({
   "../../packages/serviceme-core/src/scheduled-tasks/TaskExecutionEngine.ts"() {
-    init_types();
+    init_types2();
     init_TaskConfigManager();
     TaskExecutionEngine = class {
       constructor(getExecutor2) {
@@ -12769,17 +13147,17 @@ var init_TaskLogManager = __esm({
     MAX_LOGS = 200;
     TaskLogManager = class {
       constructor(workspacePath) {
-        this.logPath = path__namespace.join(workspacePath, CONFIG_DIR4, LOG_FILE2);
+        this.logPath = path11__namespace.join(workspacePath, CONFIG_DIR4, LOG_FILE2);
       }
       getLogPath() {
         return this.logPath;
       }
       readLogFile() {
-        if (!fs8__namespace.existsSync(this.logPath)) {
+        if (!fs9__namespace.existsSync(this.logPath)) {
           return emptyLogFile();
         }
         try {
-          const raw = fs8__namespace.readFileSync(this.logPath, "utf-8");
+          const raw = fs9__namespace.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) {
@@ -12795,21 +13173,21 @@ var init_TaskLogManager = __esm({
       }
       backupCorruptedFile() {
         try {
-          if (fs8__namespace.existsSync(this.logPath)) {
+          if (fs9__namespace.existsSync(this.logPath)) {
             const backupPath = `${this.logPath}.corrupted.${Date.now()}`;
-            fs8__namespace.copyFileSync(this.logPath, backupPath);
+            fs9__namespace.copyFileSync(this.logPath, backupPath);
           }
         } catch {
         }
       }
       writeLogFile(file) {
-        const dir = path__namespace.dirname(this.logPath);
-        if (!fs8__namespace.existsSync(dir)) {
-          fs8__namespace.mkdirSync(dir, { recursive: true });
+        const dir = path11__namespace.dirname(this.logPath);
+        if (!fs9__namespace.existsSync(dir)) {
+          fs9__namespace.mkdirSync(dir, { recursive: true });
         }
         const tmp = `${this.logPath}.tmp`;
-        fs8__namespace.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
-        fs8__namespace.renameSync(tmp, this.logPath);
+        fs9__namespace.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
+        fs9__namespace.renameSync(tmp, this.logPath);
       }
       appendLog(input) {
         const file = this.readLogFile();
@@ -12968,8 +13346,8 @@ var init_SchedulerDaemon = __esm({
         const configPath = this.configManager.getConfigPath();
         const dir = configPath.substring(0, configPath.lastIndexOf("/"));
         try {
-          if (fs8__namespace.existsSync(dir)) {
-            this.watcher = fs8__namespace.watch(dir, (_eventType, filename) => {
+          if (fs9__namespace.existsSync(dir)) {
+            this.watcher = fs9__namespace.watch(dir, (_eventType, filename) => {
               if (filename === "scheduled-tasks.json") {
                 this.logger.log("info", "Config file changed, reconciling...");
               }
@@ -13105,9 +13483,202 @@ var init_scheduled_tasks2 = __esm({
   }
 });
 
+// ../../packages/serviceme-core/src/skills/SkillCatalogClient.ts
+var SkillCatalogClient;
+var init_SkillCatalogClient = __esm({
+  "../../packages/serviceme-core/src/skills/SkillCatalogClient.ts"() {
+    SkillCatalogClient = class {
+      constructor(options2 = {}) {
+        this.fetchImpl = options2.fetchImpl ?? fetch;
+        this.baseUrl = options2.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()
+        };
+      }
+    };
+  }
+});
+
+// ../../packages/serviceme-core/src/skills/SkillReconciler.ts
+var SkillReconciler;
+var init_SkillReconciler = __esm({
+  "../../packages/serviceme-core/src/skills/SkillReconciler.ts"() {
+    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."
+        };
+      }
+    };
+  }
+});
+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 USER_SKILL_MARKER_FILE, WORKSPACE_SKILLS_ROOT_RELATIVE, WORKSPACE_SKILLS_MARKER_RELATIVE, SAFE_LOCAL_ID_PATTERN2, SkillStore;
+var init_SkillStore = __esm({
+  "../../packages/serviceme-core/src/skills/SkillStore.ts"() {
+    USER_SKILL_MARKER_FILE = ".ms-devtools-skill.json";
+    WORKSPACE_SKILLS_ROOT_RELATIVE = ".github/skills";
+    WORKSPACE_SKILLS_MARKER_RELATIVE = ".github/.ms-devtools-skills.yml";
+    SAFE_LOCAL_ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+    SkillStore = class {
+      constructor(options2) {
+        this.workspacePath = options2.workspacePath;
+        this.userSkillsRoot = options2.userSkillsRoot;
+        this.fileSystem = options2.fileSystem ?? fs12__namespace;
+      }
+      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 path11__namespace.join(this.userSkillsRoot, skillId);
+      }
+      async listWorkspaceSkillIds() {
+        const skillsRootPath = path11__namespace.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(
+          path11__namespace.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(
+            path11__namespace.join(this.getUserSkillPath(skillId), USER_SKILL_MARKER_FILE),
+            "utf-8"
+          );
+          const parsed = JSON.parse(marker);
+          return parsed.skillId === skillId;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// ../../packages/serviceme-core/src/skills/types.ts
+var init_types3 = __esm({
+  "../../packages/serviceme-core/src/skills/types.ts"() {
+  }
+});
+
+// ../../packages/serviceme-core/src/skills/index.ts
+var init_skills = __esm({
+  "../../packages/serviceme-core/src/skills/index.ts"() {
+    init_SkillCatalogClient();
+    init_SkillReconciler();
+    init_SkillStore();
+    init_types3();
+  }
+});
+
 // ../../packages/serviceme-core/src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AgentCatalogClient: () => AgentCatalogClient,
+  AgentReconciler: () => AgentReconciler,
+  AgentStore: () => AgentStore,
   DaemonLogger: () => DaemonLogger,
   EnvironmentInspector: () => EnvironmentInspector,
   GithubCopilotCliExecutor: () => GithubCopilotCliExecutor,
@@ -13117,6 +13688,10 @@ __export(src_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,
@@ -13134,6 +13709,7 @@ __export(src_exports, {
   matchesCron: () => matchesCron,
   moveFiles: () => moveFiles,
   noopLogger: () => noopLogger,
+  parseAgentToolPermissions: () => parseAgentToolPermissions,
   parseIntervalMs: () => parseIntervalMs,
   resolveTaskExecutionPayload: () => resolveTaskExecutionPayload,
   unzipFile: () => unzipFile,
@@ -13141,13 +13717,16 @@ __export(src_exports, {
 });
 var init_src2 = __esm({
   "../../packages/serviceme-core/src/index.ts"() {
+    init_agents();
     init_copilot2();
     init_environmentInspector();
     init_imageTools();
     init_jsonTools();
     init_logger();
+    init_permissions();
     init_projectTools();
     init_scheduled_tasks2();
+    init_skills();
     init_fileUtils();
   }
 });
@@ -13198,48 +13777,954 @@ function getStringFlag(parsed, name) {
   return typeof value === "string" ? value : void 0;
 }
 
-// src/commands/bridge.ts
+// src/commands/agent.ts
 init_src2();
-
-// src/bridge/BridgeServer.ts
 init_src();
 
-// src/version.ts
-var SERVICEME_CLI_NAME = "serviceme";
-var SERVICEME_CLI_VERSION = "0.1.5";
-
-// src/bridge/ndjson.ts
-function writeBridgeMessage(message) {
-  process.stdout.write(`${JSON.stringify(message)}
+// src/output.ts
+init_src();
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value)}
 `);
 }
+function writeSuccess(data) {
+  writeJson(createCliSuccess(data));
+}
+function writeFailure(error) {
+  writeJson(createCliFailure(normalizeServicemeError(error)));
+}
 
-// src/bridge/TaskBridgeHandler.ts
-init_src2();
-var TaskBridgeHandler = class {
-  constructor(logger, emitEvent) {
-    this.logger = logger;
-    this.emitEvent = emitEvent;
-    this.engine = new TaskExecutionEngine(
-      (taskType) => getExecutor(taskType)
+// src/commands/agent.ts
+function normalizeAgentIdOrThrow(store, remoteId) {
+  try {
+    return store.normalizeRemoteAgentId(remoteId);
+  } catch {
+    throw createServicemeError("invalid_params", `Invalid agent id: ${remoteId}`);
+  }
+}
+async function runAgentCommand(parsed) {
+  const action = parsed.positionals[1];
+  const workspacePath = getStringFlag(parsed, "workspacePath");
+  if (!workspacePath) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --workspacePath <path>."
     );
-    this.engine.setListener({
-      onStarted: (params) => this.emitEvent("task.started", params),
-      onOutput: (params) => this.emitEvent("task.output", params),
-      onCompleted: (params) => this.emitEvent("task.completed", params),
-      onFailed: (params) => this.emitEvent("task.failed", params),
-      onCancelled: (params) => this.emitEvent("task.cancelled", params)
-    });
   }
-  async execute(snapshot) {
-    let earlyError;
-    const executePromise = this.engine.execute(snapshot).catch((err) => {
-      earlyError = err;
-    });
-    await Promise.resolve();
-    if (earlyError) {
-      throw earlyError;
-    }
+  const store = new AgentStore({
+    workspacePath,
+    userAgentsRoot: path11__namespace.join(os__namespace.homedir(), ".copilot", "agents")
+  });
+  const catalogClient = new AgentCatalogClient({
+    baseUrl: getStringFlag(parsed, "baseUrl")
+  });
+  const reconciler = new AgentReconciler({
+    agentStore: store,
+    catalogClient
+  });
+  switch (action) {
+    case "list":
+      writeSuccess(await handleList(store));
+      return;
+    case "install":
+      writeSuccess(await handleInstall(store, parsed));
+      return;
+    case "uninstall":
+      writeSuccess(await handleUninstall(store, workspacePath, parsed));
+      return;
+    case "move":
+      writeSuccess(await handleMove(store, workspacePath, parsed));
+      return;
+    case "marketplace":
+      writeSuccess(await handleMarketplace(store, catalogClient));
+      return;
+    case "permissions":
+      writeSuccess(
+        await handlePermissions(store, reconciler, workspacePath, parsed)
+      );
+      return;
+    default:
+      throw new Error(
+        "Unsupported agent command. Use list, install, uninstall, move, marketplace, or permissions."
+      );
+  }
+}
+async function handleList(store) {
+  const workspaceAgents = await store.listWorkspaceAgentIds();
+  const userAgents = await store.listUserAgentIds();
+  return {
+    agents: [
+      ...workspaceAgents.map((id) => ({ id, scope: "workspace" })),
+      ...userAgents.map((id) => ({ id, scope: "user" }))
+    ]
+  };
+}
+async function handleInstall(store, parsed) {
+  const remoteId = getStringFlag(parsed, "id");
+  if (!remoteId) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --id <remoteAgentId>."
+    );
+  }
+  const agentId = normalizeAgentIdOrThrow(store, remoteId);
+  if (!getBooleanFlag(parsed, "confirmed")) {
+    return {
+      changed: false,
+      scope: "workspace",
+      agentId,
+      status: "requires_confirmation",
+      message: "Install requires --confirmed."
+    };
+  }
+  const content = `---
+name: ${agentId}
+tools:
+  - run_in_terminal
+  - read_file
+---
+
+# ${agentId}
+`;
+  await store.writeAgentFiles(agentId, "workspace", [
+    {
+      path: `${agentId}.agent.md`,
+      content
+    }
+  ]);
+  await store.addInstalledAgent({
+    id: remoteId,
+    name: agentId,
+    scope: "workspace",
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    changed: true,
+    scope: "workspace",
+    agentId,
+    status: "success"
+  };
+}
+async function handleUninstall(store, workspacePath, parsed) {
+  const remoteId = getStringFlag(parsed, "id");
+  if (!remoteId) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --id <remoteAgentId>."
+    );
+  }
+  const agentId = normalizeAgentIdOrThrow(store, remoteId);
+  await fs12__namespace.rm(
+    path11__namespace.join(workspacePath, ".github", "agents", `${agentId}.agent.md`),
+    {
+      recursive: true,
+      force: true
+    }
+  );
+  await fs12__namespace.rm(path11__namespace.join(workspacePath, ".github", "agents", agentId), {
+    recursive: true,
+    force: true
+  });
+  await fs12__namespace.rm(path11__namespace.join(store.getUserAgentsRootPath(), `${agentId}.agent.md`), {
+    recursive: true,
+    force: true
+  });
+  await fs12__namespace.rm(path11__namespace.join(store.getUserAgentsRootPath(), agentId), {
+    recursive: true,
+    force: true
+  });
+  await store.removeInstalledAgent(remoteId);
+  return {
+    changed: true,
+    agentId
+  };
+}
+async function handleMove(store, workspacePath, parsed) {
+  const remoteId = getStringFlag(parsed, "id");
+  const to = getStringFlag(parsed, "to");
+  if (!remoteId || !to) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --id <remoteAgentId> and --to <workspace|user>."
+    );
+  }
+  if (to !== "workspace" && to !== "user") {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --to value to be workspace or user."
+    );
+  }
+  const agentId = normalizeAgentIdOrThrow(store, remoteId);
+  const workspaceFlatPath = path11__namespace.join(
+    workspacePath,
+    ".github",
+    "agents",
+    `${agentId}.agent.md`
+  );
+  const userFlatPath = path11__namespace.join(
+    store.getUserAgentsRootPath(),
+    `${agentId}.agent.md`
+  );
+  if (to === "user") {
+    await moveEntry(workspaceFlatPath, userFlatPath);
+    return {
+      changed: true,
+      fromScope: "workspace",
+      toScope: "user",
+      agentId
+    };
+  }
+  await moveEntry(userFlatPath, workspaceFlatPath);
+  return {
+    changed: true,
+    fromScope: "user",
+    toScope: "workspace",
+    agentId
+  };
+}
+async function handleMarketplace(store, catalogClient) {
+  const [catalog, workspaceAgentIds, userAgentIds] = await Promise.all([
+    catalogClient.getCatalog(),
+    store.listWorkspaceAgentIds(),
+    store.listUserAgentIds()
+  ]);
+  const scopesById = /* @__PURE__ */ new Map();
+  for (const agentId of workspaceAgentIds) {
+    scopesById.set(agentId, ["workspace"]);
+  }
+  for (const agentId of userAgentIds) {
+    const existing = scopesById.get(agentId);
+    if (existing) {
+      existing.push("user");
+    } else {
+      scopesById.set(agentId, ["user"]);
+    }
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const agent of catalog.agents) {
+    const normalizedId = normalizeAgentIdOrThrow(store, agent.id);
+    merged.set(normalizedId, {
+      id: normalizedId,
+      displayName: agent.displayName,
+      description: agent.description,
+      source: "catalog",
+      scopes: scopesById.get(normalizedId) ?? []
+    });
+  }
+  for (const [agentId, scopes] of scopesById) {
+    if (merged.has(agentId)) {
+      continue;
+    }
+    merged.set(agentId, {
+      id: agentId,
+      displayName: agentId,
+      description: "Local installed agent",
+      source: "local",
+      scopes
+    });
+  }
+  return {
+    agents: [...merged.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    fetchedAt: catalog.fetchedAt
+  };
+}
+async function handlePermissions(store, reconciler, workspacePath, parsed) {
+  const remoteId = getStringFlag(parsed, "id");
+  const scopeFlag = getStringFlag(parsed, "scope");
+  if (!remoteId) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --id <remoteAgentId>."
+    );
+  }
+  if (scopeFlag !== void 0 && scopeFlag !== "workspace" && scopeFlag !== "user") {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --scope value to be workspace or user."
+    );
+  }
+  const agentId = normalizeAgentIdOrThrow(store, remoteId);
+  const requestedScope = scopeFlag ?? "workspace";
+  const scope = requestedScope;
+  const content = await readAgentContent(store, workspacePath, agentId, scope);
+  const summary = reconciler.getPermissionSummary(agentId, agentId, content);
+  return {
+    agentId,
+    scope,
+    summary
+  };
+}
+async function moveEntry(fromPath, toPath) {
+  await fs12__namespace.mkdir(path11__namespace.dirname(toPath), { recursive: true });
+  try {
+    await fs12__namespace.rename(fromPath, toPath);
+  } catch {
+    await fs12__namespace.cp(fromPath, toPath, { recursive: true });
+    await fs12__namespace.rm(fromPath, { recursive: true, force: true });
+  }
+}
+async function readAgentContent(store, workspacePath, agentId, scope) {
+  const root2 = scope === "workspace" ? path11__namespace.join(workspacePath, store.getWorkspaceAgentsRootPath()) : store.getUserAgentsRootPath();
+  const candidates = [
+    path11__namespace.join(root2, `${agentId}.agent.md`),
+    path11__namespace.join(root2, agentId, `${agentId}.agent.md`)
+  ];
+  for (const candidate of candidates) {
+    try {
+      return await fs12__namespace.readFile(candidate, "utf8");
+    } catch {
+    }
+  }
+  throw createServicemeError(
+    "not_found",
+    `Agent file not found for ${agentId} in ${scope} scope.`
+  );
+}
+
+// src/commands/bridge.ts
+init_src2();
+
+// src/bridge/BridgeServer.ts
+init_src();
+
+// src/version.ts
+var SERVICEME_CLI_NAME = "serviceme";
+var SERVICEME_CLI_VERSION = "0.1.6";
+
+// src/bridge/AgentBridgeHandler.ts
+init_src2();
+init_src();
+function normalizeAgentIdOrThrow2(store, remoteId) {
+  try {
+    return store.normalizeRemoteAgentId(remoteId);
+  } catch {
+    throw createServicemeError("invalid_params", `Invalid agent id: ${remoteId}`);
+  }
+}
+var AgentBridgeHandler = class {
+  async getMarketplaceState(params) {
+    const context = this.createContext(params.workspacePath);
+    const [catalog, workspaceAgentIds, userAgentIds] = await Promise.all([
+      context.catalogClient.getCatalog(),
+      context.store.listWorkspaceAgentIds(),
+      context.store.listUserAgentIds()
+    ]);
+    const workspaceSet = new Set(workspaceAgentIds);
+    const userSet = new Set(userAgentIds);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const byId = /* @__PURE__ */ new Map();
+    for (const agent of catalog.agents) {
+      const agentId = normalizeAgentIdOrThrow2(context.store, agent.id);
+      const workspaceInstalled = workspaceSet.has(agentId);
+      const userInstalled = userSet.has(agentId);
+      byId.set(agentId, {
+        id: agentId,
+        displayName: agent.displayName,
+        description: agent.description,
+        version: agent.version,
+        updatedAt: agent.updatedAt,
+        categoryId: agent.categoryId,
+        isCatalogAgent: true,
+        recommended: agent.recommended,
+        installCount: agent.installCount,
+        ownerScope: agent.ownerScope,
+        ownerKind: agent.ownerKind,
+        hasConflict: agent.hasConflict,
+        tools: agent.tools,
+        source: agent.source,
+        localAgentPath: workspaceInstalled || userInstalled ? workspaceInstalled ? path11__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceAgentsRootPath(),
+          `${agentId}.agent.md`
+        ) : path11__namespace.join(
+          context.store.getUserAgentsRootPath(),
+          `${agentId}.agent.md`
+        ) : void 0,
+        canPublish: agent.canPublish,
+        workspaceState: this.makeScopeState(
+          "workspace",
+          workspaceInstalled,
+          path11__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          userInstalled,
+          path11__namespace.join(
+            context.store.getUserAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        )
+      });
+    }
+    for (const agentId of workspaceAgentIds) {
+      if (byId.has(agentId)) {
+        continue;
+      }
+      byId.set(agentId, {
+        id: agentId,
+        displayName: agentId,
+        description: "Local installed agent",
+        version: "0.0.0",
+        updatedAt: now,
+        isCatalogAgent: false,
+        recommended: false,
+        installCount: 0,
+        hasConflict: false,
+        tools: [],
+        source: "local",
+        localAgentPath: path11__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceAgentsRootPath(),
+          `${agentId}.agent.md`
+        ),
+        workspaceState: this.makeScopeState(
+          "workspace",
+          true,
+          path11__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          userSet.has(agentId),
+          path11__namespace.join(
+            context.store.getUserAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        )
+      });
+    }
+    for (const agentId of userAgentIds) {
+      if (byId.has(agentId)) {
+        continue;
+      }
+      byId.set(agentId, {
+        id: agentId,
+        displayName: agentId,
+        description: "Local installed agent",
+        version: "0.0.0",
+        updatedAt: now,
+        isCatalogAgent: false,
+        recommended: false,
+        installCount: 0,
+        hasConflict: false,
+        tools: [],
+        source: "local",
+        localAgentPath: path11__namespace.join(
+          context.store.getUserAgentsRootPath(),
+          `${agentId}.agent.md`
+        ),
+        workspaceState: this.makeScopeState(
+          "workspace",
+          workspaceSet.has(agentId),
+          path11__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          true,
+          path11__namespace.join(
+            context.store.getUserAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        )
+      });
+    }
+    return {
+      configPath: path11__namespace.join(
+        context.workspacePath,
+        context.store.getWorkspaceStateFilePath()
+      ),
+      userAgentsPath: context.userAgentsRoot,
+      agents: [...byId.values()].sort((a, b) => a.id.localeCompare(b.id)),
+      installedAgentIds: [.../* @__PURE__ */ new Set([...workspaceAgentIds, ...userAgentIds])],
+      workspaceOpen: true
+    };
+  }
+  async mutate(request) {
+    const context = this.createContext();
+    const agentId = normalizeAgentIdOrThrow2(context.store, request.agentId);
+    const mutateResult = await context.reconciler.mutate({
+      ...request,
+      agentId
+    });
+    if (mutateResult.status === "success") {
+      await this.applyMutationSideEffect(context, {
+        ...request,
+        agentId
+      });
+    }
+    return {
+      state: await this.getMarketplaceState({
+        workspacePath: context.workspacePath
+      }),
+      agentId,
+      targetScope: request.targetScope,
+      action: request.action,
+      changed: mutateResult.changed,
+      status: mutateResult.status,
+      message: mutateResult.message,
+      tools: mutateResult.tools
+    };
+  }
+  async permissions(params) {
+    const context = this.createContext();
+    const agentId = normalizeAgentIdOrThrow2(context.store, params.agentId);
+    const scope = params.scope ?? "workspace";
+    const content = await this.readAgentContent(context, agentId, scope);
+    return context.reconciler.getPermissionSummary(agentId, agentId, content);
+  }
+  createContext(workspacePath) {
+    const resolvedWorkspacePath = workspacePath ?? process.cwd();
+    const userAgentsRoot = path11__namespace.join(os__namespace.homedir(), ".copilot", "agents");
+    const store = new AgentStore({
+      workspacePath: resolvedWorkspacePath,
+      userAgentsRoot
+    });
+    const catalogClient = new AgentCatalogClient();
+    const reconciler = new AgentReconciler({
+      agentStore: store,
+      catalogClient
+    });
+    return {
+      workspacePath: resolvedWorkspacePath,
+      userAgentsRoot,
+      store,
+      catalogClient,
+      reconciler
+    };
+  }
+  makeScopeState(scope, installed, agentPath) {
+    if (installed) {
+      return {
+        scope,
+        status: "installed",
+        path: agentPath,
+        isInstalled: true,
+        canInstall: false,
+        canUninstall: true,
+        canRemove: false,
+        canMoveHere: false
+      };
+    }
+    return {
+      scope,
+      status: "absent",
+      isInstalled: false,
+      canInstall: true,
+      canUninstall: false,
+      canRemove: false,
+      canMoveHere: true
+    };
+  }
+  async applyMutationSideEffect(context, request) {
+    const workspaceFlatPath = path11__namespace.join(
+      context.workspacePath,
+      context.store.getWorkspaceAgentsRootPath(),
+      `${request.agentId}.agent.md`
+    );
+    const userFlatPath = path11__namespace.join(
+      context.store.getUserAgentsRootPath(),
+      `${request.agentId}.agent.md`
+    );
+    switch (request.action) {
+      case "install":
+        if (request.targetScope === "workspace") {
+          await this.writeDefaultAgentFile(workspaceFlatPath, request.agentId);
+        } else {
+          await this.writeDefaultAgentFile(userFlatPath, request.agentId);
+        }
+        return;
+      case "uninstall":
+        if (request.targetScope === "workspace") {
+          await fs12__namespace.rm(workspaceFlatPath, { recursive: true, force: true });
+        } else {
+          await fs12__namespace.rm(userFlatPath, { recursive: true, force: true });
+        }
+        return;
+      case "move":
+        if (request.targetScope === "workspace") {
+          await this.moveEntry(userFlatPath, workspaceFlatPath);
+        } else {
+          await this.moveEntry(workspaceFlatPath, userFlatPath);
+        }
+        return;
+      default:
+        return;
+    }
+  }
+  async moveEntry(fromPath, toPath) {
+    await fs12__namespace.mkdir(path11__namespace.dirname(toPath), { recursive: true });
+    try {
+      await fs12__namespace.rename(fromPath, toPath);
+    } catch {
+      await fs12__namespace.cp(fromPath, toPath, { recursive: true });
+      await fs12__namespace.rm(fromPath, { recursive: true, force: true });
+    }
+  }
+  async writeDefaultAgentFile(targetPath, agentId) {
+    await fs12__namespace.mkdir(path11__namespace.dirname(targetPath), { recursive: true });
+    await fs12__namespace.writeFile(
+      targetPath,
+      `---
+name: ${agentId}
+tools:
+  - run_in_terminal
+  - read_file
+---
+
+# ${agentId}
+`,
+      "utf8"
+    );
+  }
+  async readAgentContent(context, agentId, scope) {
+    const root2 = scope === "workspace" ? path11__namespace.join(
+      context.workspacePath,
+      context.store.getWorkspaceAgentsRootPath()
+    ) : context.store.getUserAgentsRootPath();
+    const candidates = [
+      path11__namespace.join(root2, `${agentId}.agent.md`),
+      path11__namespace.join(root2, agentId, `${agentId}.agent.md`)
+    ];
+    for (const candidate of candidates) {
+      try {
+        return await fs12__namespace.readFile(candidate, "utf8");
+      } catch {
+      }
+    }
+    throw createServicemeError(
+      "not_found",
+      `Agent file not found for ${agentId} in ${scope} scope.`
+    );
+  }
+};
+
+// src/bridge/ndjson.ts
+function writeBridgeMessage(message) {
+  process.stdout.write(`${JSON.stringify(message)}
+`);
+}
+
+// src/bridge/SkillBridgeHandler.ts
+init_src2();
+init_src();
+function normalizeSkillIdOrThrow(store, remoteId) {
+  try {
+    return store.normalizeRemoteSkillId(remoteId);
+  } catch {
+    throw createServicemeError("invalid_params", `Invalid skill id: ${remoteId}`);
+  }
+}
+var SkillBridgeHandler = class {
+  async getMarketplaceState(params) {
+    const context = this.createContext(params.workspacePath);
+    const [catalog, workspaceSkillIds, userSkillIds] = await Promise.all([
+      context.catalogClient.getCatalog(),
+      context.store.listWorkspaceSkillIds(),
+      context.store.listUserSkillIds()
+    ]);
+    const workspaceSet = new Set(workspaceSkillIds);
+    const userSet = new Set(userSkillIds);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const byId = /* @__PURE__ */ new Map();
+    for (const skill of catalog.skills) {
+      const skillId = normalizeSkillIdOrThrow(context.store, skill.id);
+      const workspaceInstalled = workspaceSet.has(skillId);
+      const userInstalled = userSet.has(skillId);
+      byId.set(skillId, {
+        id: skillId,
+        displayName: skill.displayName,
+        description: skill.description,
+        version: skill.version,
+        updatedAt: skill.updatedAt,
+        categoryId: skill.categoryId,
+        enabled: skill.enabled,
+        isCatalogSkill: true,
+        recommended: skill.recommended,
+        installCount: skill.installCount,
+        requiresSetup: skill.requiresSetup,
+        setupHint: skill.setupHint,
+        homepage: skill.homepage,
+        ownerScope: skill.ownerScope,
+        ownerKind: skill.ownerKind,
+        hasConflict: skill.hasConflict,
+        hasScripts: skill.hasScripts,
+        hasHooks: skill.hasHooks,
+        source: skill.source,
+        localSkillPath: workspaceInstalled || userInstalled ? workspaceInstalled ? path11__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceSkillPath(skillId)
+        ) : context.store.getUserSkillPath(skillId) : void 0,
+        canPublish: skill.canPublish,
+        workspaceState: this.makeScopeState(
+          "workspace",
+          workspaceInstalled,
+          path11__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceSkillPath(skillId)
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          userInstalled,
+          context.store.getUserSkillPath(skillId)
+        )
+      });
+    }
+    for (const skillId of workspaceSkillIds) {
+      if (byId.has(skillId)) {
+        continue;
+      }
+      byId.set(skillId, {
+        id: skillId,
+        displayName: skillId,
+        description: "Local installed skill",
+        version: "0.0.0",
+        updatedAt: now,
+        isCatalogSkill: false,
+        recommended: false,
+        installCount: 0,
+        hasConflict: false,
+        source: "local",
+        localSkillPath: path11__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceSkillPath(skillId)
+        ),
+        workspaceState: this.makeScopeState(
+          "workspace",
+          true,
+          path11__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceSkillPath(skillId)
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          userSet.has(skillId),
+          context.store.getUserSkillPath(skillId)
+        )
+      });
+    }
+    for (const skillId of userSkillIds) {
+      if (byId.has(skillId)) {
+        continue;
+      }
+      byId.set(skillId, {
+        id: skillId,
+        displayName: skillId,
+        description: "Local installed skill",
+        version: "0.0.0",
+        updatedAt: now,
+        isCatalogSkill: false,
+        recommended: false,
+        installCount: 0,
+        hasConflict: false,
+        source: "local",
+        localSkillPath: context.store.getUserSkillPath(skillId),
+        workspaceState: this.makeScopeState(
+          "workspace",
+          workspaceSet.has(skillId),
+          path11__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceSkillPath(skillId)
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          true,
+          context.store.getUserSkillPath(skillId)
+        )
+      });
+    }
+    return {
+      configPath: path11__namespace.join(
+        context.workspacePath,
+        context.store.getWorkspaceMarkerPath()
+      ),
+      userSkillsPath: context.userSkillsRoot,
+      skills: [...byId.values()].sort((a, b) => a.id.localeCompare(b.id)),
+      enabledSkillIds: [],
+      recommendedSkillIds: catalog.skills.filter((skill) => skill.recommended).map((skill) => context.store.normalizeRemoteSkillId(skill.id)),
+      onboardingRequired: false,
+      hasPersistedSelection: false,
+      workspaceOpen: true
+    };
+  }
+  async mutate(request) {
+    const context = this.createContext();
+    const skillId = normalizeSkillIdOrThrow(context.store, request.skillId);
+    const mutateResult = await context.reconciler.mutate({
+      ...request,
+      skillId
+    });
+    if (mutateResult.status === "success") {
+      await this.applyMutationSideEffect(context, {
+        ...request,
+        skillId
+      });
+    }
+    return {
+      state: await this.getMarketplaceState({
+        workspacePath: context.workspacePath
+      }),
+      skillId,
+      targetScope: request.targetScope,
+      action: request.action,
+      changed: mutateResult.changed,
+      status: mutateResult.status,
+      message: mutateResult.message,
+      hasScripts: mutateResult.hasScripts,
+      hasHooks: mutateResult.hasHooks
+    };
+  }
+  async reconcile(params) {
+    const state = await this.getMarketplaceState({
+      workspacePath: params.workspacePath,
+      forceRefresh: params.force
+    });
+    return {
+      state,
+      changed: false
+    };
+  }
+  async publishable(params) {
+    const context = this.createContext(params.workspacePath);
+    const workspaceSkillIds = await context.store.listWorkspaceSkillIds();
+    return {
+      skills: workspaceSkillIds.map((skillId) => ({
+        id: skillId,
+        displayName: skillId,
+        path: path11__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceSkillPath(skillId)
+        )
+      }))
+    };
+  }
+  createContext(workspacePath) {
+    const resolvedWorkspacePath = workspacePath ?? process.cwd();
+    const userSkillsRoot = path11__namespace.join(os__namespace.homedir(), ".agents", "skills");
+    const store = new SkillStore({
+      workspacePath: resolvedWorkspacePath,
+      userSkillsRoot
+    });
+    const catalogClient = new SkillCatalogClient();
+    const reconciler = new SkillReconciler({
+      skillStore: store,
+      catalogClient
+    });
+    return {
+      workspacePath: resolvedWorkspacePath,
+      userSkillsRoot,
+      store,
+      catalogClient,
+      reconciler
+    };
+  }
+  makeScopeState(scope, installed, skillPath) {
+    if (installed) {
+      return {
+        scope,
+        status: "installed",
+        path: skillPath,
+        isInstalled: true,
+        canInstall: false,
+        canUninstall: true,
+        canRemove: false,
+        canMoveHere: false
+      };
+    }
+    return {
+      scope,
+      status: "absent",
+      isInstalled: false,
+      canInstall: true,
+      canUninstall: false,
+      canRemove: false,
+      canMoveHere: true
+    };
+  }
+  async applyMutationSideEffect(context, request) {
+    const workspaceSkillPath = path11__namespace.join(
+      context.workspacePath,
+      context.store.getWorkspaceSkillPath(request.skillId)
+    );
+    const userSkillPath = context.store.getUserSkillPath(request.skillId);
+    switch (request.action) {
+      case "install":
+        if (request.targetScope === "workspace") {
+          await fs12__namespace.mkdir(workspaceSkillPath, { recursive: true });
+        } else {
+          await fs12__namespace.mkdir(userSkillPath, { recursive: true });
+          await context.store.writeManagedUserSkillMarker(request.skillId);
+        }
+        return;
+      case "uninstall":
+        if (request.targetScope === "workspace") {
+          await fs12__namespace.rm(workspaceSkillPath, { recursive: true, force: true });
+        } else {
+          await fs12__namespace.rm(userSkillPath, { recursive: true, force: true });
+        }
+        return;
+      case "move":
+        if (request.targetScope === "workspace") {
+          await this.moveDirectory(userSkillPath, workspaceSkillPath);
+        } else {
+          await this.moveDirectory(workspaceSkillPath, userSkillPath);
+          await context.store.writeManagedUserSkillMarker(request.skillId);
+        }
+        return;
+      default:
+        return;
+    }
+  }
+  async moveDirectory(fromPath, toPath) {
+    await fs12__namespace.mkdir(path11__namespace.dirname(toPath), { recursive: true });
+    try {
+      await fs12__namespace.rename(fromPath, toPath);
+    } catch {
+      await fs12__namespace.cp(fromPath, toPath, { recursive: true });
+      await fs12__namespace.rm(fromPath, { recursive: true, force: true });
+    }
+  }
+};
+
+// src/bridge/TaskBridgeHandler.ts
+init_src2();
+var TaskBridgeHandler = class {
+  constructor(logger, emitEvent) {
+    this.logger = logger;
+    this.emitEvent = emitEvent;
+    this.engine = new TaskExecutionEngine(
+      (taskType) => getExecutor(taskType)
+    );
+    this.engine.setListener({
+      onStarted: (params) => this.emitEvent("task.started", params),
+      onOutput: (params) => this.emitEvent("task.output", params),
+      onCompleted: (params) => this.emitEvent("task.completed", params),
+      onFailed: (params) => this.emitEvent("task.failed", params),
+      onCancelled: (params) => this.emitEvent("task.cancelled", params)
+    });
+  }
+  async execute(snapshot) {
+    let earlyError;
+    const executePromise = this.engine.execute(snapshot).catch((err) => {
+      earlyError = err;
+    });
+    await Promise.resolve();
+    if (earlyError) {
+      throw earlyError;
+    }
     executePromise.then(void 0, (err) => {
       this.logger.error("Task execution background error", err);
     });
@@ -13262,7 +14747,9 @@ var CAPABILITIES = {
   bridge: true,
   json: 1,
   env: 1,
-  tasks: 1
+  tasks: 1,
+  skills: 1,
+  agents: 1
 };
 var BridgeServer = class {
   constructor(logger) {
@@ -13271,6 +14758,8 @@ var BridgeServer = class {
     this.taskHandler = new TaskBridgeHandler(logger, (event, params) => {
       this.writeEvent(event, params);
     });
+    this.skillHandler = new SkillBridgeHandler();
+    this.agentHandler = new AgentBridgeHandler();
   }
   async run() {
     const reader = readline__namespace.createInterface({
@@ -13376,6 +14865,56 @@ var BridgeServer = class {
           this.writeSuccess(request.id, result);
           return;
         }
+        case "skill.marketplace-state": {
+          const skillRequest = request;
+          const result = await this.skillHandler.getMarketplaceState(
+            skillRequest.params
+          );
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "skill.mutate": {
+          const skillRequest = request;
+          const result = await this.skillHandler.mutate(skillRequest.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "skill.reconcile": {
+          const skillRequest = request;
+          const result = await this.skillHandler.reconcile(skillRequest.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "skill.publishable": {
+          const skillRequest = request;
+          const result = await this.skillHandler.publishable(
+            skillRequest.params
+          );
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "agent.marketplace-state": {
+          const agentRequest = request;
+          const result = await this.agentHandler.getMarketplaceState(
+            agentRequest.params
+          );
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "agent.mutate": {
+          const agentRequest = request;
+          const result = await this.agentHandler.mutate(agentRequest.params);
+          this.writeSuccess(request.id, result);
+          return;
+        }
+        case "agent.permissions": {
+          const agentRequest = request;
+          const result = await this.agentHandler.permissions(
+            agentRequest.params
+          );
+          this.writeSuccess(request.id, result);
+          return;
+        }
         default:
           this.writeError(
             request.id,
@@ -13425,21 +14964,6 @@ async function runBridgeCommand() {
 
 // src/commands/copilot.ts
 init_src2();
-
-// src/output.ts
-init_src();
-function writeJson(value) {
-  process.stdout.write(`${JSON.stringify(value)}
-`);
-}
-function writeSuccess(data) {
-  writeJson(createCliSuccess(data));
-}
-function writeFailure(error) {
-  writeJson(createCliFailure(normalizeServicemeError(error)));
-}
-
-// src/commands/copilot.ts
 async function runCopilotCommand(parsed) {
   const action = parsed.positionals[1];
   switch (action) {
@@ -13559,7 +15083,7 @@ async function runImageCommand(parsed) {
 init_src2();
 async function readCommandInput(options2) {
   if (options2.filePath) {
-    return fs2__namespace.readFile(options2.filePath, "utf8");
+    return fs12__namespace.readFile(options2.filePath, "utf8");
   }
   if (options2.stdin) {
     return readStdin();
@@ -13698,7 +15222,7 @@ async function runScheduleCommand(parsed) {
       await handleCreate(parsed);
       return;
     case "list":
-      handleList(parsed);
+      handleList2(parsed);
       return;
     case "get":
       handleGet(parsed);
@@ -13733,7 +15257,7 @@ function requireWorkspace(parsed) {
       "Missing required flag: --workspacePath"
     );
   }
-  if (!fs8__namespace.existsSync(wp)) {
+  if (!fs9__namespace.existsSync(wp)) {
     throw createServicemeError(
       "workspace_not_found",
       `Workspace path does not exist: ${wp}`
@@ -13930,7 +15454,7 @@ async function handleCreate(parsed) {
   const task = mgr.createTask(input);
   writeSuccess({ task });
 }
-function handleList(parsed) {
+function handleList2(parsed) {
   const wp = requireWorkspace(parsed);
   const mgr = new TaskConfigManager(wp);
   const tasks = mgr.listTasks();
@@ -14302,7 +15826,7 @@ function requireWorkspace2(parsed) {
       "Missing required flag: --workspacePath"
     );
   }
-  if (!fs8__namespace.existsSync(wp)) {
+  if (!fs9__namespace.existsSync(wp)) {
     throw createServicemeError(
       "workspace_not_found",
       `Workspace path does not exist: ${wp}`
@@ -14329,10 +15853,10 @@ function handleStart(parsed) {
       "Cannot determine CLI path for daemon spawn"
     );
   }
-  const logPath = path__namespace.join(wp, ".serviceme", "scheduler.log");
-  const logDir = path__namespace.dirname(logPath);
-  if (!fs8__namespace.existsSync(logDir)) {
-    fs8__namespace.mkdirSync(logDir, { recursive: true });
+  const logPath = path11__namespace.join(wp, ".serviceme", "scheduler.log");
+  const logDir = path11__namespace.dirname(logPath);
+  if (!fs9__namespace.existsSync(logDir)) {
+    fs9__namespace.mkdirSync(logDir, { recursive: true });
   }
   const spawnCmd = process.execPath;
   const spawnArgs = [
@@ -14345,7 +15869,7 @@ function handleStart(parsed) {
     logPath
   ];
   if (process.platform === "win32") {
-    fs8__namespace.appendFileSync(
+    fs9__namespace.appendFileSync(
       logPath,
       `[scheduler:start] spawning daemon via hidden PowerShell Start-Process: cmd=${spawnCmd}, args=${JSON.stringify(spawnArgs)}, platform=${process.platform}, windowsHide=true
 `
@@ -14355,9 +15879,9 @@ function handleStart(parsed) {
     writeSuccess({ pid: pid2, status: "started", workspacePath: wp });
     return;
   }
-  const out = fs8__namespace.openSync(logPath, "a");
-  const err = fs8__namespace.openSync(logPath, "a");
-  fs8__namespace.appendFileSync(
+  const out = fs9__namespace.openSync(logPath, "a");
+  const err = fs9__namespace.openSync(logPath, "a");
+  fs9__namespace.appendFileSync(
     logPath,
     `[scheduler:start] spawning daemon: cmd=${spawnCmd}, args=${JSON.stringify(spawnArgs)}, platform=${process.platform}, detached=true, windowsHide=true
 `
@@ -14468,7 +15992,7 @@ function handleStatus(parsed) {
   let uptimeSeconds = null;
   if (pid !== null) {
     try {
-      const stat2 = fs8__namespace.statSync(pidMgr.getPidPath());
+      const stat2 = fs9__namespace.statSync(pidMgr.getPidPath());
       uptimeSeconds = Math.floor((Date.now() - stat2.mtimeMs) / 1e3);
     } catch {
       uptimeSeconds = null;
@@ -14539,6 +16063,279 @@ function writeDescribe2(action) {
   }
 }
 
+// src/commands/skill.ts
+init_src2();
+init_src();
+function normalizeSkillIdOrThrow2(store, remoteId) {
+  try {
+    return store.normalizeRemoteSkillId(remoteId);
+  } catch {
+    throw createServicemeError("invalid_params", `Invalid skill id: ${remoteId}`);
+  }
+}
+async function runSkillCommand(parsed) {
+  const action = parsed.positionals[1];
+  const workspacePath = getStringFlag(parsed, "workspacePath");
+  if (!workspacePath) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --workspacePath <path>."
+    );
+  }
+  const store = new SkillStore({
+    workspacePath,
+    userSkillsRoot: path11__namespace.join(os__namespace.homedir(), ".agents", "skills")
+  });
+  const catalogClient = new SkillCatalogClient({
+    baseUrl: getStringFlag(parsed, "baseUrl")
+  });
+  const reconciler = new SkillReconciler({
+    skillStore: store,
+    catalogClient
+  });
+  switch (action) {
+    case "list":
+      writeSuccess(await handleList3(store));
+      return;
+    case "install":
+      writeSuccess(await handleInstall2(store, workspacePath, parsed));
+      return;
+    case "uninstall":
+      writeSuccess(await handleUninstall2(store, workspacePath, parsed));
+      return;
+    case "move":
+      writeSuccess(await handleMove2(store, workspacePath, parsed));
+      return;
+    case "marketplace":
+      writeSuccess(await handleMarketplace2(store, catalogClient));
+      return;
+    case "find":
+      writeSuccess(await handleFind(store, catalogClient, parsed));
+      return;
+    case "reconcile":
+      writeSuccess(await handleReconcile(store, reconciler));
+      return;
+    case "publishable":
+      writeSuccess(await handlePublishable(store, workspacePath));
+      return;
+    default:
+      throw new Error(
+        "Unsupported skill command. Use list, install, uninstall, move, marketplace, find, reconcile, or publishable."
+      );
+  }
+}
+async function handleList3(store) {
+  const workspaceSkills = await store.listWorkspaceSkillIds();
+  const userSkills = await store.listUserSkillIds();
+  return {
+    skills: [
+      ...workspaceSkills.map((id) => ({ id, scope: "workspace" })),
+      ...userSkills.map((id) => ({ id, scope: "user" }))
+    ]
+  };
+}
+async function handleInstall2(store, workspacePath, parsed) {
+  const remoteId = getStringFlag(parsed, "id");
+  if (!remoteId) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --id <remoteSkillId>."
+    );
+  }
+  const skillId = normalizeSkillIdOrThrow2(store, remoteId);
+  if (!getBooleanFlag(parsed, "confirmed")) {
+    return {
+      changed: false,
+      scope: "workspace",
+      skillId,
+      status: "requires_confirmation",
+      message: "Install requires --confirmed."
+    };
+  }
+  const workspaceSkillDir = path11__namespace.join(
+    workspacePath,
+    store.getWorkspaceSkillPath(skillId)
+  );
+  await fs12__namespace.mkdir(workspaceSkillDir, { recursive: true });
+  return {
+    changed: true,
+    scope: "workspace",
+    skillId,
+    status: "success"
+  };
+}
+async function handleUninstall2(store, workspacePath, parsed) {
+  const remoteId = getStringFlag(parsed, "id");
+  if (!remoteId) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --id <remoteSkillId>."
+    );
+  }
+  const skillId = normalizeSkillIdOrThrow2(store, remoteId);
+  await fs12__namespace.rm(path11__namespace.join(workspacePath, store.getWorkspaceSkillPath(skillId)), {
+    recursive: true,
+    force: true
+  });
+  await fs12__namespace.rm(store.getUserSkillPath(skillId), {
+    recursive: true,
+    force: true
+  });
+  return {
+    changed: true,
+    skillId
+  };
+}
+async function handleMove2(store, workspacePath, parsed) {
+  const remoteId = getStringFlag(parsed, "id");
+  const to = getStringFlag(parsed, "to");
+  if (!remoteId || !to) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --id <remoteSkillId> and --to <workspace|user>."
+    );
+  }
+  if (to !== "workspace" && to !== "user") {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --to value to be workspace or user."
+    );
+  }
+  const skillId = normalizeSkillIdOrThrow2(store, remoteId);
+  const workspacePathForSkill = path11__namespace.join(
+    workspacePath,
+    store.getWorkspaceSkillPath(skillId)
+  );
+  const userPathForSkill = store.getUserSkillPath(skillId);
+  if (to === "user") {
+    await moveDirectory(workspacePathForSkill, userPathForSkill);
+    await store.writeManagedUserSkillMarker(skillId);
+    return {
+      changed: true,
+      fromScope: "workspace",
+      toScope: "user",
+      skillId
+    };
+  }
+  await moveDirectory(userPathForSkill, workspacePathForSkill);
+  return {
+    changed: true,
+    fromScope: "user",
+    toScope: "workspace",
+    skillId
+  };
+}
+async function moveDirectory(fromPath, toPath) {
+  await fs12__namespace.mkdir(path11__namespace.dirname(toPath), { recursive: true });
+  try {
+    await fs12__namespace.rename(fromPath, toPath);
+  } catch {
+    await fs12__namespace.cp(fromPath, toPath, { recursive: true });
+    await fs12__namespace.rm(fromPath, { recursive: true, force: true });
+  }
+}
+async function handleMarketplace2(store, catalogClient) {
+  const [catalog, workspaceSkillIds, userSkillIds] = await Promise.all([
+    catalogClient.getCatalog(),
+    store.listWorkspaceSkillIds(),
+    store.listUserSkillIds()
+  ]);
+  const scopesById = /* @__PURE__ */ new Map();
+  for (const skillId of workspaceSkillIds) {
+    scopesById.set(skillId, ["workspace"]);
+  }
+  for (const skillId of userSkillIds) {
+    const existing = scopesById.get(skillId);
+    if (existing) {
+      existing.push("user");
+    } else {
+      scopesById.set(skillId, ["user"]);
+    }
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const skill of catalog.skills) {
+    const normalizedId = normalizeSkillIdOrThrow2(store, skill.id);
+    merged.set(normalizedId, {
+      id: normalizedId,
+      displayName: skill.displayName,
+      description: skill.description,
+      source: "catalog",
+      scopes: scopesById.get(normalizedId) ?? []
+    });
+  }
+  for (const [skillId, scopes] of scopesById) {
+    if (merged.has(skillId)) {
+      continue;
+    }
+    merged.set(skillId, {
+      id: skillId,
+      displayName: skillId,
+      description: "Local installed skill",
+      source: "local",
+      scopes
+    });
+  }
+  return {
+    skills: [...merged.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    fetchedAt: catalog.fetchedAt
+  };
+}
+async function handleFind(store, catalogClient, parsed) {
+  const query = getStringFlag(parsed, "query") ?? getStringFlag(parsed, "q");
+  if (!query) {
+    throw createServicemeError(
+      "invalid_params",
+      "Expected --query <text> or --q <text>."
+    );
+  }
+  const marketplace = await handleMarketplace2(store, catalogClient);
+  const loweredQuery = query.toLowerCase();
+  const skills = marketplace.skills.filter(
+    (skill) => skill.id.toLowerCase().includes(loweredQuery) || skill.displayName.toLowerCase().includes(loweredQuery) || skill.description.toLowerCase().includes(loweredQuery)
+  );
+  return {
+    query,
+    skills,
+    total: skills.length
+  };
+}
+async function handleReconcile(store, reconciler) {
+  const [workspaceSkillIds, userSkillIds] = await Promise.all([
+    store.listWorkspaceSkillIds(),
+    store.listUserSkillIds()
+  ]);
+  if (workspaceSkillIds.length === 0) {
+    return {
+      changed: false,
+      workspaceSkillIds,
+      userSkillIds,
+      installGate: "open"
+    };
+  }
+  const gateCheck = await reconciler.mutate({
+    skillId: workspaceSkillIds[0],
+    targetScope: "workspace",
+    action: "install",
+    confirmed: false
+  });
+  return {
+    changed: false,
+    workspaceSkillIds,
+    userSkillIds,
+    installGate: gateCheck.status === "requires_confirmation" ? "requires_confirmation" : gateCheck.status === "blocked" ? "blocked" : "open"
+  };
+}
+async function handlePublishable(store, workspacePath) {
+  const workspaceSkillIds = await store.listWorkspaceSkillIds();
+  return {
+    skills: workspaceSkillIds.map((skillId) => ({
+      id: skillId,
+      displayName: skillId,
+      path: path11__namespace.join(workspacePath, store.getWorkspaceSkillPath(skillId))
+    }))
+  };
+}
+
 // src/commands/version.ts
 init_src();
 async function runVersionCommand() {
@@ -14567,6 +16364,8 @@ function printUsage() {
       "  serviceme env check --json",
       "  serviceme copilot doctor --json",
       "  serviceme copilot prompt --prompt <text> [--workspace <path>] [--autopilot] [--allow-tool <tools>] [--timeout <ms>] --json",
+      "  serviceme skill <list|install|uninstall|move|marketplace|find|reconcile|publishable> --workspacePath <path> --json",
+      "  serviceme agent <list|install|uninstall|move|marketplace|permissions> --workspacePath <path> --json",
       "  serviceme schedule <create|list|get|edit|delete|toggle|trigger|logs> --workspacePath <path> --json",
       "  serviceme scheduler <start|stop|status> --workspacePath <path> --json"
     ].join("\n")}
@@ -14603,6 +16402,12 @@ async function main() {
       case "copilot":
         await runCopilotCommand(parsed);
         return;
+      case "skill":
+        await runSkillCommand(parsed);
+        return;
+      case "agent":
+        await runAgentCommand(parsed);
+        return;
       case "schedule":
         await runScheduleCommand(parsed);
         return;