@docyrus/docyrus 0.0.62 → 0.0.64

package/server-loader.js

@@ -2218,8 +2218,8 @@ var require_lib = __commonJS({
       }
     };
     var walk2 = (opts, callback) => {
-      const p = new Promise((resolve4, reject) => {
-        new Walker(opts).on("done", resolve4).on("error", reject).start();
+      const p = new Promise((resolve5, reject) => {
+        new Walker(opts).on("done", resolve5).on("error", reject).start();
       });
       return callback ? p.then((res) => callback(null, res), callback) : p;
     };
@@ -5393,10 +5393,10 @@ function resolveAll(constructs2, events, context) {
   const called = [];
   let index2 = -1;
   while (++index2 < constructs2.length) {
-    const resolve4 = constructs2[index2].resolveAll;
-    if (resolve4 && !called.includes(resolve4)) {
-      events = resolve4(events, context);
-      called.push(resolve4);
+    const resolve5 = constructs2[index2].resolveAll;
+    if (resolve5 && !called.includes(resolve5)) {
+      events = resolve5(events, context);
+      called.push(resolve5);
     }
   }
   return events;
@@ -10705,9 +10705,9 @@ var init_lib9 = __esm({
        * @returns {undefined}
        *   Nothing.
        */
-      set dirname(dirname11) {
+      set dirname(dirname12) {
         assertPath(this.basename, "dirname");
-        this.path = import_node_path6.default.join(dirname11 || "", this.basename);
+        this.path = import_node_path6.default.join(dirname12 || "", this.basename);
       }
       /**
        * Get the extname (including dot) (example: `'.js'`).
@@ -11354,7 +11354,7 @@ var init_lib10 = __esm({
         assertParser("process", this.parser || this.Parser);
         assertCompiler("process", this.compiler || this.Compiler);
         return done ? executor(void 0, done) : new Promise(executor);
-        function executor(resolve4, reject) {
+        function executor(resolve5, reject) {
           const realFile = vfile(file2);
           const parseTree = (
             /** @type {HeadTree extends undefined ? Node : HeadTree} */
@@ -11385,8 +11385,8 @@ var init_lib10 = __esm({
           function realDone(error48, file3) {
             if (error48 || !file3) {
               reject(error48);
-            } else if (resolve4) {
-              resolve4(file3);
+            } else if (resolve5) {
+              resolve5(file3);
             } else {
               ok(done, "`done` is defined if `resolve` is not");
               done(void 0, file3);
@@ -11488,7 +11488,7 @@ var init_lib10 = __esm({
           file2 = void 0;
         }
         return done ? executor(void 0, done) : new Promise(executor);
-        function executor(resolve4, reject) {
+        function executor(resolve5, reject) {
           ok(
             typeof file2 !== "function",
             "`file` can\u2019t be a `done` anymore, we checked"
@@ -11502,8 +11502,8 @@ var init_lib10 = __esm({
             );
             if (error48) {
               reject(error48);
-            } else if (resolve4) {
-              resolve4(resultingTree);
+            } else if (resolve5) {
+              resolve5(resultingTree);
             } else {
               ok(done, "`done` is defined if `resolve` is not");
               done(void 0, resultingTree, file3);
@@ -12590,8 +12590,8 @@ var require_dist = __commonJS({
       const header = report.header;
       return typeof header === "object" && !!header && "glibcVersionRuntime" in header;
     }
-    function load(dirname11) {
-      const m = path6.join(dirname11, "index.node");
+    function load(dirname12) {
+      const m = path6.join(dirname12, "index.node");
       return fs7.existsSync(m) ? require(m) : null;
     }
     exports2.load = load;
@@ -12621,12 +12621,12 @@ var require_filesystem = __commonJS({
     var fs7 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var readFileSync5 = (path6) => fs7.readFileSync(path6, "utf-8");
-    var readFile15 = (path6) => new Promise((resolve4, reject) => {
+    var readFile15 = (path6) => new Promise((resolve5, reject) => {
       fs7.readFile(path6, "utf-8", (err2, data) => {
         if (err2) {
           reject(err2);
         } else {
-          resolve4(data);
+          resolve5(data);
         }
       });
     });
@@ -12651,10 +12651,10 @@ var require_detect_libc = __commonJS({
     var commandOut = "";
     var safeCommand = () => {
       if (!commandOut) {
-        return new Promise((resolve4) => {
+        return new Promise((resolve5) => {
           childProcess.exec(command, (err2, out2) => {
             commandOut = err2 ? " " : out2;
-            resolve4(commandOut);
+            resolve5(commandOut);
           });
         });
       }
@@ -16571,7 +16571,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes, createHash: createHash5 } = require("crypto");
+    var { randomBytes, createHash: createHash6 } = require("crypto");
     var { Duplex, Readable: Readable2 } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -17231,7 +17231,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash5("sha1").update(key + GUID).digest("base64");
+        const digest = createHash6("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -17598,7 +17598,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash5 } = require("crypto");
+    var { createHash: createHash6 } = require("crypto");
     var extension3 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -17899,7 +17899,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash5("sha1").update(key + GUID).digest("base64");
+        const digest = createHash6("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -18467,7 +18467,7 @@ var init_dist = __esm({
             });
             if (!chunk) {
               if (i2 === 1) {
-                await new Promise((resolve4) => setTimeout(resolve4));
+                await new Promise((resolve5) => setTimeout(resolve5));
                 maxReadCount = 3;
                 continue;
               }
@@ -18617,7 +18617,7 @@ var init_dist = __esm({
 });
 
 // src/server/server-loader.ts
-var import_node_fs13 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 var import_node_url3 = require("node:url");
 var import_node_path23 = require("node:path");
 var import_picocolors2 = __toESM(require_picocolors());
@@ -18743,7 +18743,7 @@ function resolvePackagedExtensionPaths(resourceRoot, runtime = "terminal") {
 
 // src/server/agentServer.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 var import_promises18 = require("node:fs/promises");
 var import_node_path22 = require("node:path");
 
@@ -32612,7 +32612,8 @@ var EnvironmentConfigStateSchema = external_exports.object({
   version: external_exports.literal(1),
   activeEnvironmentId: external_exports.string().min(1),
   environments: external_exports.array(EnvironmentConfigItemSchema).min(1),
-  defaultClientId: external_exports.string().min(1).optional()
+  defaultClientId: external_exports.string().min(1).optional(),
+  activeSoulId: external_exports.string().min(1).optional()
 });
 var LegacyAuthSessionSchema = external_exports.object({
   apiBaseUrl: external_exports.string().min(1),
@@ -32982,6 +32983,76 @@ var AuthStore = class {
 // src/services/environmentConfig.ts
 var import_promises3 = require("node:fs/promises");
 var import_node_path5 = require("node:path");
+
+// resources/pi-agent/souls/catalog.ts
+var DEFAULT_SOUL_ID = "default";
+var SOULS = [
+  {
+    id: "default",
+    name: "Default",
+    description: "Standard Docyrus operator voice. No style overlay.",
+    promptFile: null
+  },
+  {
+    id: "caveman",
+    name: "Caveman",
+    description: "Short grunts. Agent talk simple. Fire good.",
+    promptFile: "caveman.md"
+  },
+  {
+    id: "boomer-parent",
+    name: "Boomer Parent",
+    description: "Overly proud dad-jokes energy with 'back in my day' asides.",
+    promptFile: "boomer-parent.md"
+  },
+  {
+    id: "master-yoda",
+    name: "Master Yoda",
+    description: "Inverted syntax the agent speaks. Mystical brevity, hmm.",
+    promptFile: "master-yoda.md"
+  },
+  {
+    id: "bro",
+    name: "Bro",
+    description: "Pure gym-bro hype energy. 'Lit, fam, let's go.'",
+    promptFile: "bro.md"
+  },
+  {
+    id: "nonsense-engineer",
+    name: "Nonsense Engineer",
+    description: "Maximum jargon, minimum meaning. 'Leveraging synergistic abstractions.'",
+    promptFile: "nonsense-engineer.md"
+  },
+  {
+    id: "shakespeare",
+    name: "Shakespeare",
+    description: "Thee/thou, dramatic flair, iambic vibes.",
+    promptFile: "shakespeare.md"
+  },
+  {
+    id: "noir-detective",
+    name: "Noir Detective",
+    description: "Hard-boiled 1940s narrator. Every bug is a dame.",
+    promptFile: "noir-detective.md"
+  },
+  {
+    id: "pirate",
+    name: "Pirate",
+    description: "Aye matey, every task a seafaring metaphor, arrr.",
+    promptFile: "pirate.md"
+  },
+  {
+    id: "linkedin-influencer",
+    name: "LinkedIn Influencer",
+    description: "Every reply is a mini-post. Single-sentence paragraphs. Humble-brags. 'Agree? \u{1F447}'",
+    promptFile: "linkedin-influencer.md"
+  }
+];
+function findSoul(id) {
+  return SOULS.find((soul) => soul.id === id);
+}
+
+// src/services/environmentConfig.ts
 var ENVIRONMENT_ID_ALIASES = {
   "local-development": "dev",
   prod: "live"
@@ -33005,9 +33076,20 @@ function createDefaultState2() {
       name: environment.name,
       apiBaseUrl: environment.apiBaseUrl
     })),
-    defaultClientId: void 0
+    defaultClientId: void 0,
+    activeSoulId: DEFAULT_SOUL_ID
   };
 }
+function normalizeSoulId(value2) {
+  if (!value2) {
+    return DEFAULT_SOUL_ID;
+  }
+  const trimmed = value2.trim();
+  if (!trimmed) {
+    return DEFAULT_SOUL_ID;
+  }
+  return findSoul(trimmed) ? trimmed : DEFAULT_SOUL_ID;
+}
 function normalizeState3(state) {
   const defaultsById = new Map(
     DEFAULT_ENVIRONMENTS.map((environment) => [
@@ -33058,7 +33140,8 @@ function normalizeState3(state) {
     version: 1,
     activeEnvironmentId: hasActiveEnvironment ? canonicalActiveEnvironmentId : fallbackActiveEnvironment,
     environments,
-    defaultClientId: state.defaultClientId?.trim() || void 0
+    defaultClientId: state.defaultClientId?.trim() || void 0,
+    activeSoulId: normalizeSoulId(state.activeSoulId)
   };
 }
 var EnvironmentConfigService = class {
@@ -33163,6 +33246,25 @@ var EnvironmentConfigService = class {
       defaultClientId: trimmedClientId
     });
   }
+  async getActiveSoulId() {
+    const state = await this.#readStateWithDefaults();
+    return normalizeSoulId(state.activeSoulId);
+  }
+  async setActiveSoulId(soulId) {
+    const trimmed = soulId.trim();
+    if (!trimmed) {
+      throw new UserInputError("Soul ID cannot be empty.");
+    }
+    if (!findSoul(trimmed)) {
+      throw new UserInputError(`Unknown soul '${soulId}'. Use /souls inside the pi agent or GET /api/souls to view options.`);
+    }
+    const state = await this.#readStateWithDefaults();
+    await this.writeState({
+      ...state,
+      activeSoulId: trimmed
+    });
+    return trimmed;
+  }
   async #readStateWithDefaults() {
     const state = await this.readState();
     if (state.environments.length > 0) {
@@ -33177,6 +33279,14 @@ var EnvironmentConfigService = class {
   }
 };
 
+// src/services/soulRegistry.ts
+function listSouls(activeSoulId) {
+  return SOULS.map((soul) => ({
+    ...soul,
+    isActive: soul.id === activeSoulId
+  }));
+}
+
 // ../../node_modules/.pnpm/hono@4.12.14/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
@@ -35695,23 +35805,23 @@ var EXCLUDE_DIRS = ["docyrus/knowledge", ".claude"];
 var EXCLUDE_GLOBS = ["*.md"];
 var DOCYRUS_REF_RE = /(?:\/\/|#)\s*@docyrus:\s*\[\[([^\]]+)\]\]/gu;
 function tryExec(command, args2, cwd) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     (0, import_node_child_process.execFile)(command, args2, { cwd, maxBuffer: 50 * 1024 * 1024 }, (error48, stdout) => {
       if (error48) {
         const exitCode = error48.code;
         const status = error48.status;
         if (exitCode === "ENOENT") {
-          resolve4(null);
+          resolve5(null);
           return;
         }
         if (status === 1 && stdout === "") {
-          resolve4("");
+          resolve5("");
           return;
         }
-        resolve4(null);
+        resolve5(null);
         return;
       }
-      resolve4(stdout);
+      resolve5(stdout);
     });
   });
 }
@@ -37917,8 +38027,8 @@ var Module2 = (() => {
     var moduleRtn;
     var Module = moduleArg;
     var readyPromiseResolve, readyPromiseReject;
-    var readyPromise = new Promise((resolve4, reject) => {
-      readyPromiseResolve = resolve4;
+    var readyPromise = new Promise((resolve5, reject) => {
+      readyPromiseResolve = resolve5;
       readyPromiseReject = reject;
     });
     var ENVIRONMENT_IS_WEB = typeof window == "object";
@@ -38001,13 +38111,13 @@ var Module2 = (() => {
         }
         readAsync = /* @__PURE__ */ __name(async (url2) => {
           if (isFileURI(url2)) {
-            return new Promise((resolve4, reject) => {
+            return new Promise((resolve5, reject) => {
               var xhr = new XMLHttpRequest();
               xhr.open("GET", url2, true);
               xhr.responseType = "arraybuffer";
               xhr.onload = () => {
                 if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                  resolve4(xhr.response);
+                  resolve5(xhr.response);
                   return;
                 }
                 reject(xhr.status);
@@ -38231,10 +38341,10 @@ var Module2 = (() => {
       __name(receiveInstantiationResult, "receiveInstantiationResult");
       var info2 = getWasmImports();
       if (Module["instantiateWasm"]) {
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           Module["instantiateWasm"](info2, (mod, inst) => {
             receiveInstance(mod, inst);
-            resolve4(mod.exports);
+            resolve5(mod.exports);
           });
         });
       }
@@ -43379,8 +43489,8 @@ var OAuthFlowManager = class {
     if (state.currentStep) {
       return Promise.resolve(state.currentStep);
     }
-    return new Promise((resolve4) => {
-      state.waitingForStep = { resolve: resolve4 };
+    return new Promise((resolve5) => {
+      state.waitingForStep = { resolve: resolve5 };
     });
   }
   async start(params) {
@@ -43401,8 +43511,8 @@ var OAuthFlowManager = class {
       onPrompt: async (prompt) => {
         const step = buildPromptStep({ state, type: "prompt", prompt });
         this.emitStep(state, step);
-        return await new Promise((resolve4) => {
-          state.pendingInput = { type: "prompt", resolve: resolve4 };
+        return await new Promise((resolve5) => {
+          state.pendingInput = { type: "prompt", resolve: resolve5 };
         });
       },
       onManualCodeInput: async () => {
@@ -43414,8 +43524,8 @@ var OAuthFlowManager = class {
           }
         });
         this.emitStep(state, step);
-        return await new Promise((resolve4) => {
-          state.pendingInput = { type: "manual-code", resolve: resolve4 };
+        return await new Promise((resolve5) => {
+          state.pendingInput = { type: "manual-code", resolve: resolve5 };
         });
       },
       onProgress: (_message) => {
@@ -43459,6 +43569,7 @@ var OAuthFlowManager = class {
 
 // src/server/mcpConfigService.ts
 var import_node_crypto5 = require("node:crypto");
+var import_node_fs12 = require("node:fs");
 var import_promises16 = require("node:fs/promises");
 var import_node_os2 = require("node:os");
 var import_node_path20 = require("node:path");
@@ -43784,6 +43895,95 @@ async function removeMcpServer(agentDir, name2) {
   raw2[key] = servers;
   await writeUserConfig(agentDir, raw2);
 }
+var SUPPORTED_IMPORT_KINDS = [
+  "cursor",
+  "claude-code",
+  "claude-desktop",
+  "codex",
+  "windsurf",
+  "vscode"
+];
+function validateMcpSettings(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) {
+    return { ok: false, error: "settings must be an object" };
+  }
+  const obj = value2;
+  const settings = {};
+  if (obj.toolPrefix !== void 0) {
+    if (!["server", "none", "short"].includes(obj.toolPrefix)) {
+      return { ok: false, error: "settings.toolPrefix must be 'server', 'none', or 'short'" };
+    }
+    settings.toolPrefix = obj.toolPrefix;
+  }
+  if (obj.idleTimeout !== void 0) {
+    if (typeof obj.idleTimeout !== "number" || !Number.isFinite(obj.idleTimeout) || obj.idleTimeout < 0) {
+      return { ok: false, error: "settings.idleTimeout must be a non-negative number (minutes)" };
+    }
+    settings.idleTimeout = obj.idleTimeout;
+  }
+  if (obj.directTools !== void 0) {
+    if (typeof obj.directTools !== "boolean") {
+      return { ok: false, error: "settings.directTools must be a boolean" };
+    }
+    settings.directTools = obj.directTools;
+  }
+  return { ok: true, value: settings };
+}
+function validateImportKinds(value2) {
+  if (!Array.isArray(value2)) {
+    return { ok: false, error: "imports must be an array of import kinds" };
+  }
+  const kinds = [];
+  for (const item of value2) {
+    if (typeof item !== "string" || !SUPPORTED_IMPORT_KINDS.includes(item)) {
+      return {
+        ok: false,
+        error: `Unsupported import kind: ${String(item)}. Allowed: ${SUPPORTED_IMPORT_KINDS.join(", ")}`
+      };
+    }
+    if (!kinds.includes(item)) {
+      kinds.push(item);
+    }
+  }
+  return { ok: true, value: kinds };
+}
+function getImportPath(kind, cwd) {
+  const raw2 = IMPORT_PATHS[kind];
+  return raw2.startsWith(".") ? (0, import_node_path20.resolve)(cwd, raw2) : raw2;
+}
+async function updateMcpSettings(agentDir, patch) {
+  const { raw: raw2 } = await readUserConfig(agentDir);
+  const current = raw2.settings && typeof raw2.settings === "object" && !Array.isArray(raw2.settings) ? raw2.settings : {};
+  const merged = { ...current, ...patch };
+  raw2.settings = merged;
+  await writeUserConfig(agentDir, raw2);
+  return merged;
+}
+async function updateMcpImports(agentDir, imports) {
+  const { raw: raw2 } = await readUserConfig(agentDir);
+  raw2.imports = imports;
+  await writeUserConfig(agentDir, raw2);
+  return imports;
+}
+async function describeImports(agentDir, cwd) {
+  const { config: config2 } = await readUserConfig(agentDir);
+  const enabled = config2.imports ?? [];
+  const available = await Promise.all(
+    SUPPORTED_IMPORT_KINDS.map(async (kind) => {
+      const path6 = getImportPath(kind, cwd);
+      const imported = (0, import_node_fs12.existsSync)(path6) ? await readJsonFile2(path6) : null;
+      const servers = imported ? extractServers(imported, kind) : {};
+      return {
+        kind,
+        path: path6,
+        exists: imported !== null,
+        enabled: enabled.includes(kind),
+        serverCount: Object.keys(servers).length
+      };
+    })
+  );
+  return { enabled, available };
+}
 function getServerPrefix(serverName, mode) {
   if (mode === "none") {
     return "";
@@ -43803,8 +44003,18 @@ function formatToolName(toolName, serverName, prefix) {
 }
 
 // src/server/skillsService.ts
+var import_node_crypto6 = require("node:crypto");
 var import_promises17 = require("node:fs/promises");
 var import_node_path21 = require("node:path");
+var SKILL_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+var SkillError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "SkillError";
+    this.code = code;
+  }
+};
 function parseFrontmatter2(content3) {
   const frontmatter2 = {};
   if (!content3.startsWith("---")) {
@@ -43910,6 +44120,229 @@ async function getSkillDetail(agentDir, skillName) {
   }
   return null;
 }
+function getSkillsLockPath(agentDir) {
+  return (0, import_node_path21.join)(agentDir, "skills-lock.json");
+}
+function getSkillsDir(agentDir) {
+  return (0, import_node_path21.join)(agentDir, "skills");
+}
+function createEmptyLockFile() {
+  return { version: 1, skills: {} };
+}
+async function readSkillsLockFile(agentDir) {
+  let content3;
+  try {
+    content3 = await (0, import_promises17.readFile)(getSkillsLockPath(agentDir), "utf-8");
+  } catch (error48) {
+    if (isErrnoException(error48) && error48.code === "ENOENT") {
+      return createEmptyLockFile();
+    }
+    throw error48;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content3);
+  } catch {
+    return createEmptyLockFile();
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return createEmptyLockFile();
+  }
+  const obj = parsed;
+  const skills = obj.skills;
+  if (!skills || typeof skills !== "object" || Array.isArray(skills)) {
+    return createEmptyLockFile();
+  }
+  return {
+    version: 1,
+    skills
+  };
+}
+function isErrnoException(error48) {
+  return error48 instanceof Error && "code" in error48;
+}
+async function writeSkillsLockFile(agentDir, lock) {
+  const lockPath = getSkillsLockPath(agentDir);
+  await (0, import_promises17.mkdir)((0, import_node_path21.dirname)(lockPath), { recursive: true });
+  const tmpPath = `${lockPath}.${process.pid}.tmp`;
+  await (0, import_promises17.writeFile)(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+  await (0, import_promises17.rename)(tmpPath, lockPath);
+}
+function validateSkillName(name2) {
+  if (!name2) {
+    return { ok: false, error: "Skill name is required" };
+  }
+  if (!SKILL_NAME_REGEX.test(name2)) {
+    return {
+      ok: false,
+      error: "Skill name must start with alphanumeric and contain only alphanumeric, hyphens, and underscores"
+    };
+  }
+  return { ok: true };
+}
+function validateInstallRequest(request) {
+  if (!request.source || typeof request.source !== "string") {
+    return { ok: false, code: "INVALID_REQUEST", error: "Missing required field: source" };
+  }
+  if (!request.sourceType || !["local"].includes(request.sourceType)) {
+    return { ok: false, code: "INVALID_REQUEST", error: "sourceType must be 'local'" };
+  }
+  if (request.name !== void 0) {
+    const nameCheck = validateSkillName(request.name);
+    if (!nameCheck.ok) {
+      return { ok: false, code: "INVALID_NAME", error: nameCheck.error };
+    }
+  }
+  return { ok: true };
+}
+async function collectFiles2(dir, baseDir) {
+  const files = [];
+  const entries = await (0, import_promises17.readdir)(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = (0, import_node_path21.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles2(full, baseDir));
+    } else if (entry.isFile()) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+async function computeSkillHash(skillDir) {
+  const files = (await collectFiles2(skillDir, skillDir)).sort();
+  const hash2 = (0, import_node_crypto6.createHash)("sha256");
+  for (const file2 of files) {
+    const rel = file2.slice(skillDir.length + 1).replace(/\\/g, "/");
+    const content3 = await (0, import_promises17.readFile)(file2);
+    hash2.update(rel);
+    hash2.update("\0");
+    hash2.update(content3);
+    hash2.update("\0");
+  }
+  return hash2.digest("hex");
+}
+async function readSkillFrontmatterName(skillDir) {
+  try {
+    const content3 = await (0, import_promises17.readFile)((0, import_node_path21.join)(skillDir, "SKILL.md"), "utf-8");
+    const parsed = parseFrontmatter2(content3);
+    return parsed.frontmatter.name || null;
+  } catch {
+    return null;
+  }
+}
+async function verifySkillDirectory(skillDir) {
+  const skillMd = (0, import_node_path21.join)(skillDir, "SKILL.md");
+  try {
+    const s = await (0, import_promises17.stat)(skillMd);
+    if (!s.isFile()) {
+      throw new SkillError("INVALID_SOURCE", `SKILL.md at ${skillMd} is not a regular file`);
+    }
+  } catch (error48) {
+    if (error48 instanceof SkillError) {
+      throw error48;
+    }
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    throw new SkillError("INVALID_SOURCE", `Invalid skill directory: ${message}`);
+  }
+}
+async function copyLocalSkill(params) {
+  const absoluteSource = (0, import_node_path21.isAbsolute)(params.source) ? params.source : (0, import_node_path21.resolve)(params.cwd, params.source);
+  const s = await (0, import_promises17.stat)(absoluteSource).catch(() => null);
+  if (!s || !s.isDirectory()) {
+    throw new SkillError("INVALID_SOURCE", `Local skill source must be an existing directory: ${absoluteSource}`);
+  }
+  await verifySkillDirectory(absoluteSource);
+  await (0, import_promises17.rm)(params.destination, { recursive: true, force: true });
+  await (0, import_promises17.cp)(absoluteSource, params.destination, { recursive: true });
+}
+function deriveSkillName(request) {
+  if (request.name) {
+    return request.name;
+  }
+  const normalized = request.source.replace(/[\\/]+$/, "");
+  const base = normalized.split(/[\\/]/).filter(Boolean).pop() ?? "";
+  return base;
+}
+async function installSkill(params) {
+  const validation = validateInstallRequest(params.request);
+  if (!validation.ok) {
+    throw new SkillError(validation.code, validation.error);
+  }
+  const skillName = params.request.name ?? deriveSkillName(params.request);
+  if (!params.request.name) {
+    const nameCheck = validateSkillName(skillName);
+    if (!nameCheck.ok) {
+      throw new SkillError(
+        "INVALID_NAME",
+        `Unable to derive a valid skill name from "${params.request.source}". Provide an explicit "name".`
+      );
+    }
+  }
+  const skillsDir = getSkillsDir(params.agentDir);
+  const destination = (0, import_node_path21.join)(skillsDir, skillName);
+  const existed = await dirExists(destination);
+  if (existed && !params.request.overwrite) {
+    throw new SkillError(
+      "ALREADY_EXISTS",
+      `Skill "${skillName}" already exists. Set overwrite=true to replace it.`
+    );
+  }
+  await (0, import_promises17.mkdir)(skillsDir, { recursive: true });
+  switch (params.request.sourceType) {
+    case "local":
+      await copyLocalSkill({
+        source: params.request.source,
+        cwd: params.cwd,
+        destination
+      });
+      break;
+  }
+  const fmName = await readSkillFrontmatterName(destination);
+  const computedHash = await computeSkillHash(destination);
+  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const lock = await readSkillsLockFile(params.agentDir);
+  lock.skills[skillName] = {
+    source: params.request.source,
+    sourceType: params.request.sourceType,
+    computedHash,
+    installedAt
+  };
+  await writeSkillsLockFile(params.agentDir, lock);
+  return {
+    name: fmName ?? skillName,
+    directory: skillName,
+    source: params.request.source,
+    sourceType: params.request.sourceType,
+    computedHash,
+    installedAt,
+    overwritten: existed
+  };
+}
+async function uninstallSkill(params) {
+  const nameCheck = validateSkillName(params.name);
+  if (!nameCheck.ok) {
+    throw new SkillError("INVALID_NAME", nameCheck.error);
+  }
+  const skillsDir = getSkillsDir(params.agentDir);
+  let targetDir = params.name;
+  const existed = await dirExists((0, import_node_path21.join)(skillsDir, targetDir));
+  if (!existed) {
+    const detail = await getSkillDetail(params.agentDir, params.name);
+    if (!detail) {
+      throw new SkillError("NOT_FOUND", `Skill "${params.name}" not found`);
+    }
+    targetDir = detail.skill.directory;
+  }
+  const destination = (0, import_node_path21.join)(skillsDir, targetDir);
+  const lock = await readSkillsLockFile(params.agentDir);
+  const lockKey = lock.skills[targetDir] ? targetDir : lock.skills[params.name] ? params.name : null;
+  await (0, import_promises17.rm)(destination, { recursive: true, force: true });
+  if (lockKey) {
+    delete lock.skills[lockKey];
+    await writeSkillsLockFile(params.agentDir, lock);
+  }
+  return { name: params.name, directory: targetDir, removed: true };
+}
 
 // src/server/toolsService.ts
 var BUILT_IN_TOOLS = {
@@ -44180,7 +44613,7 @@ var BROWSER_TOOL_SCHEMAS = [
 ];
 
 // src/server/sessionConfig.ts
-var import_node_fs12 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 var path5 = __toESM(require("node:path"));
 var DEFAULT_CONFIG = { autoCommit: false };
 function configPath(agentDir, sessionId) {
@@ -44188,7 +44621,7 @@ function configPath(agentDir, sessionId) {
 }
 async function readSessionConfig(agentDir, sessionId) {
   try {
-    const raw2 = await import_node_fs12.promises.readFile(configPath(agentDir, sessionId), "utf-8");
+    const raw2 = await import_node_fs13.promises.readFile(configPath(agentDir, sessionId), "utf-8");
     return { ...DEFAULT_CONFIG, ...JSON.parse(raw2) };
   } catch {
     return { ...DEFAULT_CONFIG };
@@ -44196,14 +44629,28 @@ async function readSessionConfig(agentDir, sessionId) {
 }
 async function writeSessionConfig(agentDir, sessionId, patch) {
   const dir = path5.join(agentDir, "session-config");
-  await import_node_fs12.promises.mkdir(dir, { recursive: true });
+  await import_node_fs13.promises.mkdir(dir, { recursive: true });
   const current = await readSessionConfig(agentDir, sessionId);
   const next = { ...current, ...patch };
-  await import_node_fs12.promises.writeFile(configPath(agentDir, sessionId), JSON.stringify(next, null, 2), "utf-8");
+  await import_node_fs13.promises.writeFile(configPath(agentDir, sessionId), JSON.stringify(next, null, 2), "utf-8");
   return next;
 }
 
 // src/server/agentServer.ts
+var SKILL_ERROR_STATUS = {
+  INVALID_REQUEST: 400,
+  INVALID_NAME: 400,
+  INVALID_SOURCE: 404,
+  ALREADY_EXISTS: 409,
+  NOT_FOUND: 404
+};
+function skillErrorResponse(c, error48) {
+  if (error48 instanceof SkillError) {
+    return c.json({ error: error48.message, code: error48.code }, SKILL_ERROR_STATUS[error48.code]);
+  }
+  const message = error48 instanceof Error ? error48.message : String(error48);
+  return c.json({ error: message }, 500);
+}
 function generateMessageId() {
   return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
 }
@@ -44271,7 +44718,7 @@ async function waitForIdle(session, timeoutMs = 3e4) {
   if (!session.isStreaming) {
     return;
   }
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const timer = setTimeout(() => {
       unsubscribe();
       reject(new Error("Timed out waiting for session to become idle"));
@@ -44280,13 +44727,13 @@ async function waitForIdle(session, timeoutMs = 3e4) {
       if (event.type === "agent_end") {
         clearTimeout(timer);
         unsubscribe();
-        resolve4();
+        resolve5();
       }
     });
     if (!session.isStreaming) {
       clearTimeout(timer);
       unsubscribe();
-      resolve4();
+      resolve5();
     }
   });
 }
@@ -44829,10 +45276,28 @@ async function createAgentServer(params) {
     const encoder = new TextEncoder();
     const stream = new ReadableStream({
       start(controller) {
+        let closed = false;
         function writeChunk(chunk) {
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
+          if (closed) {
+            return;
+          }
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
 
 `));
+          } catch {
+            closed = true;
+          }
+        }
+        function closeController() {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          try {
+            controller.close();
+          } catch {
+          }
         }
         writeChunk({ type: "start" });
         writeChunk({ type: "start-step" });
@@ -44856,14 +45321,14 @@ async function createAgentServer(params) {
             extensionUICleanup?.();
             writeChunk({ type: "finish-step" });
             writeChunk({ type: "finish" });
-            controller.close();
+            closeController();
           },
           onError: (errorText) => {
             extensionUICleanup?.();
             writeChunk({ type: "error", errorText });
             writeChunk({ type: "finish-step" });
             writeChunk({ type: "finish" });
-            controller.close();
+            closeController();
           }
         });
         const unsubscribe = activeSession.subscribe((event) => {
@@ -44875,17 +45340,19 @@ async function createAgentServer(params) {
         activeSession.prompt(promptText).then(() => {
           if (!activeSession.isStreaming) {
             unsubscribe();
+            extensionUICleanup?.();
             writeChunk({ type: "finish-step" });
             writeChunk({ type: "finish" });
-            controller.close();
+            closeController();
           }
         }).catch((error48) => {
           const errorMessage = error48 instanceof Error ? error48.message : String(error48);
+          extensionUICleanup?.();
           writeChunk({ type: "error", errorText: errorMessage });
           writeChunk({ type: "finish-step" });
           writeChunk({ type: "finish" });
           unsubscribe();
-          controller.close();
+          closeController();
         });
       }
     });
@@ -45050,6 +45517,41 @@ async function createAgentServer(params) {
       commands: normalizeSlashCommands(activeSession.listCommands())
     });
   });
+  app.get("/api/souls", async (c) => {
+    const configFilePath = (0, import_node_path22.join)(settingsRootPath, "config.json");
+    const envConfigService = new EnvironmentConfigService(configFilePath);
+    const activeSoulId = await envConfigService.getActiveSoulId();
+    const runtimeSoulId = process.env.DOCYRUS_PI_SOUL_ID?.trim() || DEFAULT_SOUL_ID;
+    return c.json({
+      souls: listSouls(activeSoulId),
+      activeSoulId,
+      runtimeSoulId,
+      restartRequired: activeSoulId !== runtimeSoulId
+    });
+  });
+  app.post("/api/souls/select", async (c) => {
+    const body2 = await c.req.json().catch(() => ({}));
+    const requested = typeof body2.soulId === "string" ? body2.soulId.trim() : "";
+    if (!requested) {
+      return c.json({ error: "Field 'soulId' is required." }, 400);
+    }
+    if (!SOULS.some((soul) => soul.id === requested)) {
+      return c.json({
+        error: `Unknown soul '${requested}'.`,
+        availableSoulIds: SOULS.map((soul) => soul.id)
+      }, 400);
+    }
+    const configFilePath = (0, import_node_path22.join)(settingsRootPath, "config.json");
+    const envConfigService = new EnvironmentConfigService(configFilePath);
+    const persistedSoulId = await envConfigService.setActiveSoulId(requested);
+    const runtimeSoulId = process.env.DOCYRUS_PI_SOUL_ID?.trim() || DEFAULT_SOUL_ID;
+    return c.json({
+      soulId: persistedSoulId,
+      runtimeSoulId,
+      restartRequired: persistedSoulId !== runtimeSoulId,
+      message: persistedSoulId === runtimeSoulId ? "Soul persisted. Already running \u2014 no restart needed." : "Soul persisted. Restart the agent (or open a new session) for the new soul to take effect."
+    });
+  });
   app.get("/api/knowledge/sections", async (c) => {
     try {
       const query = c.req.query("query")?.trim();
@@ -46400,6 +46902,69 @@ async function createAgentServer(params) {
       return c.json({ error: message }, status);
     }
   });
+  app.get("/api/mcp/settings", async (c) => {
+    try {
+      const config2 = await loadMcpServerConfig(context.agentDir, context.cwd);
+      return c.json({
+        settings: {
+          toolPrefix: config2.settings?.toolPrefix ?? "server",
+          idleTimeout: config2.settings?.idleTimeout ?? 10,
+          directTools: config2.settings?.directTools ?? false
+        },
+        supportedToolPrefixes: ["server", "none", "short"]
+      });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      return c.json({ error: message }, 500);
+    }
+  });
+  app.put("/api/mcp/settings", async (c) => {
+    try {
+      const body2 = await c.req.json();
+      const result = validateMcpSettings(body2.settings);
+      if (!result.ok) {
+        return c.json({ error: result.error }, 400);
+      }
+      const merged = await updateMcpSettings(context.agentDir, result.value);
+      return c.json({
+        settings: {
+          toolPrefix: merged.toolPrefix ?? "server",
+          idleTimeout: merged.idleTimeout ?? 10,
+          directTools: merged.directTools ?? false
+        }
+      });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      return c.json({ error: message }, 500);
+    }
+  });
+  app.get("/api/mcp/imports", async (c) => {
+    try {
+      const summary = await describeImports(context.agentDir, context.cwd);
+      return c.json({
+        enabled: summary.enabled,
+        available: summary.available,
+        supported: SUPPORTED_IMPORT_KINDS
+      });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      return c.json({ error: message }, 500);
+    }
+  });
+  app.put("/api/mcp/imports", async (c) => {
+    try {
+      const body2 = await c.req.json();
+      const result = validateImportKinds(body2.imports);
+      if (!result.ok) {
+        return c.json({ error: result.error }, 400);
+      }
+      const imports = await updateMcpImports(context.agentDir, result.value);
+      return c.json({ imports });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      return c.json({ error: message }, 500);
+    }
+  });
   app.get("/api/skills", async (c) => {
     try {
       const skills = (await listSkills(context.agentDir)).filter((skill) => skill.name !== "docyrus-chrome-devtools-cli");
@@ -46425,6 +46990,56 @@ async function createAgentServer(params) {
       return c.json({ error: message }, 500);
     }
   });
+  app.get("/api/skills/lock/entries", async (c) => {
+    try {
+      const lock = await readSkillsLockFile(context.agentDir);
+      return c.json({
+        version: lock.version,
+        skills: lock.skills,
+        supportedSourceTypes: ["local"]
+      });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      return c.json({ error: message }, 500);
+    }
+  });
+  app.post("/api/skills", async (c) => {
+    try {
+      const body2 = await c.req.json();
+      if (!body2.source || typeof body2.source !== "string") {
+        return c.json({ error: "Missing required field: source" }, 400);
+      }
+      if (!body2.sourceType || typeof body2.sourceType !== "string") {
+        return c.json({ error: "Missing required field: sourceType" }, 400);
+      }
+      const request = {
+        source: body2.source,
+        sourceType: body2.sourceType,
+        name: body2.name,
+        overwrite: body2.overwrite === true
+      };
+      const result = await installSkill({
+        agentDir: context.agentDir,
+        cwd: context.cwd,
+        request
+      });
+      return c.json({ ok: true, skill: result }, result.overwritten ? 200 : 201);
+    } catch (error48) {
+      return skillErrorResponse(c, error48);
+    }
+  });
+  app.delete("/api/skills/:skillName", async (c) => {
+    const skillName = c.req.param("skillName");
+    try {
+      const result = await uninstallSkill({
+        agentDir: context.agentDir,
+        name: skillName
+      });
+      return c.json({ ok: true, ...result });
+    } catch (error48) {
+      return skillErrorResponse(c, error48);
+    }
+  });
   app.post("/api/extension-ui-response", async (c) => {
     if (!extensionUIBridge) {
       return c.json({ error: "Extension UI bridge not available" }, 404);
@@ -46672,10 +47287,24 @@ async function createAgentServer(params) {
     process.stderr.write(`  PUT  /api/mcp/servers/:name             \u2014 update MCP server
 `);
     process.stderr.write(`  DEL  /api/mcp/servers/:name             \u2014 remove MCP server
+`);
+    process.stderr.write(`  GET  /api/mcp/settings                  \u2014 MCP global settings
+`);
+    process.stderr.write(`  PUT  /api/mcp/settings                  \u2014 update MCP global settings
+`);
+    process.stderr.write(`  GET  /api/mcp/imports                   \u2014 available and enabled MCP imports
+`);
+    process.stderr.write(`  PUT  /api/mcp/imports                   \u2014 update enabled MCP imports
 `);
     process.stderr.write(`  GET  /api/skills                        \u2014 list skills
 `);
     process.stderr.write(`  GET  /api/skills/:name                  \u2014 skill details
+`);
+    process.stderr.write(`  POST /api/skills                        \u2014 install a skill from local source
+`);
+    process.stderr.write(`  DEL  /api/skills/:name                  \u2014 uninstall a skill
+`);
+    process.stderr.write(`  GET  /api/skills/lock/entries           \u2014 skills-lock.json entries
 `);
     process.stderr.write(`  GET  /api/tools                         \u2014 list all tools
 `);
@@ -46736,7 +47365,7 @@ function extractBearerToken(authorizationHeader) {
   return token;
 }
 function hashToken(token) {
-  return (0, import_node_crypto6.createHash)("sha256").update(token).digest();
+  return (0, import_node_crypto7.createHash)("sha256").update(token).digest();
 }
 function isBearerTokenAuthorized(actualToken, expectedToken) {
   if (!expectedToken) {
@@ -46747,7 +47376,7 @@ function isBearerTokenAuthorized(actualToken, expectedToken) {
   }
   const actualHash = hashToken(actualToken);
   const expectedHash = hashToken(expectedToken);
-  return (0, import_node_crypto6.timingSafeEqual)(actualHash, expectedHash);
+  return (0, import_node_crypto7.timingSafeEqual)(actualHash, expectedHash);
 }
 function createUnauthorizedResponse() {
   return new Response(JSON.stringify({ error: "Unauthorized" }), {
@@ -46881,7 +47510,7 @@ function createServerSessionAdapter(params) {
 }
 
 // src/server/extensionUIBridge.ts
-var import_node_crypto7 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 var ExtensionUIBridge = class {
   pending = /* @__PURE__ */ new Map();
   requestHandler;
@@ -46925,9 +47554,9 @@ var ExtensionUIBridge = class {
     if (opts?.signal?.aborted) {
       return Promise.resolve(defaultValue);
     }
-    const id = (0, import_node_crypto7.randomUUID)();
+    const id = (0, import_node_crypto8.randomUUID)();
     const timeout = opts?.timeout ?? this.defaultTimeout;
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const cleanup = () => {
         if (timer) {
           clearTimeout(timer);
@@ -46937,17 +47566,17 @@ var ExtensionUIBridge = class {
       };
       const onAbort = () => {
         cleanup();
-        resolve4(defaultValue);
+        resolve5(defaultValue);
       };
       opts?.signal?.addEventListener("abort", onAbort, { once: true });
       const timer = timeout > 0 ? setTimeout(() => {
         cleanup();
-        resolve4(defaultValue);
+        resolve5(defaultValue);
       }, timeout) : void 0;
       this.pending.set(id, {
         resolve: (response) => {
           cleanup();
-          resolve4(parseResponse(response));
+          resolve5(parseResponse(response));
         },
         reject: (error48) => {
           cleanup();
@@ -46988,23 +47617,23 @@ var ExtensionUIBridge = class {
         opts
       ),
       notify: (message, notifyType) => {
-        const id = (0, import_node_crypto7.randomUUID)();
+        const id = (0, import_node_crypto8.randomUUID)();
         this.requestHandler({ type: "extension_ui_request", id, method: "notify", message, placeholder: notifyType });
       },
       setStatus: (statusKey, statusText) => {
-        const id = (0, import_node_crypto7.randomUUID)();
+        const id = (0, import_node_crypto8.randomUUID)();
         this.requestHandler({ type: "extension_ui_request", id, method: "setStatus", title: statusKey, message: statusText });
       },
       setWidget: (widgetKey, widgetLines) => {
-        const id = (0, import_node_crypto7.randomUUID)();
+        const id = (0, import_node_crypto8.randomUUID)();
         this.requestHandler({ type: "extension_ui_request", id, method: "setWidget", title: widgetKey, options: widgetLines });
       },
       setTitle: (title) => {
-        const id = (0, import_node_crypto7.randomUUID)();
+        const id = (0, import_node_crypto8.randomUUID)();
         this.requestHandler({ type: "extension_ui_request", id, method: "setTitle", title });
       },
       setEditorText: (text3) => {
-        const id = (0, import_node_crypto7.randomUUID)();
+        const id = (0, import_node_crypto8.randomUUID)();
         this.requestHandler({ type: "extension_ui_request", id, method: "set_editor_text", message: text3 });
       },
       // No-op methods for server mode (not applicable without TUI)
@@ -47085,7 +47714,7 @@ function resolvePackagedPiResourceRoot() {
     (0, import_node_path23.resolve)(__dirname, "resources/pi-agent"),
     (0, import_node_path23.resolve)(process.cwd(), "dist/apps/api-cli/resources/pi-agent")
   ];
-  const resolved = candidates.find((candidate) => (0, import_node_fs13.existsSync)(candidate));
+  const resolved = candidates.find((candidate) => (0, import_node_fs14.existsSync)(candidate));
   if (!resolved) {
     throw new Error(`Unable to locate pi agent resources. Checked: ${candidates.join(", ")}`);
   }
@@ -47217,7 +47846,7 @@ async function main() {
       skills: skills.filter((skill) => skill.name !== "docyrus-chrome-devtools-cli"),
       diagnostics
     }),
-    systemPrompt: (0, import_node_path23.join)(
+    systemPrompt: process.env.DOCYRUS_PI_SYSTEM_PROMPT_PATH ?? (0, import_node_path23.join)(
       resourceRoot,
       "prompts",
       request.profile === "agent" ? "agent-system.md" : "coder-system.md"