@serviceme/devtools-cli 0.1.4 → 0.1.6

package/dist/bridgeServer.js

@@ -2,11 +2,11 @@
 'use strict';
 
 var readline = require('readline');
+var fs12 = require('fs/promises');
+var os2 = require('os');
+var path10 = require('path');
 var child_process = require('child_process');
-require('fs/promises');
-var path5 = require('path');
-var fs6 = require('fs');
-require('os');
+var fs7 = require('fs');
 require('crypto');
 
 function _interopNamespace(e) {
@@ -28,8 +28,10 @@ function _interopNamespace(e) {
 }
 
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
-var path5__namespace = /*#__PURE__*/_interopNamespace(path5);
-var fs6__namespace = /*#__PURE__*/_interopNamespace(fs6);
+var fs12__namespace = /*#__PURE__*/_interopNamespace(fs12);
+var os2__namespace = /*#__PURE__*/_interopNamespace(os2);
+var path10__namespace = /*#__PURE__*/_interopNamespace(path10);
+var fs7__namespace = /*#__PURE__*/_interopNamespace(fs7);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -550,8 +552,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 cp3 = this.scanner.source.charCodeAt(this.scanner.index);
+                if (cp3 === 60 || cp3 === 62 || cp3 === 47 || cp3 === 58 || cp3 === 61 || cp3 === 123 || cp3 === 125) {
                   var value = this.scanner.source[this.scanner.index++];
                   return {
                     type: 7,
@@ -562,7 +564,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp === 34 || cp === 39) {
+                if (cp3 === 34 || cp3 === 39) {
                   var start = this.scanner.index;
                   var quote = this.scanner.source[this.scanner.index++];
                   var str = "";
@@ -585,7 +587,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp === 46) {
+                if (cp3 === 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 ? "..." : ".";
@@ -600,7 +602,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp === 96) {
+                if (cp3 === 96) {
                   return {
                     type: 10,
                     value: "",
@@ -610,7 +612,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (character_1.Character.isIdentifierStart(cp) && cp !== 92) {
+                if (character_1.Character.isIdentifierStart(cp3) && cp3 !== 92) {
                   var start = this.scanner.index;
                   ++this.scanner.index;
                   while (!this.scanner.eof()) {
@@ -939,33 +941,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(cp3) {
+                return cp3 < 65536 ? String.fromCharCode(cp3) : String.fromCharCode(55296 + (cp3 - 65536 >> 10)) + String.fromCharCode(56320 + (cp3 - 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(cp3) {
+                return cp3 === 32 || cp3 === 9 || cp3 === 11 || cp3 === 12 || cp3 === 160 || cp3 >= 5760 && [5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(cp3) >= 0;
               },
               // https://tc39.github.io/ecma262/#sec-line-terminators
-              isLineTerminator: function(cp) {
-                return cp === 10 || cp === 13 || cp === 8232 || cp === 8233;
+              isLineTerminator: function(cp3) {
+                return cp3 === 10 || cp3 === 13 || cp3 === 8232 || cp3 === 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(cp3) {
+                return cp3 === 36 || cp3 === 95 || cp3 >= 65 && cp3 <= 90 || cp3 >= 97 && cp3 <= 122 || cp3 === 92 || cp3 >= 128 && Regex.NonAsciiIdentifierStart.test(exports2.Character.fromCodePoint(cp3));
               },
-              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(cp3) {
+                return cp3 === 36 || cp3 === 95 || cp3 >= 65 && cp3 <= 90 || cp3 >= 97 && cp3 <= 122 || cp3 >= 48 && cp3 <= 57 || cp3 === 92 || cp3 >= 128 && Regex.NonAsciiIdentifierPart.test(exports2.Character.fromCodePoint(cp3));
               },
               // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
-              isDecimalDigit: function(cp) {
-                return cp >= 48 && cp <= 57;
+              isDecimalDigit: function(cp3) {
+                return cp3 >= 48 && cp3 <= 57;
               },
-              isHexDigit: function(cp) {
-                return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 70 || cp >= 97 && cp <= 102;
+              isHexDigit: function(cp3) {
+                return cp3 >= 48 && cp3 <= 57 || cp3 >= 65 && cp3 <= 70 || cp3 >= 97 && cp3 <= 102;
               },
-              isOctalDigit: function(cp) {
-                return cp >= 48 && cp <= 55;
+              isOctalDigit: function(cp3) {
+                return cp3 >= 48 && cp3 <= 55;
               }
             };
           },
@@ -5015,15 +5017,15 @@ var require_esprima = __commonJS({
                 }
               };
               Scanner2.prototype.codePointAt = function(i) {
-                var cp = this.source.charCodeAt(i);
-                if (cp >= 55296 && cp <= 56319) {
+                var cp3 = this.source.charCodeAt(i);
+                if (cp3 >= 55296 && cp3 <= 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 = cp3;
+                    cp3 = (first - 55296) * 1024 + second - 56320 + 65536;
                   }
                 }
-                return cp;
+                return cp3;
               };
               Scanner2.prototype.scanHexEscape = function(prefix) {
                 var len = prefix === "u" ? 4 : 2;
@@ -5075,11 +5077,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 cp3 = this.codePointAt(this.index);
+                var id = character_1.Character.fromCodePoint(cp3);
                 this.index += id.length;
                 var ch;
-                if (cp === 92) {
+                if (cp3 === 92) {
                   if (this.source.charCodeAt(this.index) !== 117) {
                     this.throwUnexpectedToken();
                   }
@@ -5096,14 +5098,14 @@ var require_esprima = __commonJS({
                   id = ch;
                 }
                 while (!this.eof()) {
-                  cp = this.codePointAt(this.index);
-                  if (!character_1.Character.isIdentifierPart(cp)) {
+                  cp3 = this.codePointAt(this.index);
+                  if (!character_1.Character.isIdentifierPart(cp3)) {
                     break;
                   }
-                  ch = character_1.Character.fromCodePoint(cp);
+                  ch = character_1.Character.fromCodePoint(cp3);
                   id += ch;
                   this.index += ch.length;
-                  if (cp === 92) {
+                  if (cp3 === 92) {
                     id = id.substr(0, id.length - 1);
                     if (this.source.charCodeAt(this.index) !== 117) {
                       this.throwUnexpectedToken();
@@ -5729,29 +5731,29 @@ var require_esprima = __commonJS({
                     end: this.index
                   };
                 }
-                var cp = this.source.charCodeAt(this.index);
-                if (character_1.Character.isIdentifierStart(cp)) {
+                var cp3 = this.source.charCodeAt(this.index);
+                if (character_1.Character.isIdentifierStart(cp3)) {
                   return this.scanIdentifier();
                 }
-                if (cp === 40 || cp === 41 || cp === 59) {
+                if (cp3 === 40 || cp3 === 41 || cp3 === 59) {
                   return this.scanPunctuator();
                 }
-                if (cp === 39 || cp === 34) {
+                if (cp3 === 39 || cp3 === 34) {
                   return this.scanStringLiteral();
                 }
-                if (cp === 46) {
+                if (cp3 === 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(cp3)) {
                   return this.scanNumericLiteral();
                 }
-                if (cp === 96 || cp === 125 && this.curlyStack[this.curlyStack.length - 1] === "${") {
+                if (cp3 === 96 || cp3 === 125 && this.curlyStack[this.curlyStack.length - 1] === "${") {
                   return this.scanTemplate();
                 }
-                if (cp >= 55296 && cp < 57343) {
+                if (cp3 >= 55296 && cp3 < 57343) {
                   if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {
                     return this.scanIdentifier();
                   }
@@ -7929,10 +7931,10 @@ var require_stringify = __commonJS({
       replacer = null;
       indent = EMPTY;
     };
-    var join8 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + LF + gap : two ? two.trimRight() + LF + gap : EMPTY;
+    var join12 = (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 join8(comment, inside, gap);
+      return join12(comment, inside, gap);
     };
     var array_stringify = (value, gap) => {
       const deeper_gap = gap + indent;
@@ -7943,7 +7945,7 @@ var require_stringify = __commonJS({
         if (i !== 0) {
           inside += COMMA;
         }
-        const before = join8(
+        const before = join12(
           after_comma,
           process_comments(value, BEFORE(i), deeper_gap),
           deeper_gap
@@ -7953,7 +7955,7 @@ var require_stringify = __commonJS({
         inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
         after_comma = process_comments(value, AFTER(i), deeper_gap);
       }
-      inside += join8(
+      inside += join12(
         after_comma,
         process_comments(value, PREFIX_AFTER, deeper_gap),
         deeper_gap
@@ -7978,7 +7980,7 @@ var require_stringify = __commonJS({
           inside += COMMA;
         }
         first = false;
-        const before = join8(
+        const before = join12(
           after_comma,
           process_comments(value, BEFORE(key), deeper_gap),
           deeper_gap
@@ -7988,7 +7990,7 @@ var require_stringify = __commonJS({
         after_comma = process_comments(value, AFTER(key), deeper_gap);
       };
       keys.forEach(iteratee);
-      inside += join8(
+      inside += join12(
         after_comma,
         process_comments(value, PREFIX_AFTER, deeper_gap),
         deeper_gap
@@ -8146,7 +8148,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 fs10 = __require("fs");
+    var fs14 = __require("fs");
     var util = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -8171,7 +8173,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs10.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs14.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -8180,7 +8182,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs10.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        fs14.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -8201,7 +8203,7 @@ var require_fd_slicer = __commonJS({
       if (self.refCount > 0) return;
       if (self.refCount < 0) throw new Error("invalid unref");
       if (self.autoClose) {
-        fs10.close(self.fd, onCloseDone);
+        fs14.close(self.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -8238,7 +8240,7 @@ var require_fd_slicer = __commonJS({
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
         var buffer = Buffer.allocUnsafe(toRead);
-        fs10.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        fs14.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -8285,7 +8287,7 @@ var require_fd_slicer = __commonJS({
       }
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
-        fs10.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
+        fs14.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
           if (err2) {
             self.destroy();
             cb();
@@ -8723,7 +8725,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 fs10 = __require("fs");
+    var fs14 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -8744,7 +8746,7 @@ var require_yauzl = __commonJS({
     exports$1.Entry = Entry;
     exports$1.LocalFileHeader = LocalFileHeader;
     exports$1.RandomAccessReader = RandomAccessReader;
-    function open2(path8, options2, callback) {
+    function open2(path12, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -8756,10 +8758,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs10.open(path8, "r", function(err, fd) {
+      fs14.open(path12, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options2, function(err2, zipfile) {
-          if (err2) fs10.close(fd, defaultCallback);
+          if (err2) fs14.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -8776,7 +8778,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs10.fstat(fd, function(err, stats) {
+      fs14.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -9474,7 +9476,14 @@ var BRIDGE_METHODS = [
   "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"
 ];
 function isBridgeMethod(value) {
   return typeof value === "string" && BRIDGE_METHODS.includes(value);
@@ -9600,13 +9609,284 @@ function normalizeServicemeError(error, fallbackCode = "internal_error") {
 }
 
 // src/version.ts
-var SERVICEME_CLI_VERSION = "0.1.4";
+var SERVICEME_CLI_VERSION = "0.1.6";
 
-// src/bridge/ndjson.ts
-function writeBridgeMessage(message) {
-  process.stdout.write(`${JSON.stringify(message)}
-`);
+// ../../packages/serviceme-core/src/agents/AgentCatalogClient.ts
+var 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
+var TOOL_RISK_MAP = {
+  shell: "high",
+  terminal: "high",
+  run_in_terminal: "high",
+  execution_subagent: "high",
+  filesystem: "medium",
+  fetch: "medium",
+  fetch_webpage: "medium",
+  create_file: "medium",
+  replace_string_in_file: "medium",
+  multi_replace_string_in_file: "medium",
+  read_file: "low",
+  search: "low",
+  grep_search: "low",
+  file_search: "low",
+  semantic_search: "low",
+  list_dir: "low"
+};
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---/;
+var TOOLS_LINE_REGEX = /^tools:\s*$/m;
+var TOOLS_INLINE_REGEX = /^tools:\s*\[([^\]]*)\]/m;
+var LIST_ITEM_REGEX = /^\s*-\s+(.+)$/;
+function parseAgentToolPermissions(content) {
+  const fmMatch = content.match(FRONTMATTER_REGEX);
+  if (!fmMatch?.[1]) return [];
+  const frontmatter = fmMatch[1];
+  const inlineMatch = frontmatter.match(TOOLS_INLINE_REGEX);
+  if (inlineMatch?.[1] != null) {
+    const raw = inlineMatch[1];
+    return raw.split(",").map((t) => t.trim()).filter(Boolean).map((tool) => ({
+      tool,
+      riskLevel: TOOL_RISK_MAP[tool] ?? "medium"
+    }));
+  }
+  const blockMatch = frontmatter.match(TOOLS_LINE_REGEX);
+  if (!blockMatch?.[0]) return [];
+  const toolsStartIndex = frontmatter.indexOf(blockMatch[0]) + blockMatch[0].length;
+  const remaining = frontmatter.slice(toolsStartIndex);
+  const lines = remaining.split(/\r?\n/);
+  const tools = [];
+  for (const line of lines) {
+    const itemMatch = line.match(LIST_ITEM_REGEX);
+    if (itemMatch?.[1]) {
+      const tool = itemMatch[1].trim();
+      tools.push({ tool, riskLevel: TOOL_RISK_MAP[tool] ?? "medium" });
+    } else if (line.trim() !== "" && !line.startsWith(" ") && !line.startsWith("	")) {
+      break;
+    }
+  }
+  return tools;
+}
+
+// ../../packages/serviceme-core/src/agents/AgentReconciler.ts
+var AgentReconciler = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async mutate(request) {
+    if (request.targetScope !== "workspace" && request.targetScope !== "user") {
+      throw new Error(`Invalid target scope: ${String(request.targetScope)}`);
+    }
+    if (request.action === "uninstall" || request.action === "move" || request.action === "removeExternal") {
+      return {
+        status: "success",
+        changed: true,
+        message: `Agent ${request.action} completed.`
+      };
+    }
+    if (request.action !== "install") {
+      return {
+        status: "blocked",
+        changed: false,
+        message: `Agent action is not supported by bridge reconciler: ${request.action}`
+      };
+    }
+    const catalog = await this.deps.catalogClient.getCatalog();
+    const remoteAgent = catalog.agents.find(
+      (agent) => this.deps.agentStore.normalizeRemoteAgentId(agent.id) === request.agentId
+    );
+    if (!remoteAgent) {
+      return {
+        status: "blocked",
+        changed: false,
+        message: "Agent not found in catalog."
+      };
+    }
+    if (!request.confirmed && this.hasHighRiskTool(remoteAgent.tools)) {
+      return {
+        status: "requires_confirmation",
+        changed: false,
+        message: "This agent uses high-risk tools that require confirmation.",
+        tools: remoteAgent.tools
+      };
+    }
+    return {
+      status: "success",
+      changed: true,
+      message: "Agent installed."
+    };
+  }
+  getPermissionSummary(agentId, agentName, content) {
+    const tools = parseAgentToolPermissions(content);
+    return {
+      agentId,
+      agentName,
+      tools,
+      highRiskCount: tools.filter((tool) => tool.riskLevel === "high").length,
+      mediumRiskCount: tools.filter((tool) => tool.riskLevel === "medium").length,
+      lowRiskCount: tools.filter((tool) => tool.riskLevel === "low").length
+    };
+  }
+  hasHighRiskTool(tools) {
+    return tools.some((tool) => TOOL_RISK_MAP[tool] === "high");
+  }
+};
+var WORKSPACE_AGENTS_ROOT_RELATIVE = ".github/agents";
+var WORKSPACE_AGENTS_STATE_RELATIVE = ".github/.ms-devtools-agents.yml";
+var SAFE_LOCAL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function assertSafeLocalAgentId(agentId) {
+  if (typeof agentId !== "string" || agentId.length === 0 || agentId === "." || agentId === ".." || agentId.includes("/") || agentId.includes("\\") || !SAFE_LOCAL_ID_PATTERN.test(agentId)) {
+    throw new Error(`Invalid agent id: ${agentId}`);
+  }
+  return agentId;
 }
+var AgentStore = class {
+  constructor(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(
+      path10__namespace.join(this.workspacePath, WORKSPACE_AGENTS_ROOT_RELATIVE)
+    );
+  }
+  async listUserAgentIds() {
+    return this.listAgentIds(this.userAgentsRoot);
+  }
+  async readState() {
+    try {
+      const raw = await this.fileSystem.readFile(
+        path10__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 = path10__namespace.join(
+      this.workspacePath,
+      WORKSPACE_AGENTS_STATE_RELATIVE
+    );
+    await this.fileSystem.mkdir(path10__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 root = scope === "workspace" ? path10__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 ? root : path10__namespace.join(root, agentId);
+    await this.fileSystem.mkdir(targetDir, { recursive: true });
+    for (const file of files) {
+      const filePath = path10__namespace.join(targetDir, file.path);
+      await this.fileSystem.mkdir(path10__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 [];
+    }
+  }
+};
 function terminateCommandProcess(child) {
   if (child.killed) {
     return;
@@ -9755,11 +10035,35 @@ function redactArgs(args) {
 function writeDiagnostic(message) {
   const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
   if (logPath) {
-    fs6__namespace.appendFileSync(logPath, message);
+    fs7__namespace.appendFileSync(logPath, message);
     return;
   }
   process.stderr.write(message);
 }
+function resolveGithubCopilotCliExecution(payload) {
+  const args = ["copilot", "prompt", "--prompt", payload.prompt];
+  if (payload.autopilot) {
+    args.push("--autopilot");
+  }
+  if (payload.allowTools && payload.allowTools.length > 0) {
+    args.push("--allow-tools", payload.allowTools.join(","));
+  }
+  if (payload.model) {
+    args.push("--model", payload.model);
+  }
+  if (payload.agent) {
+    args.push("--agent", payload.agent);
+  }
+  args.push("--timeout", String(payload.timeout ?? 0));
+  return {
+    command: "serviceme",
+    args,
+    cwd: payload.workspace,
+    timeoutMs: resolveConfiguredTimeoutMs(payload.timeout, DEFAULT_TIMEOUT_MS),
+    diagnosticArgs: redactArgs(args),
+    promptLen: payload.prompt.length
+  };
+}
 var GithubCopilotCliExecutor = class {
   async execute(payload, abortSignal) {
     const authenticated = await isCopilotAuthenticated();
@@ -9782,7 +10086,7 @@ var GithubCopilotCliExecutor = class {
   }
   executeStreaming(payload, onOutput, abortSignal) {
     const p = payload;
-    const timeoutMs = resolveConfiguredTimeoutMs(p.timeout, DEFAULT_TIMEOUT_MS);
+    const execution = resolveGithubCopilotCliExecution(p);
     let resolve;
     const resultPromise = new Promise((r) => {
       resolve = r;
@@ -9804,26 +10108,12 @@ var GithubCopilotCliExecutor = class {
         }
       };
     }
-    const args = ["copilot", "prompt", "--prompt", p.prompt];
-    if (p.autopilot) {
-      args.push("--autopilot");
-    }
-    if (p.allowTools && p.allowTools.length > 0) {
-      args.push("--allow-tools", p.allowTools.join(","));
-    }
-    if (p.model) {
-      args.push("--model", p.model);
-    }
-    if (p.agent) {
-      args.push("--agent", p.agent);
-    }
-    args.push("--timeout", String(p.timeout ?? 0));
     writeDiagnostic(
-      `[GithubCopilotCliExecutor] spawn: command=serviceme, args=${JSON.stringify(redactArgs(args))}, promptLen=${p.prompt.length}, cwd=${p.workspace ?? "(default)"}, platform=${process.platform}, windowsHide=true, pid=${process.pid}
+      `[GithubCopilotCliExecutor] spawn: command=${execution.command}, args=${JSON.stringify(execution.diagnosticArgs)}, promptLen=${execution.promptLen}, cwd=${execution.cwd ?? "(default)"}, platform=${process.platform}, windowsHide=true, pid=${process.pid}
 `
     );
-    const child = child_process.spawn("serviceme", args, {
-      cwd: p.workspace,
+    const child = child_process.spawn(execution.command, execution.args, {
+      cwd: execution.cwd,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
@@ -9833,6 +10123,7 @@ var GithubCopilotCliExecutor = class {
 `
       );
     }
+    const timeoutMs = execution.timeoutMs;
     const timer = timeoutMs != null ? setTimeout(() => {
       child.kill("SIGTERM");
       setTimeout(() => {
@@ -9957,7 +10248,7 @@ var POSIX_SHELL_CANDIDATES = ["bash.exe", "sh.exe"];
 function resolveShellExecution(script, options2 = {}) {
   const platform = options2.platform ?? process.platform;
   const env = options2.env ?? process.env;
-  const fileExists = options2.fileExists ?? fs6__namespace.existsSync;
+  const fileExists = options2.fileExists ?? fs7__namespace.existsSync;
   if (platform === "win32") {
     const posixShell = usesPosixShellSyntax(script) ? findWindowsPosixShell(env, fileExists) : null;
     if (posixShell) {
@@ -10002,10 +10293,10 @@ function findWindowsPosixShell(env, fileExists) {
     if (fileExists(candidate)) return candidate;
   }
   const pathValue = env.Path ?? env.PATH ?? "";
-  for (const dir of pathValue.split(path5__namespace.win32.delimiter)) {
+  for (const dir of pathValue.split(path10__namespace.win32.delimiter)) {
     if (!dir) continue;
     for (const executable of POSIX_SHELL_CANDIDATES) {
-      const candidate = path5__namespace.win32.join(dir, executable);
+      const candidate = path10__namespace.win32.join(dir, executable);
       if (fileExists(candidate) && !isWindowsWslLauncher(candidate)) {
         return candidate;
       }
@@ -10014,13 +10305,13 @@ function findWindowsPosixShell(env, fileExists) {
   return null;
 }
 function isWindowsWslLauncher(candidate) {
-  const normalized = path5__namespace.win32.normalize(candidate).toLowerCase();
+  const normalized = path10__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) {
-    fs6__namespace.appendFileSync(logPath, message);
+    fs7__namespace.appendFileSync(logPath, message);
     return;
   }
   process.stderr.write(message);
@@ -10380,6 +10671,767 @@ var TaskExecutionEngine = class {
   }
 };
 
+// ../../packages/serviceme-core/src/skills/SkillCatalogClient.ts
+var 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 = 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."
+    };
+  }
+};
+var USER_SKILL_MARKER_FILE = ".ms-devtools-skill.json";
+var WORKSPACE_SKILLS_ROOT_RELATIVE = ".github/skills";
+var WORKSPACE_SKILLS_MARKER_RELATIVE = ".github/.ms-devtools-skills.yml";
+var SAFE_LOCAL_ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function assertSafeLocalSkillId(skillId) {
+  if (typeof skillId !== "string" || skillId.length === 0 || skillId === "." || skillId === ".." || skillId.includes("/") || skillId.includes("\\") || !SAFE_LOCAL_ID_PATTERN2.test(skillId)) {
+    throw new Error(`Invalid skill id: ${skillId}`);
+  }
+  return skillId;
+}
+var SkillStore = class {
+  constructor(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 path10__namespace.join(this.userSkillsRoot, skillId);
+  }
+  async listWorkspaceSkillIds() {
+    const skillsRootPath = path10__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(
+      path10__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(
+        path10__namespace.join(this.getUserSkillPath(skillId), USER_SKILL_MARKER_FILE),
+        "utf-8"
+      );
+      const parsed = JSON.parse(marker);
+      return parsed.skillId === skillId;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/bridge/AgentBridgeHandler.ts
+function normalizeAgentIdOrThrow(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 = normalizeAgentIdOrThrow(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 ? path10__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceAgentsRootPath(),
+          `${agentId}.agent.md`
+        ) : path10__namespace.join(
+          context.store.getUserAgentsRootPath(),
+          `${agentId}.agent.md`
+        ) : void 0,
+        canPublish: agent.canPublish,
+        workspaceState: this.makeScopeState(
+          "workspace",
+          workspaceInstalled,
+          path10__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          userInstalled,
+          path10__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: path10__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceAgentsRootPath(),
+          `${agentId}.agent.md`
+        ),
+        workspaceState: this.makeScopeState(
+          "workspace",
+          true,
+          path10__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          userSet.has(agentId),
+          path10__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: path10__namespace.join(
+          context.store.getUserAgentsRootPath(),
+          `${agentId}.agent.md`
+        ),
+        workspaceState: this.makeScopeState(
+          "workspace",
+          workspaceSet.has(agentId),
+          path10__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          true,
+          path10__namespace.join(
+            context.store.getUserAgentsRootPath(),
+            `${agentId}.agent.md`
+          )
+        )
+      });
+    }
+    return {
+      configPath: path10__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 = normalizeAgentIdOrThrow(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 = normalizeAgentIdOrThrow(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 = path10__namespace.join(os2__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 = path10__namespace.join(
+      context.workspacePath,
+      context.store.getWorkspaceAgentsRootPath(),
+      `${request.agentId}.agent.md`
+    );
+    const userFlatPath = path10__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(path10__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(path10__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 root = scope === "workspace" ? path10__namespace.join(
+      context.workspacePath,
+      context.store.getWorkspaceAgentsRootPath()
+    ) : context.store.getUserAgentsRootPath();
+    const candidates = [
+      path10__namespace.join(root, `${agentId}.agent.md`),
+      path10__namespace.join(root, 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)}
+`);
+}
+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 ? path10__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceSkillPath(skillId)
+        ) : context.store.getUserSkillPath(skillId) : void 0,
+        canPublish: skill.canPublish,
+        workspaceState: this.makeScopeState(
+          "workspace",
+          workspaceInstalled,
+          path10__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: path10__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceSkillPath(skillId)
+        ),
+        workspaceState: this.makeScopeState(
+          "workspace",
+          true,
+          path10__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),
+          path10__namespace.join(
+            context.workspacePath,
+            context.store.getWorkspaceSkillPath(skillId)
+          )
+        ),
+        userState: this.makeScopeState(
+          "user",
+          true,
+          context.store.getUserSkillPath(skillId)
+        )
+      });
+    }
+    return {
+      configPath: path10__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: path10__namespace.join(
+          context.workspacePath,
+          context.store.getWorkspaceSkillPath(skillId)
+        )
+      }))
+    };
+  }
+  createContext(workspacePath) {
+    const resolvedWorkspacePath = workspacePath ?? process.cwd();
+    const userSkillsRoot = path10__namespace.join(os2__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 = path10__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(path10__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
 var TaskBridgeHandler = class {
   constructor(logger, emitEvent) {
@@ -10427,7 +11479,9 @@ var CAPABILITIES = {
   bridge: true,
   json: 1,
   env: 1,
-  tasks: 1
+  tasks: 1,
+  skills: 1,
+  agents: 1
 };
 var BridgeServer = class {
   constructor(logger) {
@@ -10436,6 +11490,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({
@@ -10541,6 +11597,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,