@liangjie559567/ultrapower 5.5.2 → 5.5.3

package/bridge/mcp-server.cjs

@@ -2245,8 +2245,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize2) {
-      if (normalize2 !== false)
+    function getFullPath(resolver, id = "", normalize6) {
+      if (normalize6 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -2994,7 +2994,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve5.call(this, root, ref);
+      let _sch = resolve6.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3021,7 +3021,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve5(root, ref) {
+    function resolve6(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3236,8 +3236,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path10) {
-      let input = path10;
+    function removeDotSegments(path12) {
+      let input = path12;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3436,8 +3436,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path10, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path10 && path10 !== "/" ? path10 : void 0;
+        const [path12, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path12 && path12 !== "/" ? path12 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3586,7 +3586,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize2(uri, options) {
+    function normalize6(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         serialize(parse5(uri, options), options);
@@ -3596,55 +3596,55 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve5(baseURI, relativeURI, options) {
+    function resolve6(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse5(baseURI, schemelessOptions), parse5(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative3, options, skipNormalization) {
+    function resolveComponent(base, relative4, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse5(serialize(base, options), options);
-        relative3 = parse5(serialize(relative3, options), options);
+        relative4 = parse5(serialize(relative4, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative3.scheme) {
-        target.scheme = relative3.scheme;
-        target.userinfo = relative3.userinfo;
-        target.host = relative3.host;
-        target.port = relative3.port;
-        target.path = removeDotSegments(relative3.path || "");
-        target.query = relative3.query;
+      if (!options.tolerant && relative4.scheme) {
+        target.scheme = relative4.scheme;
+        target.userinfo = relative4.userinfo;
+        target.host = relative4.host;
+        target.port = relative4.port;
+        target.path = removeDotSegments(relative4.path || "");
+        target.query = relative4.query;
       } else {
-        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
-          target.userinfo = relative3.userinfo;
-          target.host = relative3.host;
-          target.port = relative3.port;
-          target.path = removeDotSegments(relative3.path || "");
-          target.query = relative3.query;
+        if (relative4.userinfo !== void 0 || relative4.host !== void 0 || relative4.port !== void 0) {
+          target.userinfo = relative4.userinfo;
+          target.host = relative4.host;
+          target.port = relative4.port;
+          target.path = removeDotSegments(relative4.path || "");
+          target.query = relative4.query;
         } else {
-          if (!relative3.path) {
+          if (!relative4.path) {
             target.path = base.path;
-            if (relative3.query !== void 0) {
-              target.query = relative3.query;
+            if (relative4.query !== void 0) {
+              target.query = relative4.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative3.path[0] === "/") {
-              target.path = removeDotSegments(relative3.path);
+            if (relative4.path[0] === "/") {
+              target.path = removeDotSegments(relative4.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative3.path;
+                target.path = "/" + relative4.path;
               } else if (!base.path) {
-                target.path = relative3.path;
+                target.path = relative4.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative4.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative3.query;
+            target.query = relative4.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3652,7 +3652,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative3.fragment;
+      target.fragment = relative4.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -3822,8 +3822,8 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize: normalize2,
-      resolve: resolve5,
+      normalize: normalize6,
+      resolve: resolve6,
       resolveComponent,
       equal,
       serialize,
@@ -6799,12 +6799,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs8, exportName) {
+    function addFormats(ajv, list, fs10, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs8[f]);
+        ajv.addFormat(f, fs10[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -7290,8 +7290,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path10, errorMaps, issueData } = params;
-  const fullPath = [...path10, ...issueData.path || []];
+  const { data, path: path12, errorMaps, issueData } = params;
+  const fullPath = [...path12, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7407,11 +7407,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path10, key) {
+  constructor(parent, value, path12, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path10;
+    this._path = path12;
     this._key = key;
   }
   get path() {
@@ -11048,15 +11048,15 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path10) {
-  if (!path10)
+function getElementAtPath(obj, path12) {
+  if (!path12)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path12.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises).then((results) => {
+  const promises2 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises2).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -11371,11 +11371,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path10, issues) {
+function prefixIssues(path12, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path12);
     return iss;
   });
 }
@@ -16674,7 +16674,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
+        await new Promise((resolve6) => setTimeout(resolve6, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -16691,7 +16691,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -16769,7 +16769,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve5(parseResult.data);
+            resolve6(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -17030,12 +17030,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve5, interval);
+      const timeoutId = setTimeout(resolve6, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -17764,12 +17764,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve5();
+        resolve6();
       } else {
-        this._stdout.once("drain", resolve5);
+        this._stdout.once("drain", resolve6);
       }
     });
   }
@@ -17972,7 +17972,7 @@ var LspClient = class {
 Install with: ${this.serverConfig.installHint}`
       );
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       this.process = (0, import_child_process2.spawn)(this.serverConfig.command, this.serverConfig.args, {
         cwd: this.workspaceRoot,
         stdio: ["pipe", "pipe", "pipe"],
@@ -17998,7 +17998,7 @@ Install with: ${this.serverConfig.installHint}`
       });
       this.initialize().then(() => {
         this.initialized = true;
-        resolve5();
+        resolve6();
       }).catch(reject);
     });
   }
@@ -18106,13 +18106,13 @@ Install with: ${this.serverConfig.installHint}`
     const message = `Content-Length: ${Buffer.byteLength(content)}\r
 \r
 ${content}`;
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const timeoutHandle = setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(new Error(`LSP request '${method}' timed out after ${timeout}ms`));
       }, timeout);
       this.pendingRequests.set(id, {
-        resolve: resolve5,
+        resolve: resolve6,
         reject,
         timeout: timeoutHandle
       });
@@ -18181,7 +18181,7 @@ ${content}`;
       }
     });
     this.openDocuments.add(uri);
-    await new Promise((resolve5) => setTimeout(resolve5, 100));
+    await new Promise((resolve6) => setTimeout(resolve6, 100));
   }
   /**
    * Close a document
@@ -18347,8 +18347,46 @@ var LspClientManager = class {
   lastUsed = /* @__PURE__ */ new Map();
   inFlightCount = /* @__PURE__ */ new Map();
   idleTimer = null;
+  warmupPromises = /* @__PURE__ */ new Map();
+  symbolCache = /* @__PURE__ */ new Map();
   constructor() {
     this.startIdleCheck();
+    this.warmupCommonServers();
+  }
+  /**
+   * Warmup common language servers in background
+   */
+  warmupCommonServers() {
+    const cwd = process.cwd();
+    const commonServers = ["typescript", "python"];
+    for (const serverKey of commonServers) {
+      const config2 = getServerForFile(`.${serverKey === "typescript" ? "ts" : "py"}`);
+      if (config2 && commandExists(config2.command)) {
+        const key = `${cwd}:${config2.command}`;
+        const warmup = (async () => {
+          try {
+            const client = new LspClient(cwd, config2);
+            await client.connect();
+            this.clients.set(key, client);
+            this.lastUsed.set(key, Date.now());
+            const symbols = await client.workspaceSymbols("");
+            this.symbolCache.set(key, { symbols, timestamp: Date.now() });
+          } catch {
+          }
+        })();
+        this.warmupPromises.set(key, warmup);
+      }
+    }
+  }
+  /**
+   * Get cached workspace symbols if available
+   */
+  getCachedSymbols(key) {
+    const cached2 = this.symbolCache.get(key);
+    if (cached2 && Date.now() - cached2.timestamp < 3e5) {
+      return cached2.symbols;
+    }
+    return null;
   }
   /**
    * Get or create a client for a file
@@ -18360,6 +18398,11 @@ var LspClientManager = class {
     }
     const workspaceRoot = this.findWorkspaceRoot(filePath);
     const key = `${workspaceRoot}:${serverConfig.command}`;
+    const warmup = this.warmupPromises.get(key);
+    if (warmup) {
+      await warmup;
+      this.warmupPromises.delete(key);
+    }
     let client = this.clients.get(key);
     if (!client) {
       client = new LspClient(workspaceRoot, serverConfig);
@@ -18381,6 +18424,11 @@ var LspClientManager = class {
     }
     const workspaceRoot = this.findWorkspaceRoot(filePath);
     const key = `${workspaceRoot}:${serverConfig.command}`;
+    const warmup = this.warmupPromises.get(key);
+    if (warmup) {
+      await warmup;
+      this.warmupPromises.delete(key);
+    }
     let client = this.clients.get(key);
     if (!client) {
       client = new LspClient(workspaceRoot, serverConfig);
@@ -18480,6 +18528,8 @@ var LspClientManager = class {
     this.clients.clear();
     this.lastUsed.clear();
     this.inFlightCount.clear();
+    this.warmupPromises.clear();
+    this.symbolCache.clear();
   }
   /** Expose in-flight count for testing */
   getInFlightCount(key) {
@@ -18548,11 +18598,12 @@ function formatRange(range) {
 function formatLocation(location) {
   const uri = location.uri || location.targetUri;
   if (!uri) return "Unknown location";
-  const path10 = uriToPath(uri);
-  const locationRange = location.range || location.targetRange || location.targetSelectionRange;
-  if (!locationRange) return path10;
+  const path12 = uriToPath(uri);
+  const loc = location;
+  const locationRange = loc.range || loc.targetRange || loc.targetSelectionRange;
+  if (!locationRange) return path12;
   const range = formatRange(locationRange);
-  return `${path10}:${range}`;
+  return `${path12}:${range}`;
 }
 function formatHover(hover) {
   if (!hover) return "No hover information available";
@@ -18638,8 +18689,8 @@ function formatWorkspaceEdit(edit) {
   const lines = [];
   if (edit.changes) {
     for (const [uri, changes] of Object.entries(edit.changes)) {
-      const path10 = uriToPath(uri);
-      lines.push(`File: ${path10}`);
+      const path12 = uriToPath(uri);
+      lines.push(`File: ${path12}`);
       for (const change of changes) {
         const range = formatRange(change.range);
         const preview = change.newText.length > 50 ? change.newText.slice(0, 50) + "..." : change.newText;
@@ -18649,8 +18700,8 @@ function formatWorkspaceEdit(edit) {
   }
   if (edit.documentChanges) {
     for (const docChange of edit.documentChanges) {
-      const path10 = uriToPath(docChange.textDocument.uri);
-      lines.push(`File: ${path10}`);
+      const path12 = uriToPath(docChange.textDocument.uri);
+      lines.push(`File: ${path12}`);
       for (const change of docChange.edits) {
         const range = formatRange(change.range);
         const preview = change.newText.length > 50 ? change.newText.slice(0, 50) + "..." : change.newText;
@@ -18738,6 +18789,11 @@ function parseTscOutput(output) {
 // src/tools/diagnostics/lsp-aggregator.ts
 var import_fs3 = require("fs");
 var import_path4 = require("path");
+
+// src/tools/diagnostics/constants.ts
+var LSP_DIAGNOSTICS_WAIT_MS = 300;
+
+// src/tools/diagnostics/lsp-aggregator.ts
 function findFiles(directory, extensions, ignoreDirs = []) {
   const results = [];
   const ignoreDirSet = new Set(ignoreDirs);
@@ -18777,7 +18833,7 @@ async function runLspAggregatedDiagnostics(directory, extensions = [".ts", ".tsx
     try {
       await lspClientManager.runWithClientLease(file, async (client) => {
         await client.openDocument(file);
-        await new Promise((resolve5) => setTimeout(resolve5, LSP_DIAGNOSTICS_WAIT_MS));
+        await new Promise((resolve6) => setTimeout(resolve6, LSP_DIAGNOSTICS_WAIT_MS));
         const diagnostics = client.getDiagnostics(file);
         for (const diagnostic of diagnostics) {
           allDiagnostics.push({
@@ -18803,7 +18859,6 @@ async function runLspAggregatedDiagnostics(directory, extensions = [".ts", ".tsx
 }
 
 // src/tools/diagnostics/index.ts
-var LSP_DIAGNOSTICS_WAIT_MS = 300;
 async function runDirectoryDiagnostics(directory, strategy = "auto") {
   const tsconfigPath = (0, import_path5.join)(directory, "tsconfig.json");
   const hasTsconfig = (0, import_fs4.existsSync)(tsconfigPath);
@@ -19028,7 +19083,7 @@ var lspDiagnosticsTool = {
     const { file, severity } = args;
     return withLspClient(file, "diagnostics", async (client) => {
       await client.openDocument(file);
-      await new Promise((resolve5) => setTimeout(resolve5, LSP_DIAGNOSTICS_WAIT_MS));
+      await new Promise((resolve6) => setTimeout(resolve6, LSP_DIAGNOSTICS_WAIT_MS));
       let diagnostics = client.getDiagnostics(file);
       if (severity) {
         const severityMap = {
@@ -19259,10 +19314,35 @@ var lspTools = [
 var import_fs5 = require("fs");
 var import_path6 = require("path");
 var import_module = require("module");
+var import_child_process4 = require("child_process");
 var import_meta = {};
 var sgModule = null;
 var sgLoadFailed = false;
 var sgLoadError = "";
+var installAttempted = false;
+async function tryInstallAstGrep() {
+  if (process.env.AST_AUTO_INSTALL === "false") {
+    return false;
+  }
+  try {
+    (0, import_child_process4.execSync)("npm --version", { stdio: "ignore", timeout: 5e3 });
+  } catch {
+    sgLoadError = "npm not available";
+    return false;
+  }
+  try {
+    console.log("Installing @ast-grep/napi...");
+    (0, import_child_process4.execSync)("npm install -g @ast-grep/napi --silent", {
+      stdio: "inherit",
+      timeout: 3e4
+    });
+    console.log("Installation complete");
+    return true;
+  } catch (error2) {
+    sgLoadError = `Installation failed: ${error2 instanceof Error ? error2.message : String(error2)}`;
+    return false;
+  }
+}
 async function getSgModule() {
   if (sgLoadFailed) {
     return null;
@@ -19275,6 +19355,26 @@ async function getSgModule() {
       try {
         sgModule = await import("@ast-grep/napi");
       } catch (error2) {
+        if (!installAttempted) {
+          installAttempted = true;
+          const installed = await tryInstallAstGrep();
+          if (installed) {
+            try {
+              const require2 = (0, import_module.createRequire)(import_meta.url || __filename || process.cwd() + "/");
+              sgModule = require2("@ast-grep/napi");
+              return sgModule;
+            } catch {
+              try {
+                sgModule = await import("@ast-grep/napi");
+                return sgModule;
+              } catch (retryError) {
+                sgLoadFailed = true;
+                sgLoadError = retryError instanceof Error ? retryError.message : String(retryError);
+                return null;
+              }
+            }
+          }
+        }
         sgLoadFailed = true;
         sgLoadError = error2 instanceof Error ? error2.message : String(error2);
         return null;
@@ -19359,6 +19459,27 @@ var EXT_TO_LANG = {
   ".yaml": "yaml",
   ".yml": "yaml"
 };
+async function readFileStream(filePath, onProgress) {
+  const stat = (0, import_fs5.statSync)(filePath);
+  const fileSize = stat.size;
+  const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024;
+  if (fileSize < LARGE_FILE_THRESHOLD) {
+    return (0, import_fs5.readFileSync)(filePath, "utf-8");
+  }
+  return new Promise((resolve6, reject) => {
+    const chunks = [];
+    let bytesRead = 0;
+    const stream = (0, import_fs5.createReadStream)(filePath, { encoding: "utf-8" });
+    stream.on("data", (chunk) => {
+      const str = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+      chunks.push(str);
+      bytesRead += Buffer.byteLength(str, "utf-8");
+      onProgress?.(bytesRead, fileSize);
+    });
+    stream.on("end", () => resolve6(chunks.join("")));
+    stream.on("error", reject);
+  });
+}
 function getFilesForLanguage(dirPath, language, maxFiles = 1e3) {
   const files = [];
   const extensions = Object.entries(EXT_TO_LANG).filter(([_, lang]) => lang === language).map(([ext]) => ext);
@@ -19440,30 +19561,41 @@ Note: Patterns must be valid AST nodes for the language.`,
     const {
       pattern,
       language,
-      path: path10 = ".",
+      path: path12 = ".",
       context = 2,
       maxResults = 20
     } = args;
     try {
       const sg = await getSgModule();
       if (!sg) {
+        const errorMsg = installAttempted ? `Auto-installation failed: ${sgLoadError}
+
+Please install manually:
+  npm install -g @ast-grep/napi
+
+Or disable auto-install:
+  export AST_AUTO_INSTALL=false` : `@ast-grep/napi is not available.
+
+Install manually:
+  npm install -g @ast-grep/napi
+
+Error: ${sgLoadError}`;
         return {
           content: [
             {
               type: "text",
-              text: `@ast-grep/napi is not available. Install it with: npm install -g @ast-grep/napi
-Error: ${sgLoadError}`
+              text: errorMsg
             }
           ]
         };
       }
-      const files = getFilesForLanguage(path10, language);
+      const files = getFilesForLanguage(path12, language);
       if (files.length === 0) {
         return {
           content: [
             {
               type: "text",
-              text: `No ${language} files found in ${path10}`
+              text: `No ${language} files found in ${path12}`
             }
           ]
         };
@@ -19473,7 +19605,7 @@ Error: ${sgLoadError}`
       for (const filePath of files) {
         if (totalMatches >= maxResults) break;
         try {
-          const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
+          const content = await readFileStream(filePath);
           const root = sg.parse(toLangEnum(sg, language), content).root();
           const matches = root.findAll(pattern);
           for (const match of matches) {
@@ -19503,7 +19635,7 @@ Error: ${sgLoadError}`
               type: "text",
               text: `No matches found for pattern: ${pattern}
 
-Searched ${files.length} ${language} file(s) in ${path10}
+Searched ${files.length} ${language} file(s) in ${path12}
 
 Tip: Ensure the pattern is a valid AST node. For example:
 - Use "function $NAME" not just "$NAME"
@@ -19563,27 +19695,38 @@ IMPORTANT: dryRun=true (default) only previews changes. Set dryRun=false to appl
     dryRun: external_exports.boolean().optional().describe("Preview only, don't apply changes (default: true)")
   },
   handler: async (args) => {
-    const { pattern, replacement, language, path: path10 = ".", dryRun = true } = args;
+    const { pattern, replacement, language, path: path12 = ".", dryRun = true } = args;
     try {
       const sg = await getSgModule();
       if (!sg) {
+        const errorMsg = installAttempted ? `Auto-installation failed: ${sgLoadError}
+
+Please install manually:
+  npm install -g @ast-grep/napi
+
+Or disable auto-install:
+  export AST_AUTO_INSTALL=false` : `@ast-grep/napi is not available.
+
+Install manually:
+  npm install -g @ast-grep/napi
+
+Error: ${sgLoadError}`;
         return {
           content: [
             {
               type: "text",
-              text: `@ast-grep/napi is not available. Install it with: npm install -g @ast-grep/napi
-Error: ${sgLoadError}`
+              text: errorMsg
             }
           ]
         };
       }
-      const files = getFilesForLanguage(path10, language);
+      const files = getFilesForLanguage(path12, language);
       if (files.length === 0) {
         return {
           content: [
             {
               type: "text",
-              text: `No ${language} files found in ${path10}`
+              text: `No ${language} files found in ${path12}`
             }
           ]
         };
@@ -19592,7 +19735,7 @@ Error: ${sgLoadError}`
       let totalReplacements = 0;
       for (const filePath of files) {
         try {
-          const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
+          const content = await readFileStream(filePath);
           const root = sg.parse(toLangEnum(sg, language), content).root();
           const matches = root.findAll(pattern);
           if (matches.length === 0) continue;
@@ -19651,7 +19794,7 @@ Error: ${sgLoadError}`
               type: "text",
               text: `No matches found for pattern: ${pattern}
 
-Searched ${files.length} ${language} file(s) in ${path10}`
+Searched ${files.length} ${language} file(s) in ${path12}`
             }
           ]
         };
@@ -19802,7 +19945,7 @@ var fsSync2 = __toESM(require("fs"), 1);
 var path4 = __toESM(require("path"), 1);
 var os2 = __toESM(require("os"), 1);
 var crypto3 = __toESM(require("crypto"), 1);
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 var import_util6 = require("util");
 
 // src/lib/atomic-write.ts
@@ -19901,7 +20044,6 @@ function atomicWriteJsonSync(filePath, data) {
 }
 async function safeReadJson(filePath) {
   try {
-    await fs2.access(filePath);
     const content = await fs2.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
@@ -19909,7 +20051,7 @@ async function safeReadJson(filePath) {
     if (error2.code === "ENOENT") {
       return null;
     }
-    return null;
+    throw err;
   }
 }
 
@@ -19917,10 +20059,10 @@ async function safeReadJson(filePath) {
 var path3 = __toESM(require("path"), 1);
 
 // src/platform/process-utils.ts
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 var import_util5 = require("util");
 var fsPromises = __toESM(require("fs/promises"), 1);
-var execFileAsync = (0, import_util5.promisify)(import_child_process4.execFile);
+var execFileAsync = (0, import_util5.promisify)(import_child_process5.execFile);
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -19998,7 +20140,7 @@ async function getProcessStartTimeLinux(pid) {
 var PLATFORM = process.platform;
 
 // src/tools/python-repl/session-lock.ts
-var execFileAsync2 = (0, import_util6.promisify)(import_child_process5.execFile);
+var execFileAsync2 = (0, import_util6.promisify)(import_child_process6.execFile);
 var STALE_LOCK_AGE_MS = 6e4;
 var DEFAULT_ACQUIRE_TIMEOUT_MS = 3e4;
 var LOCK_RETRY_INTERVAL_MS = 100;
@@ -20283,7 +20425,7 @@ var SessionLock = class {
   }
 };
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 
 // src/tools/python-repl/socket-client.ts
@@ -20313,7 +20455,7 @@ var JsonRpcError = class extends Error {
   }
 };
 async function sendSocketRequest(socketPath, method, params, timeout = 6e4) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const id = (0, import_crypto.randomUUID)();
     const request = {
       jsonrpc: "2.0",
@@ -20377,7 +20519,7 @@ async function sendSocketRequest(socketPath, method, params, timeout = 6e4) {
             ));
             return;
           }
-          resolve5(response.result);
+          resolve6(response.result);
         } catch (e) {
           reject(new Error(
             `Failed to parse JSON-RPC response: ${e.message}`
@@ -20425,15 +20567,15 @@ async function sendSocketRequest(socketPath, method, params, timeout = 6e4) {
 }
 
 // src/tools/python-repl/bridge-manager.ts
-var import_child_process6 = require("child_process");
+var import_child_process7 = require("child_process");
 var fs4 = __toESM(require("fs"), 1);
 var fsPromises2 = __toESM(require("fs/promises"), 1);
 var path5 = __toESM(require("path"), 1);
 var import_url2 = require("url");
-var import_child_process7 = require("child_process");
+var import_child_process8 = require("child_process");
 var import_util7 = require("util");
 var import_meta2 = {};
-var execFileAsync3 = (0, import_util7.promisify)(import_child_process7.execFile);
+var execFileAsync3 = (0, import_util7.promisify)(import_child_process8.execFile);
 var BRIDGE_SPAWN_TIMEOUT_MS = 3e4;
 var DEFAULT_GRACE_PERIOD_MS = 5e3;
 var SIGTERM_GRACE_MS = 2500;
@@ -20561,12 +20703,15 @@ async function spawnBridgeServer(sessionId, projectDir) {
   const effectiveProjectDir = projectDir || process.cwd();
   const pythonEnv = await ensurePythonEnvironment(effectiveProjectDir);
   const bridgeArgs = [bridgePath, socketPath];
-  const proc = (0, import_child_process6.spawn)(pythonEnv.pythonPath, bridgeArgs, {
+  const proc = (0, import_child_process7.spawn)(pythonEnv.pythonPath, bridgeArgs, {
     stdio: ["ignore", "ignore", "pipe"],
     cwd: effectiveProjectDir,
     env: { ...process.env, PYTHONUNBUFFERED: "1" },
     detached: true
   });
+  if (!proc.pid) {
+    throw new Error("Failed to spawn bridge server: no PID assigned");
+  }
   proc.unref();
   const MAX_STDERR_CHARS = 64 * 1024;
   let stderrBuffer = "";
@@ -20612,7 +20757,7 @@ async function spawnBridgeServer(sessionId, projectDir) {
 async function ensureBridge(sessionId, projectDir) {
   const metaPath = getBridgeMetaPath(sessionId);
   const expectedSocketPath = getBridgeSocketPath(sessionId);
-  const meta = await safeReadJson(metaPath);
+  const meta = await safeReadJson(metaPath).catch(() => null);
   if (meta && isValidBridgeMeta(meta)) {
     if (meta.sessionId !== sessionId) {
       await deleteBridgeMeta(sessionId);
@@ -20641,7 +20786,7 @@ async function killBridgeWithEscalation(sessionId, options) {
   const gracePeriod = options?.gracePeriodMs ?? DEFAULT_GRACE_PERIOD_MS;
   const startTime = Date.now();
   const metaPath = getBridgeMetaPath(sessionId);
-  const meta = await safeReadJson(metaPath);
+  const meta = await safeReadJson(metaPath).catch(() => null);
   if (!meta || !isValidBridgeMeta(meta)) {
     return { terminated: true };
   }
@@ -20695,7 +20840,7 @@ async function deleteBridgeMeta(sessionId) {
   }
 }
 function sleep2(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 
 // src/tools/python-repl/tool.ts
@@ -21137,13 +21282,86 @@ function resetExecutionCounter(sessionId) {
   executionCounters.delete(sessionId);
 }
 
+// src/tools/python-repl/index.ts
+var pythonReplTool2 = {
+  name: "python_repl",
+  description: `Execute Python code in a persistent REPL environment with variable persistence across invocations.
+
+Actions:
+- execute: Run Python code (variables persist between calls)
+- reset: Clear namespace and reset environment
+- get_state: Get memory usage and list of defined variables
+- interrupt: Stop long-running execution
+
+Features:
+- Variables persist across tool calls within the same session
+- Structured output markers: [OBJECTIVE], [DATA], [FINDING], [STAT:*], [LIMITATION]
+- Memory tracking (RSS/VMS)
+- Automatic timeout handling (default 5 minutes)
+- Session locking for safe concurrent access
+
+Use this instead of Bash heredocs when you need:
+- Multi-step analysis with state persistence
+- Large datasets that shouldn't be reloaded
+- Iterative ML model training
+- Any workflow benefiting from Python state persistence`,
+  schema: pythonReplSchema,
+  handler: pythonReplHandler
+};
+
 // src/tools/state-tools.ts
 var import_fs8 = require("fs");
 
 // src/lib/worktree-paths.ts
-var import_child_process8 = require("child_process");
 var import_fs6 = require("fs");
 var import_path7 = require("path");
+
+// src/lib/git-utils.ts
+var import_child_process9 = require("child_process");
+var GIT_TIMEOUT = 5e3;
+var CACHE_TTL = 1e3;
+var cache = /* @__PURE__ */ new Map();
+function getCached(key) {
+  const entry = cache.get(key);
+  if (!entry) return null;
+  if (Date.now() - entry.timestamp > CACHE_TTL) {
+    cache.delete(key);
+    return null;
+  }
+  return entry.value;
+}
+function setCache(key, value) {
+  cache.set(key, { value, timestamp: Date.now() });
+}
+function execGit(command, cwd) {
+  try {
+    return (0, import_child_process9.execSync)(`git --no-pager ${command}`, {
+      cwd,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: process.platform === "win32" ? "cmd.exe" : void 0
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function getWorktreeRoot(cwd) {
+  const key = `root:${cwd || process.cwd()}`;
+  const cached2 = getCached(key);
+  if (cached2) return cached2;
+  try {
+    const root = execGit("rev-parse --show-toplevel", cwd);
+    if (root) {
+      setCache(key, root);
+      return root;
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/lib/worktree-paths.ts
 var OmcPaths = {
   ROOT: ".omc",
   STATE: ".omc/state",
@@ -21159,23 +21377,8 @@ var OmcPaths = {
   AUTOPILOT: ".omc/autopilot",
   SKILLS: ".omc/skills"
 };
-var worktreeCache = null;
-function getWorktreeRoot(cwd) {
-  const effectiveCwd = cwd || process.cwd();
-  if (worktreeCache && worktreeCache.cwd === effectiveCwd) {
-    return worktreeCache.root || null;
-  }
-  try {
-    const root = (0, import_child_process8.execSync)("git rev-parse --show-toplevel", {
-      cwd: effectiveCwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    worktreeCache = { cwd: effectiveCwd, root };
-    return root;
-  } catch {
-    return null;
-  }
+function getWorktreeRoot2(cwd) {
+  return getWorktreeRoot(cwd);
 }
 function validatePath(inputPath) {
   if (inputPath.includes("..")) {
@@ -21187,7 +21390,7 @@ function validatePath(inputPath) {
 }
 function resolveOmcPath(relativePath, worktreeRoot) {
   validatePath(relativePath);
-  const root = worktreeRoot || getWorktreeRoot() || process.cwd();
+  const root = worktreeRoot || getWorktreeRoot2() || process.cwd();
   const omcDir = (0, import_path7.join)(root, OmcPaths.ROOT);
   const fullPath = (0, import_path7.normalize)((0, import_path7.resolve)(omcDir, relativePath));
   const relativeToRoot = (0, import_path7.relative)(root, fullPath);
@@ -21211,11 +21414,11 @@ function ensureOmcDir(relativePath, worktreeRoot) {
   return fullPath;
 }
 function getWorktreeNotepadPath(worktreeRoot) {
-  const root = worktreeRoot || getWorktreeRoot() || process.cwd();
+  const root = worktreeRoot || getWorktreeRoot2() || process.cwd();
   return (0, import_path7.join)(root, OmcPaths.NOTEPAD);
 }
 function getWorktreeProjectMemoryPath(worktreeRoot) {
-  const root = worktreeRoot || getWorktreeRoot() || process.cwd();
+  const root = worktreeRoot || getWorktreeRoot2() || process.cwd();
   return (0, import_path7.join)(root, OmcPaths.PROJECT_MEMORY);
 }
 var SESSION_ID_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/;
@@ -21240,11 +21443,11 @@ function resolveSessionStatePath(stateName, sessionId, worktreeRoot) {
 }
 function getSessionStateDir(sessionId, worktreeRoot) {
   validateSessionId(sessionId);
-  const root = worktreeRoot || getWorktreeRoot() || process.cwd();
+  const root = worktreeRoot || getWorktreeRoot2() || process.cwd();
   return (0, import_path7.join)(root, OmcPaths.SESSIONS, sessionId);
 }
 function listSessionIds(worktreeRoot) {
-  const root = worktreeRoot || getWorktreeRoot() || process.cwd();
+  const root = worktreeRoot || getWorktreeRoot2() || process.cwd();
   const sessionsDir = (0, import_path7.join)(root, OmcPaths.SESSIONS);
   if (!(0, import_fs6.existsSync)(sessionsDir)) {
     return [];
@@ -21264,7 +21467,7 @@ function ensureSessionStateDir(sessionId, worktreeRoot) {
   return sessionDir;
 }
 function validateWorkingDirectory(workingDirectory) {
-  const trustedRoot = getWorktreeRoot(process.cwd()) || process.cwd();
+  const trustedRoot = getWorktreeRoot2(process.cwd()) || process.cwd();
   if (!workingDirectory) {
     return trustedRoot;
   }
@@ -21275,7 +21478,7 @@ function validateWorkingDirectory(workingDirectory) {
   } catch {
     trustedRootReal = trustedRoot;
   }
-  const providedRoot = getWorktreeRoot(resolved);
+  const providedRoot = getWorktreeRoot2(resolved);
   if (providedRoot) {
     let providedRootReal;
     try {
@@ -21514,6 +21717,129 @@ function getActiveSessionsForMode(mode, cwd) {
   return sessionIds.filter((sid) => isJsonModeActive(cwd, mode, sid));
 }
 
+// src/audit/logger.ts
+var import_crypto2 = require("crypto");
+var fs5 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
+
+// src/lib/safe-json.ts
+function safeJsonParse(content, filePath) {
+  try {
+    const data = JSON.parse(content);
+    return { success: true, data };
+  } catch (error2) {
+    const errorMsg = filePath ? `Failed to parse JSON from ${filePath}: ${error2 instanceof Error ? error2.message : String(error2)}` : `Failed to parse JSON: ${error2 instanceof Error ? error2.message : String(error2)}`;
+    return { success: false, error: errorMsg };
+  }
+}
+
+// src/lib/constants.ts
+var SIZE_LIMIT = {
+  AUDIT_LOG_MAX: 10 * 1024 * 1024,
+  // 审计日志最大 10MB
+  MAX_CONCURRENT_TASKS: 1e3,
+  // 最大并发任务数
+  MAX_TASKS_PER_CONFIG: 100,
+  // 配置中最大任务数
+  TELEGRAM_MESSAGE_MAX: 500,
+  // Telegram 消息最大长度
+  SANITIZE_DEFAULT: 30
+  // 默认清理长度
+};
+var TIME_THRESHOLD = {
+  DURATION_WARNING: 2 * 60 * 1e3,
+  // 2分钟警告
+  DURATION_CRITICAL: 5 * 60 * 1e3,
+  // 5分钟严重
+  SESSION_STALE: 24 * 60 * 60 * 1e3,
+  // 24小时过期
+  WORKING_MEMORY_TTL: 7,
+  // 工作记忆保留天数
+  UPDATE_CHECK_INTERVAL: 24
+  // 更新检查间隔(小时)
+};
+
+// src/audit/logger.ts
+var AuditLogger = class {
+  logPath;
+  secretKey;
+  maxSize = SIZE_LIMIT.AUDIT_LOG_MAX;
+  constructor(logDir) {
+    this.logPath = path6.join(logDir, "audit.log");
+    this.secretKey = this.deriveSecretKey();
+    this.ensureLogDir(logDir);
+  }
+  deriveSecretKey() {
+    const seed = process.env.OMC_AUDIT_SECRET || "default-seed";
+    return Buffer.from((0, import_crypto2.createHmac)("sha256", "omc-audit").update(seed).digest("hex"));
+  }
+  sign(entry) {
+    const payload = JSON.stringify(entry);
+    return (0, import_crypto2.createHmac)("sha256", this.secretKey).update(payload).digest("hex");
+  }
+  async log(entry) {
+    const fullEntry = {
+      ...entry,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fullEntry.signature = this.sign(fullEntry);
+    await this.appendLog(JSON.stringify(fullEntry) + "\n");
+    await this.rotateIfNeeded();
+  }
+  async appendLog(line) {
+    await fs5.promises.appendFile(this.logPath, line, "utf8");
+  }
+  async rotateIfNeeded() {
+    try {
+      const stats = await fs5.promises.stat(this.logPath);
+      if (stats.size >= this.maxSize) {
+        const rotatedPath = `${this.logPath}.${Date.now()}`;
+        await fs5.promises.rename(this.logPath, rotatedPath);
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  async verify() {
+    try {
+      const content = await fs5.promises.readFile(this.logPath, "utf8");
+      const lines = content.split("\n").filter(Boolean);
+      let valid = 0, invalid = 0;
+      for (const line of lines) {
+        const result = safeJsonParse(line);
+        if (!result.success) {
+          invalid++;
+          console.error(`[audit] Failed to parse entry: ${result.error}`);
+          continue;
+        }
+        const entry = result.data;
+        const { signature, ...payload } = entry;
+        const expectedSig = this.sign(payload);
+        if (signature === expectedSig) {
+          valid++;
+        } else {
+          invalid++;
+          console.error(`[audit] Invalid signature at ${entry.timestamp}`);
+        }
+      }
+      return { valid, invalid };
+    } catch (err) {
+      if (err.code === "ENOENT") return { valid: 0, invalid: 0 };
+      throw err;
+    }
+  }
+  ensureLogDir(dir) {
+    if (!fs5.existsSync(dir)) {
+      fs5.mkdirSync(dir, { recursive: true });
+    }
+  }
+};
+var auditLogger = new AuditLogger(".omc/logs");
+
+// src/lib/path-validator.ts
+var path7 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs"), 1);
+
 // src/lib/validateMode.ts
 var VALID_MODES = [
   "autopilot",
@@ -21532,6 +21858,27 @@ function assertValidMode(mode) {
   if (!validateMode(mode)) {
     const raw = typeof mode === "string" ? mode : String(mode);
     const display = raw.length > 50 ? `${raw.slice(0, 50)}...(truncated)` : raw;
+    if (typeof mode === "string" && (mode.includes("..") || mode.includes("/") || mode.includes("\\") || mode.startsWith(".") || /^[a-zA-Z]:/.test(mode))) {
+      auditLogger.log({
+        actor: "system",
+        action: "path_validation_failed",
+        resource: display,
+        result: "failure",
+        metadata: { reason: "path_traversal_attempt" }
+      }).catch(() => {
+      });
+      throw new Error(
+        `Path traversal attempt detected: "${display}". Valid modes are: ${VALID_MODES.join(", ")}`
+      );
+    }
+    auditLogger.log({
+      actor: "system",
+      action: "path_validation_failed",
+      resource: display,
+      result: "failure",
+      metadata: { reason: "invalid_mode" }
+    }).catch(() => {
+    });
     throw new Error(
       `Invalid mode: "${display}". Valid modes are: ${VALID_MODES.join(", ")}`
     );
@@ -21539,7 +21886,47 @@ function assertValidMode(mode) {
   return mode;
 }
 
+// src/lib/memory-utils.ts
+function pruneMap(map, maxSize) {
+  if (map.size <= maxSize) return;
+  const toDelete = map.size - maxSize;
+  let count = 0;
+  for (const key of map.keys()) {
+    if (count++ >= toDelete) break;
+    map.delete(key);
+  }
+}
+
 // src/tools/state-tools.ts
+var stateCache = /* @__PURE__ */ new Map();
+var CACHE_MAX_SIZE = 50;
+var CACHE_TTL_MS = 5e3;
+var cacheHits = 0;
+var cacheMisses = 0;
+function getCacheKey(mode, root, sessionId) {
+  return `${mode}:${root}:${sessionId || "legacy"}`;
+}
+function getCached2(key) {
+  const entry = stateCache.get(key);
+  if (!entry) {
+    cacheMisses++;
+    return null;
+  }
+  if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
+    stateCache.delete(key);
+    cacheMisses++;
+    return null;
+  }
+  cacheHits++;
+  return entry.data;
+}
+function setCache2(key, data) {
+  stateCache.set(key, { data, timestamp: Date.now() });
+  pruneMap(stateCache, CACHE_MAX_SIZE);
+}
+function invalidateCache(key) {
+  stateCache.delete(key);
+}
 var STATE_TOOL_MODES = [
   "autopilot",
   "ultrapilot",
@@ -21614,8 +22001,20 @@ Expected path: ${statePath2}`
             }]
           };
         }
-        const content = (0, import_fs8.readFileSync)(statePath2, "utf-8");
-        const state = JSON.parse(content);
+        const cacheKey = getCacheKey(mode, root, sessionId);
+        let data = getCached2(cacheKey);
+        if (!data) {
+          const content = (0, import_fs8.readFileSync)(statePath2, "utf-8");
+          const result = safeJsonParse(content, statePath2);
+          if (!result.success) {
+            return {
+              content: [{ type: "text", text: result.error }],
+              isError: true
+            };
+          }
+          data = result.data;
+          setCache2(cacheKey, data);
+        }
         return {
           content: [{
             type: "text",
@@ -21624,7 +22023,7 @@ Expected path: ${statePath2}`
 Path: ${statePath2}
 
 \`\`\`json
-${JSON.stringify(state, null, 2)}
+${JSON.stringify(data, null, 2)}
 \`\`\``
           }]
         };
@@ -21657,21 +22056,21 @@ Note: Reading from legacy/aggregate path (no session_id). This may include state
 
 `;
       if (legacyExists) {
-        try {
-          const content = (0, import_fs8.readFileSync)(statePath, "utf-8");
-          const state = JSON.parse(content);
+        const content = (0, import_fs8.readFileSync)(statePath, "utf-8");
+        const result = safeJsonParse(content, statePath);
+        if (result.success) {
           output += `### Legacy Path (shared)
 Path: ${statePath}
 
 \`\`\`json
-${JSON.stringify(state, null, 2)}
+${JSON.stringify(result.data, null, 2)}
 \`\`\`
 
 `;
-        } catch {
+        } else {
           output += `### Legacy Path (shared)
 Path: ${statePath}
-*Error reading state file*
+*${result.error}*
 
 `;
         }
@@ -21682,21 +22081,21 @@ Path: ${statePath}
 `;
         for (const sid of activeSessions) {
           const sessionStatePath = MODE_CONFIGS[mode] ? getStateFilePath(root, mode, sid) : resolveSessionStatePath(mode, sid, root);
-          try {
-            const content = (0, import_fs8.readFileSync)(sessionStatePath, "utf-8");
-            const state = JSON.parse(content);
+          const content = (0, import_fs8.readFileSync)(sessionStatePath, "utf-8");
+          const result = safeJsonParse(content, sessionStatePath);
+          if (result.success) {
             output += `**Session: ${sid}**
 Path: ${sessionStatePath}
 
 \`\`\`json
-${JSON.stringify(state, null, 2)}
+${JSON.stringify(result.data, null, 2)}
 \`\`\`
 
 `;
-          } catch {
+          } else {
             output += `**Session: ${sid}**
 Path: ${sessionStatePath}
-*Error reading state file*
+*${result.error}*
 
 `;
           }
@@ -21811,6 +22210,8 @@ var stateWriteTool = {
         }
       };
       atomicWriteJsonSync(statePath, stateWithMeta);
+      const cacheKey = getCacheKey(mode, root, sessionId);
+      invalidateCache(cacheKey);
       const sessionInfo = sessionId ? ` (session: ${sessionId})` : " (legacy path)";
       const warningMessage = sessionId ? "" : "\n\nWARNING: No session_id provided. State written to legacy shared path which may leak across parallel sessions. Pass session_id for session-scoped isolation.";
       return {
@@ -21860,6 +22261,8 @@ var stateClearTool = {
       const sessionId = session_id;
       if (sessionId) {
         validateSessionId(sessionId);
+        const cacheKey = getCacheKey(mode, root, sessionId);
+        invalidateCache(cacheKey);
         if (MODE_CONFIGS[mode]) {
           const success = clearModeState(mode, root, sessionId);
           if (success) {
@@ -21989,16 +22392,13 @@ var stateListActiveTool = {
       if (sessionId) {
         validateSessionId(sessionId);
         const activeModes = [...getActiveModes(root, sessionId)];
-        try {
-          const ralplanPath2 = resolveSessionStatePath("ralplan", sessionId, root);
-          if ((0, import_fs8.existsSync)(ralplanPath2)) {
-            const content = (0, import_fs8.readFileSync)(ralplanPath2, "utf-8");
-            const state = JSON.parse(content);
-            if (state.active) {
-              activeModes.push("ralplan");
-            }
+        const ralplanPath2 = resolveSessionStatePath("ralplan", sessionId, root);
+        if ((0, import_fs8.existsSync)(ralplanPath2)) {
+          const content = (0, import_fs8.readFileSync)(ralplanPath2, "utf-8");
+          const result = safeJsonParse(content, ralplanPath2);
+          if (result.success && result.data?.active) {
+            activeModes.push("ralplan");
           }
-        } catch {
         }
         if (activeModes.length === 0) {
           return {
@@ -22024,13 +22424,10 @@ ${modeList}`
       const legacyActiveModes = [...getActiveModes(root)];
       const ralplanPath = getStatePath("ralplan", root);
       if ((0, import_fs8.existsSync)(ralplanPath)) {
-        try {
-          const content = (0, import_fs8.readFileSync)(ralplanPath, "utf-8");
-          const state = JSON.parse(content);
-          if (state.active) {
-            legacyActiveModes.push("ralplan");
-          }
-        } catch {
+        const content = (0, import_fs8.readFileSync)(ralplanPath, "utf-8");
+        const result = safeJsonParse(content, ralplanPath);
+        if (result.success && result.data?.active) {
+          legacyActiveModes.push("ralplan");
         }
       }
       for (const mode of legacyActiveModes) {
@@ -22042,16 +22439,13 @@ ${modeList}`
       const sessionIds = listSessionIds(root);
       for (const sid of sessionIds) {
         const sessionActiveModes = [...getActiveModes(root, sid)];
-        try {
-          const ralplanSessionPath = resolveSessionStatePath("ralplan", sid, root);
-          if ((0, import_fs8.existsSync)(ralplanSessionPath)) {
-            const content = (0, import_fs8.readFileSync)(ralplanSessionPath, "utf-8");
-            const state = JSON.parse(content);
-            if (state.active) {
-              sessionActiveModes.push("ralplan");
-            }
+        const ralplanSessionPath = resolveSessionStatePath("ralplan", sid, root);
+        if ((0, import_fs8.existsSync)(ralplanSessionPath)) {
+          const content = (0, import_fs8.readFileSync)(ralplanSessionPath, "utf-8");
+          const result = safeJsonParse(content, ralplanSessionPath);
+          if (result.success && result.data?.active) {
+            sessionActiveModes.push("ralplan");
           }
-        } catch {
         }
         for (const mode of sessionActiveModes) {
           if (!modeSessionMap.has(mode)) {
@@ -22110,23 +22504,19 @@ var stateGetStatusTool = {
           validateSessionId(sessionId);
           const statePath = MODE_CONFIGS[mode] ? getStateFilePath(root, mode, sessionId) : resolveSessionStatePath(mode, sessionId, root);
           const active = MODE_CONFIGS[mode] ? isModeActive(mode, root, sessionId) : (0, import_fs8.existsSync)(statePath) && (() => {
-            try {
-              const content = (0, import_fs8.readFileSync)(statePath, "utf-8");
-              const state = JSON.parse(content);
-              return state.active === true;
-            } catch {
-              return false;
-            }
+            const content = (0, import_fs8.readFileSync)(statePath, "utf-8");
+            const result = safeJsonParse(content, statePath);
+            return result.success && result.data?.active === true;
           })();
           let statePreview = "No state file";
           if ((0, import_fs8.existsSync)(statePath)) {
-            try {
-              const content = (0, import_fs8.readFileSync)(statePath, "utf-8");
-              const state = JSON.parse(content);
-              statePreview = JSON.stringify(state, null, 2).slice(0, 500);
+            const content = (0, import_fs8.readFileSync)(statePath, "utf-8");
+            const result = safeJsonParse(content, statePath);
+            if (result.success) {
+              statePreview = JSON.stringify(result.data, null, 2).slice(0, 500);
               if (statePreview.length >= 500) statePreview += "\n...(truncated)";
-            } catch {
-              statePreview = "Error reading state file";
+            } else {
+              statePreview = result.error;
             }
           }
           lines2.push(`### Session: ${sessionId}`);
@@ -22147,13 +22537,9 @@ ${statePreview}
         }
         const legacyPath = getStatePath(mode, root);
         const legacyActive = MODE_CONFIGS[mode] ? isModeActive(mode, root) : (0, import_fs8.existsSync)(legacyPath) && (() => {
-          try {
-            const content = (0, import_fs8.readFileSync)(legacyPath, "utf-8");
-            const state = JSON.parse(content);
-            return state.active === true;
-          } catch {
-            return false;
-          }
+          const content = (0, import_fs8.readFileSync)(legacyPath, "utf-8");
+          const result = safeJsonParse(content, legacyPath);
+          return result.success && result.data?.active === true;
         })();
         lines2.push(`### Legacy Path`);
         lines2.push(`- **Active:** ${legacyActive ? "Yes" : "No"}`);
@@ -22161,17 +22547,13 @@ ${statePreview}
         lines2.push(`- **Exists:** ${(0, import_fs8.existsSync)(legacyPath) ? "Yes" : "No"}
 `);
         const activeSessions = MODE_CONFIGS[mode] ? getActiveSessionsForMode(mode, root) : listSessionIds(root).filter((sid) => {
-          try {
-            const sessionPath = resolveSessionStatePath(mode, sid, root);
-            if ((0, import_fs8.existsSync)(sessionPath)) {
-              const content = (0, import_fs8.readFileSync)(sessionPath, "utf-8");
-              const state = JSON.parse(content);
-              return state.active === true;
-            }
-            return false;
-          } catch {
-            return false;
+          const sessionPath = resolveSessionStatePath(mode, sid, root);
+          if ((0, import_fs8.existsSync)(sessionPath)) {
+            const content = (0, import_fs8.readFileSync)(sessionPath, "utf-8");
+            const result = safeJsonParse(content, sessionPath);
+            return result.success && result.data?.active === true;
           }
+          return false;
         });
         if (activeSessions.length > 0) {
           lines2.push(`### Active Sessions (${activeSessions.length})`);
@@ -22206,12 +22588,9 @@ No active sessions for this mode.`);
       const ralplanPath = sessionId ? resolveSessionStatePath("ralplan", sessionId, root) : getStatePath("ralplan", root);
       let ralplanActive = false;
       if ((0, import_fs8.existsSync)(ralplanPath)) {
-        try {
-          const content = (0, import_fs8.readFileSync)(ralplanPath, "utf-8");
-          const state = JSON.parse(content);
-          ralplanActive = state.active === true;
-        } catch {
-        }
+        const content = (0, import_fs8.readFileSync)(ralplanPath, "utf-8");
+        const result = safeJsonParse(content, ralplanPath);
+        ralplanActive = result.success && result.data?.active === true;
       }
       const ralplanIcon = ralplanActive ? "[ACTIVE]" : "[INACTIVE]";
       lines.push(`${ralplanIcon} **ralplan**: ${ralplanActive ? "Active" : "Inactive"}`);
@@ -22560,6 +22939,7 @@ ${sectionContent}`
       };
     } catch (error2) {
       return {
+        isError: true,
         content: [{
           type: "text",
           text: `Error reading notepad: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -22603,6 +22983,7 @@ var notepadWritePriorityTool = {
       };
     } catch (error2) {
       return {
+        isError: true,
         content: [{
           type: "text",
           text: `Error writing to Priority Context: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -22640,6 +23021,7 @@ var notepadWriteWorkingTool = {
       };
     } catch (error2) {
       return {
+        isError: true,
         content: [{
           type: "text",
           text: `Error writing to Working Memory: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -22677,6 +23059,7 @@ var notepadWriteManualTool = {
       };
     } catch (error2) {
       return {
+        isError: true,
         content: [{
           type: "text",
           text: `Error writing to MANUAL: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -22709,6 +23092,7 @@ var notepadPruneTool = {
       };
     } catch (error2) {
       return {
+        isError: true,
         content: [{
           type: "text",
           text: `Error pruning notepad: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -22752,6 +23136,7 @@ var notepadStatsTool = {
       };
     } catch (error2) {
       return {
+        isError: true,
         content: [{
           type: "text",
           text: `Error getting notepad stats: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -22978,7 +23363,7 @@ async function addCustomNote(projectRoot, category, content) {
 
 // src/tools/memory-tools.ts
 var projectMemoryReadTool = {
-  name: "project_memory_read",
+  name: "mem_read",
   description: "Read the project memory. Can read the full memory or a specific section.",
   schema: {
     section: external_exports.enum(["all", "techStack", "build", "conventions", "structure", "notes", "directives"]).optional().describe("Section to read (default: all)"),
@@ -23045,7 +23430,7 @@ ${JSON.stringify(data, null, 2)}
   }
 };
 var projectMemoryWriteTool = {
-  name: "project_memory_write",
+  name: "mem_write",
   description: "Write/update project memory. Can replace entirely or merge with existing memory.",
   schema: {
     memory: external_exports.record(external_exports.string(), external_exports.unknown()).describe("The memory object to write"),
@@ -23090,7 +23475,7 @@ Path: ${getWorktreeProjectMemoryPath(root)}`
   }
 };
 var projectMemoryAddNoteTool = {
-  name: "project_memory_add_note",
+  name: "mem_add_note",
   description: "Add a custom note to project memory. Notes are categorized and persisted across sessions.",
   schema: {
     category: external_exports.string().max(50).describe('Note category (e.g., "build", "test", "deploy", "env", "architecture")'),
@@ -23131,7 +23516,7 @@ var projectMemoryAddNoteTool = {
   }
 };
 var projectMemoryAddDirectiveTool = {
-  name: "project_memory_add_directive",
+  name: "mem_add_directive",
   description: "Add a user directive to project memory. Directives are instructions that persist across sessions and survive compaction.",
   schema: {
     directive: external_exports.string().max(500).describe('The directive (e.g., "Always use TypeScript strict mode")'),
@@ -23728,16 +24113,763 @@ No events recorded.`
 };
 var traceTools = [traceTimelineTool, traceSummaryTool];
 
-// src/mcp/standalone-server.ts
-var allTools = [
-  ...lspTools,
-  ...astTools,
-  pythonReplTool,
-  ...stateTools,
-  ...notepadTools,
-  ...memoryTools,
-  ...traceTools
+// src/tools/skills-tools.ts
+var import_path22 = require("path");
+var import_os4 = require("os");
+
+// src/hooks/learner/loader.ts
+var import_fs15 = require("fs");
+var import_crypto3 = require("crypto");
+var import_path21 = require("path");
+
+// src/hooks/learner/finder.ts
+var import_fs14 = require("fs");
+var import_path20 = require("path");
+
+// src/hooks/learner/constants.ts
+var import_path19 = require("path");
+var import_os3 = require("os");
+
+// src/utils/paths.ts
+var import_path18 = require("path");
+var import_fs13 = require("fs");
+var import_os2 = require("os");
+
+// src/utils/config-dir.ts
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+function getConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || (0, import_node_path.join)((0, import_node_os.homedir)(), ".claude");
+}
+
+// src/utils/paths.ts
+function getClaudeConfigDir() {
+  return getConfigDir();
+}
+
+// src/hooks/learner/constants.ts
+var USER_SKILLS_DIR = (0, import_path19.join)(getClaudeConfigDir(), "skills", "omc-learned");
+var GLOBAL_SKILLS_DIR = (0, import_path19.join)((0, import_os3.homedir)(), ".omc", "skills");
+var PROJECT_SKILLS_SUBDIR = OmcPaths.SKILLS;
+var MAX_RECURSION_DEPTH = 10;
+var SKILL_EXTENSION = ".md";
+var DEBUG_ENABLED = process.env.OMC_DEBUG === "1";
+
+// src/hooks/learner/finder.ts
+function findSkillFilesRecursive(dir, results, depth = 0) {
+  if (!(0, import_fs14.existsSync)(dir)) return;
+  if (depth > MAX_RECURSION_DEPTH) return;
+  try {
+    const entries = (0, import_fs14.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = (0, import_path20.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        findSkillFilesRecursive(fullPath, results, depth + 1);
+      } else if (entry.isFile() && entry.name.endsWith(SKILL_EXTENSION)) {
+        results.push(fullPath);
+      }
+    }
+  } catch (error2) {
+    if (DEBUG_ENABLED) {
+      console.error("[learner] Error scanning directory:", error2);
+    }
+  }
+}
+function safeRealpathSync(filePath) {
+  try {
+    return (0, import_fs14.realpathSync)(filePath);
+  } catch {
+    return filePath;
+  }
+}
+function isWithinBoundary(realPath, boundary) {
+  const normalizedReal = (0, import_path20.normalize)(realPath);
+  const normalizedBoundary = (0, import_path20.normalize)(boundary);
+  return normalizedReal === normalizedBoundary || normalizedReal.startsWith(normalizedBoundary + import_path20.sep);
+}
+function findSkillFiles(projectRoot, options) {
+  const candidates = [];
+  const seenRealPaths = /* @__PURE__ */ new Set();
+  const scope = options?.scope ?? "all";
+  if (projectRoot && (scope === "project" || scope === "all")) {
+    const projectSkillsDir = (0, import_path20.join)(projectRoot, PROJECT_SKILLS_SUBDIR);
+    const projectFiles = [];
+    findSkillFilesRecursive(projectSkillsDir, projectFiles);
+    for (const filePath of projectFiles) {
+      const realPath = safeRealpathSync(filePath);
+      if (seenRealPaths.has(realPath)) continue;
+      if (!isWithinBoundary(realPath, projectSkillsDir)) {
+        if (DEBUG_ENABLED) {
+          console.warn("[learner] Symlink escape blocked:", filePath);
+        }
+        continue;
+      }
+      seenRealPaths.add(realPath);
+      candidates.push({
+        path: filePath,
+        realPath,
+        scope: "project",
+        sourceDir: projectSkillsDir
+      });
+    }
+  }
+  if (scope === "user" || scope === "all") {
+    const userDirs = [GLOBAL_SKILLS_DIR, USER_SKILLS_DIR];
+    for (const userDir of userDirs) {
+      const userFiles = [];
+      findSkillFilesRecursive(userDir, userFiles);
+      for (const filePath of userFiles) {
+        const realPath = safeRealpathSync(filePath);
+        if (seenRealPaths.has(realPath)) continue;
+        if (!isWithinBoundary(realPath, userDir)) {
+          if (DEBUG_ENABLED) {
+            console.warn("[learner] Symlink escape blocked:", filePath);
+          }
+          continue;
+        }
+        seenRealPaths.add(realPath);
+        candidates.push({
+          path: filePath,
+          realPath,
+          scope: "user",
+          sourceDir: userDir
+        });
+      }
+    }
+  }
+  return candidates;
+}
+
+// src/hooks/learner/parser.ts
+function parseSkillFile(rawContent) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+  const match = rawContent.match(frontmatterRegex);
+  if (!match) {
+    return {
+      metadata: {},
+      content: rawContent,
+      valid: false,
+      errors: ["Missing YAML frontmatter"]
+    };
+  }
+  const yamlContent = match[1];
+  const content = match[2].trim();
+  const errors = [];
+  try {
+    const metadata = parseYamlMetadata(yamlContent);
+    if (!metadata.id && metadata.name) {
+      metadata.id = metadata.name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+    }
+    if (!metadata.source) {
+      metadata.source = "manual";
+    }
+    if (!metadata.name) errors.push("Missing required field: name");
+    if (!metadata.description) errors.push("Missing required field: description");
+    if (!metadata.triggers || metadata.triggers.length === 0) {
+      errors.push("Missing required field: triggers");
+    }
+    return {
+      metadata,
+      content,
+      valid: errors.length === 0,
+      errors
+    };
+  } catch (e) {
+    return {
+      metadata: {},
+      content: rawContent,
+      valid: false,
+      errors: [`YAML parse error: ${e}`]
+    };
+  }
+}
+function parseYamlMetadata(yamlContent) {
+  const lines = yamlContent.split("\n");
+  const metadata = {};
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      i++;
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    const rawValue = line.slice(colonIndex + 1).trim();
+    switch (key) {
+      case "id":
+        metadata.id = parseStringValue(rawValue);
+        break;
+      case "name":
+        metadata.name = parseStringValue(rawValue);
+        break;
+      case "description":
+        metadata.description = parseStringValue(rawValue);
+        break;
+      case "source":
+        metadata.source = parseStringValue(rawValue);
+        break;
+      case "createdAt":
+        metadata.createdAt = parseStringValue(rawValue);
+        break;
+      case "sessionId":
+        metadata.sessionId = parseStringValue(rawValue);
+        break;
+      case "quality":
+        metadata.quality = parseInt(rawValue, 10) || void 0;
+        break;
+      case "usageCount":
+        metadata.usageCount = parseInt(rawValue, 10) || 0;
+        break;
+      case "triggers":
+      case "tags": {
+        const { value, consumed } = parseArrayValue(rawValue, lines, i);
+        if (key === "triggers") {
+          metadata.triggers = Array.isArray(value) ? value : [value];
+        } else {
+          metadata.tags = Array.isArray(value) ? value : [value];
+        }
+        i += consumed - 1;
+        break;
+      }
+    }
+    i++;
+  }
+  return metadata;
+}
+function parseStringValue(value) {
+  if (!value) return "";
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseArrayValue(rawValue, lines, currentIndex) {
+  if (rawValue.startsWith("[")) {
+    const endIdx = rawValue.lastIndexOf("]");
+    if (endIdx === -1) return { value: [], consumed: 1 };
+    const content = rawValue.slice(1, endIdx).trim();
+    if (!content) return { value: [], consumed: 1 };
+    const items = content.split(",").map((s) => parseStringValue(s.trim())).filter(Boolean);
+    return { value: items, consumed: 1 };
+  }
+  if (!rawValue || rawValue === "") {
+    const items = [];
+    let consumed = 1;
+    for (let j = currentIndex + 1; j < lines.length; j++) {
+      const nextLine = lines[j];
+      const arrayMatch = nextLine.match(/^\s+-\s*(.*)$/);
+      if (arrayMatch) {
+        const itemValue = parseStringValue(arrayMatch[1].trim());
+        if (itemValue) items.push(itemValue);
+        consumed++;
+      } else if (nextLine.trim() === "") {
+        consumed++;
+      } else {
+        break;
+      }
+    }
+    if (items.length > 0) {
+      return { value: items, consumed };
+    }
+  }
+  return { value: parseStringValue(rawValue), consumed: 1 };
+}
+
+// src/hooks/learner/loader.ts
+function createContentHash(content) {
+  return (0, import_crypto3.createHash)("sha256").update(content).digest("hex").slice(0, 16);
+}
+function loadAllSkills(projectRoot) {
+  const candidates = findSkillFiles(projectRoot);
+  const seenIds = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    try {
+      const rawContent = (0, import_fs15.readFileSync)(candidate.path, "utf-8");
+      const { metadata, content, valid, errors } = parseSkillFile(rawContent);
+      if (!valid) {
+        if (DEBUG_ENABLED) {
+          console.warn(`Invalid skill file ${candidate.path}: ${errors.join(", ")}`);
+        }
+        continue;
+      }
+      const skillId = metadata.id;
+      const relativePath = (0, import_path21.normalize)((0, import_path21.relative)(candidate.sourceDir, candidate.path));
+      const skill = {
+        path: candidate.path,
+        relativePath,
+        scope: candidate.scope,
+        metadata,
+        content,
+        contentHash: createContentHash(content),
+        priority: candidate.scope === "project" ? 1 : 0
+      };
+      const existing = seenIds.get(skillId);
+      if (!existing || skill.priority > existing.priority) {
+        seenIds.set(skillId, skill);
+      }
+    } catch (e) {
+      if (DEBUG_ENABLED) {
+        console.warn(`Error loading skill ${candidate.path}:`, e);
+      }
+    }
+  }
+  return Array.from(seenIds.values()).sort((a, b) => b.priority - a.priority);
+}
+
+// src/tools/skills-tools.ts
+function getAllowedBoundaries() {
+  return [process.cwd(), (0, import_os4.homedir)()];
+}
+function validateProjectRoot(input) {
+  const normalized = (0, import_path22.normalize)((0, import_path22.resolve)(input));
+  if (input.includes("..")) {
+    throw new Error("Invalid project root: path traversal not allowed");
+  }
+  const isWithinAllowed = getAllowedBoundaries().some((boundary) => {
+    const normalizedBoundary = (0, import_path22.normalize)(boundary);
+    return normalized === normalizedBoundary || normalized.startsWith(normalizedBoundary + import_path22.sep);
+  });
+  if (!isWithinAllowed) {
+    throw new Error("Invalid project root: path is outside allowed directories");
+  }
+  return normalized;
+}
+var loadLocalSchema = {
+  projectRoot: external_exports.string().max(500).optional().describe("Project root directory (defaults to cwd)")
+};
+var loadGlobalSchema = {};
+var listSkillsSchema = {
+  projectRoot: external_exports.string().max(500).optional().describe("Project root directory (defaults to cwd)")
+};
+function formatSkillOutput(skills) {
+  if (skills.length === 0) {
+    return "No skills found in the searched directories.";
+  }
+  const lines = [];
+  for (const skill of skills) {
+    lines.push(`### ${skill.metadata.id}`);
+    lines.push(`- **Name:** ${skill.metadata.name}`);
+    lines.push(`- **Description:** ${skill.metadata.description}`);
+    lines.push(`- **Triggers:** ${skill.metadata.triggers.join(", ")}`);
+    if (skill.metadata.tags?.length) {
+      lines.push(`- **Tags:** ${skill.metadata.tags.join(", ")}`);
+    }
+    lines.push(`- **Scope:** ${skill.scope}`);
+    lines.push(`- **Path:** ${skill.relativePath}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var loadLocalTool = {
+  name: "load_omc_skills_local",
+  description: "Load and list skills from the project-local .omc/skills/ directory. Returns skill metadata (id, name, description, triggers, tags) for all discovered project-scoped skills.",
+  schema: loadLocalSchema,
+  handler: async (args) => {
+    const projectRoot = args.projectRoot ? validateProjectRoot(args.projectRoot) : process.cwd();
+    const allSkills = loadAllSkills(projectRoot);
+    const projectSkills = allSkills.filter((s) => s.scope === "project");
+    return {
+      content: [{
+        type: "text",
+        text: `## Project Skills (${projectSkills.length})
+
+${formatSkillOutput(projectSkills)}`
+      }]
+    };
+  }
+};
+var loadGlobalTool = {
+  name: "load_omc_skills_global",
+  description: "Load and list skills from global user directories (~/.omc/skills/ and ~/.claude/skills/omc-learned/). Returns skill metadata for all discovered user-scoped skills.",
+  schema: loadGlobalSchema,
+  handler: async (_args) => {
+    const allSkills = loadAllSkills(null);
+    const userSkills = allSkills.filter((s) => s.scope === "user");
+    return {
+      content: [{
+        type: "text",
+        text: `## Global User Skills (${userSkills.length})
+
+${formatSkillOutput(userSkills)}`
+      }]
+    };
+  }
+};
+var listSkillsTool = {
+  name: "list_omc_skills",
+  description: "List all available skills (both project-local and global user skills). Project skills take priority over user skills with the same ID.",
+  schema: listSkillsSchema,
+  handler: async (args) => {
+    const projectRoot = args.projectRoot ? validateProjectRoot(args.projectRoot) : process.cwd();
+    const skills = loadAllSkills(projectRoot);
+    const projectSkills = skills.filter((s) => s.scope === "project");
+    const userSkills = skills.filter((s) => s.scope === "user");
+    let output = `## All Available Skills (${skills.length} total)
+
+`;
+    if (projectSkills.length > 0) {
+      output += `### Project Skills (${projectSkills.length})
+
+${formatSkillOutput(projectSkills)}
+`;
+    }
+    if (userSkills.length > 0) {
+      output += `### User Skills (${userSkills.length})
+
+${formatSkillOutput(userSkills)}`;
+    }
+    if (skills.length === 0) {
+      output = "## No Skills Found\n\nNo skill files were discovered in any searched directories.\n\nSearched:\n- Project: .omc/skills/\n- Global: ~/.omc/skills/\n- Legacy: ~/.claude/skills/omc-learned/";
+    }
+    return {
+      content: [{
+        type: "text",
+        text: output
+      }]
+    };
+  }
+};
+var skillsTools = [loadLocalTool, loadGlobalTool, listSkillsTool];
+
+// src/tools/dependency-analyzer.ts
+var import_fs16 = require("fs");
+var import_path23 = require("path");
+var DependencyAnalyzerSchema = external_exports.object({
+  filePath: external_exports.string().describe("File path to analyze"),
+  depth: external_exports.number().optional().describe("Dependency depth (default: 1)")
+});
+var dependencyAnalyzerTool = {
+  name: "dependency_analyzer",
+  description: "Analyze file-level dependencies (imports/requires)",
+  schema: DependencyAnalyzerSchema.shape,
+  handler: async (args) => {
+    try {
+      const { filePath, depth = 1 } = args;
+      const content = (0, import_fs16.readFileSync)(filePath, "utf-8");
+      const deps = extractDependencies(content, filePath);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ file: filePath, dependencies: deps, depth }, null, 2)
+        }]
+      };
+    } catch (error2) {
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}`
+        }],
+        isError: true
+      };
+    }
+  }
+};
+function extractDependencies(content, filePath) {
+  const deps = [];
+  const dir = (0, import_path23.dirname)(filePath);
+  const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+  const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    deps.push(resolveImport(match[1], dir));
+  }
+  while ((match = requireRegex.exec(content)) !== null) {
+    deps.push(resolveImport(match[1], dir));
+  }
+  return [...new Set(deps)];
+}
+function resolveImport(importPath, baseDir) {
+  if (importPath.startsWith(".")) {
+    return (0, import_path23.join)(baseDir, importPath);
+  }
+  return importPath;
+}
+
+// src/tools/doc-sync.ts
+var import_fs17 = require("fs");
+var DocSyncSchema = external_exports.object({
+  sourceFile: external_exports.string().describe("Source code file with comments"),
+  targetDoc: external_exports.string().describe("Target documentation file"),
+  section: external_exports.string().optional().describe("Section to update (default: append)")
+});
+var docSyncTool = {
+  name: "doc_sync",
+  description: "Sync code comments to documentation files",
+  schema: DocSyncSchema.shape,
+  handler: async (args) => {
+    try {
+      const { sourceFile, targetDoc, section } = args;
+      const code = (0, import_fs17.readFileSync)(sourceFile, "utf-8");
+      const rules = extractSecurityRules(code);
+      if (rules.length === 0) {
+        return {
+          content: [{ type: "text", text: "No security rules found" }]
+        };
+      }
+      const docContent = (0, import_fs17.readFileSync)(targetDoc, "utf-8");
+      const updated = section ? updateSection(docContent, section, rules) : appendRules(docContent, rules);
+      (0, import_fs17.writeFileSync)(targetDoc, updated, "utf-8");
+      return {
+        content: [{
+          type: "text",
+          text: `Synced ${rules.length} rules to ${targetDoc}`
+        }]
+      };
+    } catch (error2) {
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}`
+        }],
+        isError: true
+      };
+    }
+  }
+};
+function extractSecurityRules(code) {
+  const rules = [];
+  const regex = /\/\*\*[\s\S]*?@security\s+([\s\S]*?)\*\//g;
+  let match;
+  while ((match = regex.exec(code)) !== null) {
+    rules.push(match[1].trim());
+  }
+  return rules;
+}
+function updateSection(doc, section, rules) {
+  const marker = `## ${section}`;
+  const idx = doc.indexOf(marker);
+  if (idx === -1) return appendRules(doc, rules);
+  const nextSection = doc.indexOf("\n## ", idx + marker.length);
+  const before = doc.slice(0, idx + marker.length);
+  const after = nextSection === -1 ? "" : doc.slice(nextSection);
+  return `${before}
+
+${rules.map((r) => `- ${r}`).join("\n")}
+${after}`;
+}
+function appendRules(doc, rules) {
+  return `${doc}
+
+## Auto-Generated Rules
+
+${rules.map((r) => `- ${r}`).join("\n")}
+`;
+}
+
+// src/tools/parallel-opportunity-detector.ts
+var ParallelOpportunitySchema = external_exports.object({
+  tasks: external_exports.array(external_exports.object({
+    id: external_exports.string(),
+    dependencies: external_exports.array(external_exports.string()).optional()
+  })).describe("Task list with dependencies")
+});
+var parallelOpportunityDetectorTool = {
+  name: "parallel_opportunity_detector",
+  description: "Analyze task dependency graph and recommend parallel strategies",
+  schema: ParallelOpportunitySchema.shape,
+  handler: async (args) => {
+    try {
+      const { tasks } = args;
+      const graph = buildDependencyGraph(tasks);
+      const phases = detectParallelPhases(graph);
+      const recommendation = generateRecommendation(phases);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(recommendation, null, 2)
+        }]
+      };
+    } catch (error2) {
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}`
+        }],
+        isError: true
+      };
+    }
+  }
+};
+function buildDependencyGraph(tasks) {
+  const graph = /* @__PURE__ */ new Map();
+  tasks.forEach((t) => graph.set(t.id, t.dependencies || []));
+  return graph;
+}
+function detectParallelPhases(graph) {
+  const phases = [];
+  const completed = /* @__PURE__ */ new Set();
+  while (completed.size < graph.size) {
+    const ready = Array.from(graph.entries()).filter(([id, deps]) => !completed.has(id) && deps.every((d) => completed.has(d))).map(([id]) => id);
+    if (ready.length === 0) break;
+    phases.push(ready);
+    ready.forEach((id) => completed.add(id));
+  }
+  return phases;
+}
+function generateRecommendation(phases) {
+  return {
+    totalPhases: phases.length,
+    phases: phases.map((p, i) => ({
+      phase: i + 1,
+      parallelTasks: p,
+      count: p.length
+    })),
+    strategy: phases.length > 1 ? "team" : "sequential"
+  };
+}
+
+// src/tools/tool-prefix-migration.ts
+var DEPRECATION_MAP = {
+  // LSP Tools
+  "lsp_hover": { oldName: "lsp_hover", newName: "ultrapower:lsp_hover", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_goto_definition": { oldName: "lsp_goto_definition", newName: "ultrapower:lsp_goto_definition", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_find_references": { oldName: "lsp_find_references", newName: "ultrapower:lsp_find_references", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_document_symbols": { oldName: "lsp_document_symbols", newName: "ultrapower:lsp_document_symbols", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_workspace_symbols": { oldName: "lsp_workspace_symbols", newName: "ultrapower:lsp_workspace_symbols", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_diagnostics": { oldName: "lsp_diagnostics", newName: "ultrapower:lsp_diagnostics", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_servers": { oldName: "lsp_servers", newName: "ultrapower:lsp_servers", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_prepare_rename": { oldName: "lsp_prepare_rename", newName: "ultrapower:lsp_prepare_rename", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_rename": { oldName: "lsp_rename", newName: "ultrapower:lsp_rename", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_code_actions": { oldName: "lsp_code_actions", newName: "ultrapower:lsp_code_actions", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_code_action_resolve": { oldName: "lsp_code_action_resolve", newName: "ultrapower:lsp_code_action_resolve", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "lsp_diagnostics_directory": { oldName: "lsp_diagnostics_directory", newName: "ultrapower:lsp_diagnostics_directory", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  // State Tools
+  "state_read": { oldName: "state_read", newName: "ultrapower:state_read", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "state_write": { oldName: "state_write", newName: "ultrapower:state_write", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "state_clear": { oldName: "state_clear", newName: "ultrapower:state_clear", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "state_list_active": { oldName: "state_list_active", newName: "ultrapower:state_list_active", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "state_get_status": { oldName: "state_get_status", newName: "ultrapower:state_get_status", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  // Notepad Tools
+  "notepad_read": { oldName: "notepad_read", newName: "ultrapower:notepad_read", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "notepad_write_priority": { oldName: "notepad_write_priority", newName: "ultrapower:notepad_write_priority", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "notepad_write_working": { oldName: "notepad_write_working", newName: "ultrapower:notepad_write_working", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "notepad_write_manual": { oldName: "notepad_write_manual", newName: "ultrapower:notepad_write_manual", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "notepad_prune": { oldName: "notepad_prune", newName: "ultrapower:notepad_prune", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "notepad_stats": { oldName: "notepad_stats", newName: "ultrapower:notepad_stats", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  // Memory Tools
+  "project_memory_read": { oldName: "project_memory_read", newName: "ultrapower:project_memory_read", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "project_memory_write": { oldName: "project_memory_write", newName: "ultrapower:project_memory_write", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "project_memory_add_note": { oldName: "project_memory_add_note", newName: "ultrapower:project_memory_add_note", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "project_memory_add_directive": { oldName: "project_memory_add_directive", newName: "ultrapower:project_memory_add_directive", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  // AST Tools
+  "ast_grep_search": { oldName: "ast_grep_search", newName: "ultrapower:ast_grep_search", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "ast_grep_replace": { oldName: "ast_grep_replace", newName: "ultrapower:ast_grep_replace", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  // Python REPL
+  "python_repl": { oldName: "python_repl", newName: "ultrapower:python_repl", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  // Trace Tools
+  "trace_timeline": { oldName: "trace_timeline", newName: "ultrapower:trace_timeline", deprecatedSince: "5.6.0", removalVersion: "6.0.0" },
+  "trace_summary": { oldName: "trace_summary", newName: "ultrapower:trace_summary", deprecatedSince: "5.6.0", removalVersion: "6.0.0" }
+};
+function createDeprecationWarning(info) {
+  return `\u26A0\uFE0F  DEPRECATED: Tool '${info.oldName}' is deprecated since v${info.deprecatedSince} and will be removed in v${info.removalVersion}.
+Please use '${info.newName}' instead.
+
+`;
+}
+function wrapWithDeprecation(tool) {
+  const deprecationInfo = DEPRECATION_MAP[tool.name];
+  if (!deprecationInfo) return tool;
+  const originalHandler = tool.handler;
+  return {
+    ...tool,
+    handler: async (args) => {
+      const result = await originalHandler(args);
+      const warning = createDeprecationWarning(deprecationInfo);
+      if (result.content && result.content[0]) {
+        result.content[0].text = warning + result.content[0].text;
+      }
+      return result;
+    }
+  };
+}
+function createPrefixedTool(tool) {
+  return {
+    ...tool,
+    name: `ultrapower:${tool.name}`
+  };
+}
+function registerToolWithBothNames(tool) {
+  const prefixedTool = createPrefixedTool(tool);
+  const deprecatedTool = wrapWithDeprecation(tool);
+  return [prefixedTool, deprecatedTool];
+}
+
+// src/tools/index.ts
+var allCustomTools = [
+  ...lspTools.flatMap(registerToolWithBothNames),
+  ...astTools.flatMap(registerToolWithBothNames),
+  ...registerToolWithBothNames(pythonReplTool2),
+  ...stateTools.flatMap(registerToolWithBothNames),
+  ...notepadTools.flatMap(registerToolWithBothNames),
+  ...memoryTools.flatMap(registerToolWithBothNames),
+  ...traceTools.flatMap(registerToolWithBothNames),
+  ...registerToolWithBothNames(dependencyAnalyzerTool),
+  ...registerToolWithBothNames(docSyncTool),
+  ...registerToolWithBothNames(parallelOpportunityDetectorTool),
+  ...skillsTools
 ];
+
+// src/mcp/namespace-manager.ts
+function parseNamespace(namespacedName) {
+  const match = namespacedName.match(/^mcp__([^_]+)__(.+)$/);
+  if (!match) return null;
+  return { serverName: match[1], toolName: match[2] };
+}
+function isNamespaced(name) {
+  return /^mcp__[^_]+__.+$/.test(name);
+}
+
+// src/mcp/tool-resolver.ts
+function resolveTool(name) {
+  const directMatch = allCustomTools.find((t) => t.name === name);
+  if (directMatch) return directMatch;
+  if (isNamespaced(name)) {
+    const parsed = parseNamespace(name);
+    if (parsed) {
+      return allCustomTools.find((t) => t.name === parsed.toolName);
+    }
+  }
+  return void 0;
+}
+
+// src/mcp/timeout.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+async function withTimeout(fn, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return Promise.race([
+    fn(),
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`Operation timed out after ${timeoutMs}ms`)), timeoutMs)
+    )
+  ]);
+}
+
+// src/mcp/tool-handler.ts
+async function handleToolCall(name, args) {
+  const tool = resolveTool(name);
+  if (!tool) {
+    return {
+      content: [{ type: "text", text: `Unknown tool: ${name}` }],
+      isError: true
+    };
+  }
+  try {
+    const result = await withTimeout(() => tool.handler(args ?? {}));
+    return {
+      content: result.content,
+      isError: false
+    };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return {
+      content: [{ type: "text", text: `Error executing ${name}: ${message}` }],
+      isError: true
+    };
+  }
+}
+
+// src/mcp/standalone-server.ts
+var allTools = allCustomTools;
 function zodToJsonSchema2(schema) {
   const rawShape = schema instanceof external_exports.ZodObject ? schema.shape : schema;
   const properties = {};
@@ -23819,26 +24951,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 });
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
-  const tool = allTools.find((t) => t.name === name);
-  if (!tool) {
-    return {
-      content: [{ type: "text", text: `Unknown tool: ${name}` }],
-      isError: true
-    };
-  }
-  try {
-    const result = await tool.handler(args ?? {});
-    return {
-      content: result.content,
-      isError: false
-    };
-  } catch (error2) {
-    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-    return {
-      content: [{ type: "text", text: `Error: ${errorMessage}` }],
-      isError: true
-    };
-  }
+  return handleToolCall(name, args);
 });
 async function main() {
   const transport = new StdioServerTransport();