@atlisp/mcp 1.8.21 → 1.8.25

package/dist/atlisp-mcp.js

@@ -7,10 +7,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __glob = (map) => (path20) => {
-  var fn = map[path20];
+var __glob = (map) => (path21) => {
+  var fn = map[path21];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path20);
+  throw new Error("Module not found in bundle: " + path21);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -37,7 +37,7 @@ function parseArgs() {
     } else if (args[i] === "--ws") {
       result.transport = "ws";
     } else if (args[i] === "--port" && args[i + 1]) {
-      result.port = args[i + 1];
+      result.port = parseInt(args[i + 1], 10);
       i++;
     } else if (args[i] === "--host" && args[i + 1]) {
       result.host = args[i + 1];
@@ -111,41 +111,42 @@ var envSchema, configSchema, cliArgs, envResult, env, configFilePath, fileConfig
 var init_config = __esm({
   "src/config.js"() {
     envSchema = z.object({
-      PORT: z.string().optional().default("8110"),
+      PORT: z.coerce.number().optional().default(8110),
       HOST: z.string().optional().default("0.0.0.0"),
       TRANSPORT: z.enum(["http", "stdio", "ws"]).optional().default("http"),
       MCP_API_KEY: z.string().optional().default(""),
-      ENABLE_SSE: z.string().optional().default("true"),
-      MESSAGE_TIMEOUT: z.string().optional().default("60000"),
-      HEARTBEAT_INTERVAL: z.string().optional().default("30000"),
-      BUSY_RETRIES: z.string().optional().default("10"),
-      BUSY_DELAY: z.string().optional().default("500"),
-      ENABLE_CORS: z.string().optional().default("true"),
-      CORS_ORIGIN: z.string().optional().default("*"),
-      RATE_LIMIT_WINDOW: z.string().optional().default("60000"),
-      RATE_LIMIT_MAX: z.string().optional().default("100"),
-      RESOURCE_CACHE_TTL: z.string().optional().default("5000"),
-      FUNCTION_LIB_CACHE_TTL: z.string().optional().default("300000"),
-      DEBUG: z.string().optional().default("false"),
+      ENABLE_SSE: z.coerce.boolean().optional().default(true),
+      MESSAGE_TIMEOUT: z.coerce.number().optional().default(6e4),
+      HEARTBEAT_INTERVAL: z.coerce.number().optional().default(3e4),
+      BUSY_RETRIES: z.coerce.number().optional().default(10),
+      BUSY_DELAY: z.coerce.number().optional().default(500),
+      ENABLE_CORS: z.coerce.boolean().optional().default(true),
+      CORS_ORIGIN: z.string().optional().default("https://atlisp.cn"),
+      RATE_LIMIT_WINDOW: z.coerce.number().optional().default(6e4),
+      RATE_LIMIT_MAX: z.coerce.number().optional().default(100),
+      RESOURCE_CACHE_TTL: z.coerce.number().optional().default(5e3),
+      FUNCTION_LIB_CACHE_TTL: z.coerce.number().optional().default(3e5),
+      DEBUG: z.coerce.boolean().optional().default(false),
       DEBUG_FILE: z.string().optional().default(""),
       FUNCTION_LIB_URL: z.string().optional().default("http://s3.atlisp.cn/json/functions.json"),
       CONFIG_FILE: z.string().optional().default(""),
-      API_KEY_RATE_LIMIT: z.string().optional().default("1000"),
-      METRICS_ENABLED: z.string().optional().default("true"),
-      REQUEST_LOG_ENABLED: z.string().optional().default("true"),
+      API_KEY_RATE_LIMIT: z.coerce.number().optional().default(1e3),
+      METRICS_ENABLED: z.coerce.boolean().optional().default(true),
+      REQUEST_LOG_ENABLED: z.coerce.boolean().optional().default(true),
       SSL_KEY_PATH: z.string().optional().default(""),
       SSL_CERT_PATH: z.string().optional().default(""),
       LLM_API_KEY: z.string().optional().default(""),
       LLM_API_URL: z.string().optional().default("https://api.openai.com/v1/chat/completions"),
       LLM_MODEL: z.string().optional().default("gpt-4o-mini"),
-      LLM_MAX_TOKENS: z.string().optional().default("4096"),
-      LLM_TEMPERATURE: z.string().optional().default("0.7"),
-      WORKER_POOL_SIZE: z.string().optional().default("2"),
+      LLM_MAX_TOKENS: z.coerce.number().optional().default(4096),
+      LLM_TEMPERATURE: z.coerce.number().optional().default(0.7),
+      WORKER_POOL_SIZE: z.coerce.number().optional().default(2),
       LINT_PRESET: z.string().optional().default(""),
       LINT_CONFIG_PATH: z.string().optional().default(""),
       LINT_LEVEL: z.string().optional().default(""),
-      NO_LINT: z.string().optional().default(""),
-      SECURITY_LEVEL: z.string().optional().default("strict")
+      NO_LINT: z.coerce.boolean().optional().default(false),
+      SECURITY_LEVEL: z.string().optional().default("strict"),
+      CLIENT_ID: z.string().optional().default("")
     });
     configSchema = z.object({
       port: z.number().optional(),
@@ -188,7 +189,8 @@ var init_config = __esm({
       lintConfigPath: z.string().optional(),
       lintLevel: z.string().optional(),
       noLint: z.boolean().optional(),
-      securityLevel: z.enum(["strict", "standard", "relaxed"]).optional()
+      securityLevel: z.enum(["strict", "standard", "relaxed"]).optional(),
+      clientId: z.string().optional()
     });
     cliArgs = parseArgs();
     envResult = envSchema.safeParse(process.env);
@@ -200,43 +202,44 @@ var init_config = __esm({
     configFilePath = env.CONFIG_FILE || cliArgs.configFile || path.join(os.homedir(), ".atlisp", "atlisp.config.json");
     fileConfig = loadConfigFile(configFilePath);
     config = {
-      port: fileConfig?.port || parseInt(cliArgs.port || env.PORT, 10),
-      host: fileConfig?.host || cliArgs.host || env.HOST,
+      port: fileConfig?.port ?? cliArgs.port ?? env.PORT,
+      host: fileConfig?.host ?? cliArgs.host ?? env.HOST,
       transport: fileConfig?.transport ?? cliArgs.transport ?? env.TRANSPORT,
-      apiKey: fileConfig?.apiKey || env.MCP_API_KEY,
-      enableSse: fileConfig?.enableSse ?? env.ENABLE_SSE === "true",
-      messageTimeout: fileConfig?.messageTimeout || parseInt(env.MESSAGE_TIMEOUT, 10),
-      heartbeatInterval: fileConfig?.heartbeatInterval || parseInt(env.HEARTBEAT_INTERVAL, 10),
-      busyRetries: fileConfig?.busyRetries || parseInt(env.BUSY_RETRIES, 10),
-      busyDelay: fileConfig?.busyDelay || parseInt(env.BUSY_DELAY, 10),
-      enableCors: fileConfig?.enableCors ?? env.ENABLE_CORS === "true",
-      corsOrigin: fileConfig?.corsOrigin || env.CORS_ORIGIN,
-      rateLimitWindow: fileConfig?.rateLimitWindow || parseInt(env.RATE_LIMIT_WINDOW, 10),
-      rateLimitMax: fileConfig?.rateLimitMax || parseInt(env.RATE_LIMIT_MAX, 10),
-      resourceCacheTtl: fileConfig?.resourceCacheTtl || parseInt(env.RESOURCE_CACHE_TTL, 10),
-      functionLibCacheTtl: fileConfig?.functionLibCacheTtl || parseInt(env.FUNCTION_LIB_CACHE_TTL, 10),
-      debug: fileConfig?.debug ?? env.DEBUG === "true",
-      debugFile: fileConfig?.debugFile || env.DEBUG_FILE,
-      functionLibUrl: fileConfig?.functionLibUrl || env.FUNCTION_LIB_URL,
+      apiKey: fileConfig?.apiKey ?? env.MCP_API_KEY,
+      enableSse: fileConfig?.enableSse ?? env.ENABLE_SSE,
+      messageTimeout: fileConfig?.messageTimeout ?? env.MESSAGE_TIMEOUT,
+      heartbeatInterval: fileConfig?.heartbeatInterval ?? env.HEARTBEAT_INTERVAL,
+      busyRetries: fileConfig?.busyRetries ?? env.BUSY_RETRIES,
+      busyDelay: fileConfig?.busyDelay ?? env.BUSY_DELAY,
+      enableCors: fileConfig?.enableCors ?? env.ENABLE_CORS,
+      corsOrigin: fileConfig?.corsOrigin ?? env.CORS_ORIGIN,
+      rateLimitWindow: fileConfig?.rateLimitWindow ?? env.RATE_LIMIT_WINDOW,
+      rateLimitMax: fileConfig?.rateLimitMax ?? env.RATE_LIMIT_MAX,
+      resourceCacheTtl: fileConfig?.resourceCacheTtl ?? env.RESOURCE_CACHE_TTL,
+      functionLibCacheTtl: fileConfig?.functionLibCacheTtl ?? env.FUNCTION_LIB_CACHE_TTL,
+      debug: fileConfig?.debug ?? env.DEBUG,
+      debugFile: fileConfig?.debugFile ?? env.DEBUG_FILE,
+      functionLibUrl: fileConfig?.functionLibUrl ?? env.FUNCTION_LIB_URL,
       configFile: configFilePath,
-      apiKeyRateLimit: fileConfig?.apiKeyRateLimit || parseInt(env.API_KEY_RATE_LIMIT, 10),
-      apiKeys: fileConfig?.apiKeys || [],
-      metricsEnabled: fileConfig?.metricsEnabled ?? env.METRICS_ENABLED === "true",
-      requestLogEnabled: fileConfig?.requestLogEnabled ?? env.REQUEST_LOG_ENABLED !== "false",
-      sslKey: fileConfig?.sslKey || env.SSL_KEY_PATH || cliArgs.sslKey,
-      sslCert: fileConfig?.sslCert || env.SSL_CERT_PATH || cliArgs.sslCert,
-      llmApiKey: fileConfig?.llmApiKey || env.LLM_API_KEY,
-      llmApiUrl: fileConfig?.llmApiUrl || env.LLM_API_URL,
-      llmModel: fileConfig?.llmModel || env.LLM_MODEL,
-      llmMaxTokens: fileConfig?.llmMaxTokens || parseInt(env.LLM_MAX_TOKENS, 10),
-      llmTemperature: fileConfig?.llmTemperature || parseFloat(env.LLM_TEMPERATURE),
-      maxPoolSize: fileConfig?.maxPoolSize || 3,
-      workerPoolSize: fileConfig?.workerPoolSize || parseInt(env.WORKER_POOL_SIZE, 10),
-      lintPreset: fileConfig?.lintPreset || cliArgs.lintPreset || env.LINT_PRESET || void 0,
-      lintConfigPath: fileConfig?.lintConfigPath || cliArgs.lintConfigPath || env.LINT_CONFIG_PATH || void 0,
-      lintLevel: fileConfig?.lintLevel || cliArgs.lintLevel || env.LINT_LEVEL || void 0,
-      noLint: fileConfig?.noLint ?? cliArgs.noLint ?? env.NO_LINT === "true",
-      securityLevel: fileConfig?.securityLevel ?? cliArgs.securityLevel ?? (env.SECURITY_LEVEL || "strict")
+      apiKeyRateLimit: fileConfig?.apiKeyRateLimit ?? env.API_KEY_RATE_LIMIT,
+      apiKeys: fileConfig?.apiKeys ?? [],
+      metricsEnabled: fileConfig?.metricsEnabled ?? env.METRICS_ENABLED,
+      requestLogEnabled: fileConfig?.requestLogEnabled ?? env.REQUEST_LOG_ENABLED,
+      sslKey: fileConfig?.sslKey ?? env.SSL_KEY_PATH ?? cliArgs.sslKey,
+      sslCert: fileConfig?.sslCert ?? env.SSL_CERT_PATH ?? cliArgs.sslCert,
+      llmApiKey: fileConfig?.llmApiKey ?? env.LLM_API_KEY,
+      llmApiUrl: fileConfig?.llmApiUrl ?? env.LLM_API_URL,
+      llmModel: fileConfig?.llmModel ?? env.LLM_MODEL,
+      llmMaxTokens: fileConfig?.llmMaxTokens ?? env.LLM_MAX_TOKENS,
+      llmTemperature: fileConfig?.llmTemperature ?? env.LLM_TEMPERATURE,
+      maxPoolSize: fileConfig?.maxPoolSize ?? 3,
+      workerPoolSize: fileConfig?.workerPoolSize ?? env.WORKER_POOL_SIZE,
+      lintPreset: fileConfig?.lintPreset ?? cliArgs.lintPreset ?? (env.LINT_PRESET || void 0),
+      lintConfigPath: fileConfig?.lintConfigPath ?? cliArgs.lintConfigPath ?? (env.LINT_CONFIG_PATH || void 0),
+      lintLevel: fileConfig?.lintLevel ?? cliArgs.lintLevel ?? (env.LINT_LEVEL || void 0),
+      noLint: fileConfig?.noLint ?? cliArgs.noLint ?? env.NO_LINT,
+      securityLevel: fileConfig?.securityLevel ?? cliArgs.securityLevel ?? (env.SECURITY_LEVEL || "strict"),
+      clientId: fileConfig?.clientId ?? (env.CLIENT_ID || "")
     };
     if (config.lintConfigPath) process.env.LINT_CONFIG_PATH = config.lintConfigPath;
     if (config.lintPreset) process.env.LINT_PRESET = config.lintPreset;
@@ -453,15 +456,89 @@ var init_metrics = __esm({
   }
 });
 
+// src/cad-circuit-breaker.js
+var CB_CLOSED, CB_OPEN, CB_HALF_OPEN, CB_FAILURE_THRESHOLD, CB_RESET_TIMEOUT, CircuitBreaker;
+var init_cad_circuit_breaker = __esm({
+  "src/cad-circuit-breaker.js"() {
+    CB_CLOSED = 0;
+    CB_OPEN = 1;
+    CB_HALF_OPEN = 2;
+    CB_FAILURE_THRESHOLD = 5;
+    CB_RESET_TIMEOUT = 1e4;
+    CircuitBreaker = class {
+      constructor(connectionId, onOpen, onHalfOpen) {
+        this._connId = connectionId;
+        this._state = CB_CLOSED;
+        this._failureCount = 0;
+        this._lastFailureTime = 0;
+        this._timer = null;
+        this._onOpen = onOpen;
+        this._onHalfOpen = onHalfOpen;
+      }
+      get state() {
+        return this._state;
+      }
+      get failureCount() {
+        return this._failureCount;
+      }
+      allowRequest() {
+        if (this._state === CB_OPEN) {
+          const elapsed = Date.now() - this._lastFailureTime;
+          if (elapsed >= CB_RESET_TIMEOUT) {
+            this._state = CB_HALF_OPEN;
+            if (this._onHalfOpen) this._onHalfOpen(this._connId);
+          } else {
+            return false;
+          }
+        }
+        return true;
+      }
+      recordSuccess() {
+        this._state = CB_CLOSED;
+        this._failureCount = 0;
+        if (this._timer) {
+          clearTimeout(this._timer);
+          this._timer = null;
+        }
+      }
+      recordFailure() {
+        this._failureCount++;
+        this._lastFailureTime = Date.now();
+        if (this._failureCount >= CB_FAILURE_THRESHOLD && this._state !== CB_OPEN) {
+          this._state = CB_OPEN;
+          if (this._onOpen) this._onOpen(this._connId);
+          this._timer = setTimeout(() => {
+            this._state = CB_HALF_OPEN;
+            if (this._onHalfOpen) this._onHalfOpen(this._connId);
+          }, CB_RESET_TIMEOUT);
+        }
+      }
+      reset() {
+        this._state = CB_CLOSED;
+        this._failureCount = 0;
+        this._lastFailureTime = 0;
+        if (this._timer) {
+          clearTimeout(this._timer);
+          this._timer = null;
+        }
+      }
+    };
+  }
+});
+
 // src/cad.js
 var cad_exports = {};
 __export(cad_exports, {
+  CommandQueue: () => CommandQueue,
+  ReadBatcher: () => ReadBatcher,
   _setInstanceResolver: () => _setInstanceResolver,
   cad: () => cad,
   createCadConnection: () => createCadConnection,
   default: () => cad_default,
   getActiveConnection: () => getActiveConnection,
+  isReadCommand: () => isReadCommand,
   onDocumentChanged: () => onDocumentChanged,
+  resolveCadConnection: () => resolveCadConnection,
   setActiveConnection: () => setActiveConnection
 });
 import { spawn } from "child_process";
@@ -506,22 +583,21 @@ function _resolveConn() {
   }
   return _activeConnection;
 }
-var __dirname, workerPath, MESSAGE_TIMEOUT, HEARTBEAT_INTERVAL, MAX_RESTART_ATTEMPTS, RESTART_BACKOFF_BASE, CB_CLOSED, CB_OPEN, CB_HALF_OPEN, CB_FAILURE_THRESHOLD, CB_RESET_TIMEOUT, MAX_BUFFER_SIZE, PRIORITY_HIGH, PRIORITY_NORMAL, MAX_QUEUE_SIZE, READ_PREFIXES, _docChangeCallbacks, ReadBatcher, CommandQueue, CadConnection, _activeConnection, _resolveInstanceConn, cad, cad_default;
+function resolveCadConnection() {
+  return _resolveConn();
+}
+var __dirname, workerPath, MESSAGE_TIMEOUT, HEARTBEAT_INTERVAL, MAX_RESTART_ATTEMPTS, RESTART_BACKOFF_BASE, MAX_BUFFER_SIZE, PRIORITY_HIGH, PRIORITY_NORMAL, MAX_QUEUE_SIZE, READ_PREFIXES, _docChangeCallbacks, ReadBatcher, CommandQueue, CadConnection, _activeConnection, _resolveInstanceConn, cad, cad_default;
 var init_cad = __esm({
   "src/cad.js"() {
     init_config();
     init_metrics();
+    init_cad_circuit_breaker();
     __dirname = path2.dirname(fileURLToPath(import.meta.url));
     workerPath = path2.join(__dirname, "cad-worker.js");
     MESSAGE_TIMEOUT = config_default.messageTimeout;
     HEARTBEAT_INTERVAL = config_default.heartbeatInterval;
     MAX_RESTART_ATTEMPTS = 5;
     RESTART_BACKOFF_BASE = 1e3;
-    CB_CLOSED = 0;
-    CB_OPEN = 1;
-    CB_HALF_OPEN = 2;
-    CB_FAILURE_THRESHOLD = 5;
-    CB_RESET_TIMEOUT = 1e4;
     MAX_BUFFER_SIZE = 1024 * 1024;
     PRIORITY_HIGH = 0;
     PRIORITY_NORMAL = 1;
@@ -708,10 +784,6 @@ var init_cad = __esm({
       _heartbeatTimer = null;
       _pendingRequests = /* @__PURE__ */ new Map();
       _commandQueue = null;
-      _cbState = CB_CLOSED;
-      _cbFailureCount = 0;
-      _cbLastFailureTime = 0;
-      _cbTimer = null;
       _restartCount = 0;
       _restartTimer = null;
       _activeDocName = null;
@@ -721,6 +793,11 @@ var init_cad = __esm({
       constructor() {
         this._connectionId = randomUUID().slice(0, 8);
         this._commandQueue = new CommandQueue(this);
+        this._cb = new CircuitBreaker(
+          this._connectionId,
+          (id) => console.error(`[${id}] Circuit breaker OPEN`),
+          (id) => console.error(`[${id}] Circuit breaker HALF_OPEN, allowing trial request`)
+        );
       }
       get _workerPoolSize() {
         return config_default.workerPoolSize || 2;
@@ -728,11 +805,15 @@ var init_cad = __esm({
       isAvailable() {
         return process.platform === "win32";
       }
-      async connect(platform = null) {
+      async connect(platform = null, options = {}) {
         if (!this.isAvailable()) return false;
-        this._cbSuccess();
+        this._cb.recordSuccess();
         try {
           const msg = platform ? { type: "connect", platform } : { type: "connect" };
+          if (options.moniker) {
+            msg.moniker = options.moniker;
+            msg.monikerKey = options.key || "moniker";
+          }
           const result = await this._sendMessage(msg);
           if (result && result.success) {
             this._version = result.version;
@@ -845,21 +926,8 @@ var init_cad = __esm({
         return `Platform: ${this._product}, Version: ${this._version}, Status: Connected`;
       }
       async disconnect() {
-        this.connected = false;
-        setCadConnected(false);
-        this._version = null;
-        this._product = null;
-        this._platform = null;
-        this._activeDocName = null;
-        this._monitorStarted = false;
-        this._commandQueue.clear();
-        this._cbState = CB_CLOSED;
-        this._cbFailureCount = 0;
-        if (this._cbTimer) {
-          clearTimeout(this._cbTimer);
-          this._cbTimer = null;
-        }
-        this._resetWorker();
+        this._reset();
+        this._cb.reset();
       }
       async ping() {
         try {
@@ -878,12 +946,6 @@ var init_cad = __esm({
         this._activeDocName = null;
         this._monitorStarted = false;
         this._commandQueue.clear();
-        this._cbState = CB_CLOSED;
-        this._cbFailureCount = 0;
-        if (this._cbTimer) {
-          clearTimeout(this._cbTimer);
-          this._cbTimer = null;
-        }
         this._resetWorker();
       }
       _getQueueSize() {
@@ -892,44 +954,6 @@ var init_cad = __esm({
       _getRestartCount() {
         return this._restartCount;
       }
-      // --- Circuit breaker ---
-      _cbSuccess() {
-        this._cbState = CB_CLOSED;
-        this._cbFailureCount = 0;
-        if (this._cbTimer) {
-          clearTimeout(this._cbTimer);
-          this._cbTimer = null;
-        }
-      }
-      _cbFailure() {
-        this._cbFailureCount++;
-        this._cbLastFailureTime = Date.now();
-        if (this._cbFailureCount >= CB_FAILURE_THRESHOLD && this._cbState !== CB_OPEN) {
-          this._cbState = CB_OPEN;
-          console.error(`[${this._connectionId}] Circuit breaker OPEN after ${this._cbFailureCount} failures`);
-          this._cbTimer = setTimeout(() => {
-            this._cbState = CB_HALF_OPEN;
-            console.error(`[${this._connectionId}] Circuit breaker HALF_OPEN, allowing trial request`);
-          }, CB_RESET_TIMEOUT);
-        }
-      }
-      _cbAllowRequest() {
-        if (this._cbState === CB_OPEN) {
-          const elapsed = Date.now() - this._cbLastFailureTime;
-          if (elapsed >= CB_RESET_TIMEOUT) {
-            this._cbState = CB_HALF_OPEN;
-            console.error(`[${this._connectionId}] Circuit breaker auto-transition to HALF_OPEN`);
-          } else {
-            return false;
-          }
-        }
-        return true;
-      }
-      // --- Worker management ---
-      _isReadOnlyMessage(msg) {
-        if (msg.code) return isReadCommand(msg.code);
-        return false;
-      }
       _spawnWorker(type) {
         const w = spawn("node", [workerPath], { stdio: ["pipe", "pipe", "pipe"] });
         w.connected = true;
@@ -940,7 +964,7 @@ var init_cad = __esm({
           w.connected = false;
           if (type === "primary") {
             if (w !== this._primaryWorker) return;
-            this._cbFailure();
+            this._cb.recordFailure();
             const exitError = new Error(`Primary worker exited with code ${code}`);
             for (const [id, entry] of this._pendingRequests) {
               clearTimeout(entry.timeout);
@@ -977,7 +1001,7 @@ var init_cad = __esm({
             this._primaryWorker = null;
           }
           this._primaryWorker = this._spawnWorker("primary");
-          this._cbSuccess();
+          this._cb.recordSuccess();
           if (!this._heartbeatTimer) this._startHeartbeat();
           this._restartCount = 0;
         }
@@ -1118,14 +1142,9 @@ var init_cad = __esm({
         }, delay);
       }
       async _sendMessage(msg) {
-        if (!this._cbAllowRequest()) {
+        if (!this._cb.allowRequest()) {
           console.error(`[${this._connectionId}] Circuit breaker OPEN, auto-recovering...`);
-          this._cbState = CB_CLOSED;
-          this._cbFailureCount = 0;
-          if (this._cbTimer) {
-            clearTimeout(this._cbTimer);
-            this._cbTimer = null;
-          }
+          this._cb.reset();
           await this._resetWorker();
           await this._getWorker(false);
         }
@@ -1141,17 +1160,17 @@ var init_cad = __esm({
             const p = self._pendingRequests.get(requestId);
             if (p) {
               self._pendingRequests.delete(requestId);
-              if (!noCircuitBreaker) self._cbFailure();
+              if (!noCircuitBreaker) self._cb.recordFailure();
               reject(new Error("Timeout waiting for worker"));
             }
           }, MESSAGE_TIMEOUT);
           const entry = {
             resolve: (v) => {
-              if (!noCircuitBreaker && !entry._skipCb) self._cbSuccess();
+              if (!noCircuitBreaker && !entry._skipCb) self._cb.recordSuccess();
               resolve(v);
             },
             reject: (e) => {
-              if (!noCircuitBreaker && !entry._skipCb) self._cbFailure();
+              if (!noCircuitBreaker && !entry._skipCb) self._cb.recordFailure();
               reject(e);
             },
             timeout
@@ -1162,11 +1181,15 @@ var init_cad = __esm({
           } catch (e) {
             clearTimeout(timeout);
             self._pendingRequests.delete(requestId);
-            if (!noCircuitBreaker) self._cbFailure();
+            if (!noCircuitBreaker) self._cb.recordFailure();
             reject(new Error(`Failed to write to worker: ${e.message}`));
           }
         });
       }
+      _isReadOnlyMessage(msg) {
+        if (msg.code) return isReadCommand(msg.code);
+        return false;
+      }
     };
     _activeConnection = new CadConnection();
     _resolveInstanceConn = null;
@@ -1175,28 +1198,28 @@ var init_cad = __esm({
         return _resolveConn().connected;
       },
       set connected(v) {
-        _activeConnection.connected = v;
+        _resolveConn().connected = v;
       },
       get version() {
-        return _activeConnection._version;
+        return _resolveConn()._version;
       },
       set version(v) {
-        _activeConnection._version = v;
+        _resolveConn()._version = v;
       },
       get product() {
-        return _activeConnection._product;
+        return _resolveConn()._product;
       },
       set product(v) {
-        _activeConnection._product = v;
+        _resolveConn()._product = v;
       },
       get _platform() {
-        return _activeConnection._platform;
+        return _resolveConn()._platform;
       },
       set _platform(v) {
-        _activeConnection._platform = v;
+        _resolveConn()._platform = v;
       },
       async connect(platform) {
-        return _activeConnection.connect(platform);
+        return _resolveConn().connect(platform);
       },
       async sendCommand(code) {
         return _resolveConn().sendCommand(code);
@@ -1205,49 +1228,49 @@ var init_cad = __esm({
         return _resolveConn().sendCommandWithResult(code, encoding);
       },
       getVersion() {
-        return _activeConnection.getVersion();
+        return _resolveConn().getVersion();
       },
       getPlatform() {
-        return _activeConnection.getPlatform();
+        return _resolveConn().getPlatform();
       },
       getConnectionId() {
-        return _activeConnection.getConnectionId();
+        return _resolveConn().getConnectionId();
       },
       isAvailable() {
-        return _activeConnection.isAvailable();
+        return _resolveConn().isAvailable();
       },
       async isBusy() {
-        return _activeConnection.isBusy();
+        return _resolveConn().isBusy();
       },
       async hasDoc() {
-        return _activeConnection.hasDoc();
+        return _resolveConn().hasDoc();
       },
       async newDoc() {
-        return _activeConnection.newDoc();
+        return _resolveConn().newDoc();
       },
       async bringToFront() {
-        return _activeConnection.bringToFront();
+        return _resolveConn().bringToFront();
       },
       async getActiveDocInfo() {
-        return _activeConnection.getActiveDocInfo();
+        return _resolveConn().getActiveDocInfo();
       },
       async getInfo() {
-        return _activeConnection.getInfo();
+        return _resolveConn().getInfo();
       },
       async disconnect() {
-        return _activeConnection.disconnect();
+        return _resolveConn().disconnect();
       },
       async ping() {
-        return _activeConnection.ping();
+        return _resolveConn().ping();
       },
       _reset() {
-        return _activeConnection._reset();
+        return _resolveConn()._reset();
       },
       _getQueueSize() {
-        return _activeConnection._getQueueSize();
+        return _resolveConn()._getQueueSize();
       },
       _getRestartCount() {
-        return _activeConnection._getRestartCount();
+        return _resolveConn()._getRestartCount();
       }
     };
     cad_default = CadConnection;
@@ -1258,7 +1281,7 @@ var init_cad = __esm({
 import path3 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire } from "module";
-var CAD_PLATFORMS, FILE_EXTENSIONS, __dirname2, require2, version, SERVER_NAME, SERVER_VERSION, SERVER_CAPABILITIES, MOCK_PACKAGES;
+var CAD_PLATFORMS, FILE_EXTENSIONS, __dirname2, require2, version, SERVER_NAME, SERVER_VERSION, SERVER_CAPABILITIES, MOCK_PACKAGES, CAD_RESOURCE_URIS;
 var init_constants = __esm({
   "src/constants.js"() {
     CAD_PLATFORMS = ["AutoCAD", "ZWCAD", "GStarCAD", "BricsCAD"];
@@ -1281,6 +1304,17 @@ var init_constants = __esm({
       completions: {}
     };
     MOCK_PACKAGES = [];
+    CAD_RESOURCE_URIS = [
+      "atlisp://cad/info",
+      "atlisp://dwg/name",
+      "atlisp://dwg/path",
+      "atlisp://dwg/entities",
+      "atlisp://dwg/tbl",
+      "atlisp://dwg/block-refs",
+      "atlisp://dwg/text-content",
+      "atlisp://cad/dwgs",
+      "atlisp://packages"
+    ];
   }
 });
 
@@ -1481,7 +1515,10 @@ var init_resource_defs = __esm({
       { uri: "atlisp://standards/drafting", name: "Drafting Standards", description: "CAD \u5236\u56FE\u89C4\u8303", mimeType: "application/json", subscribable: false },
       { uri: "atlisp://standards/coding", name: "Coding Standards", description: "@lisp \u7F16\u7801\u89C4\u8303", mimeType: "application/json", subscribable: false },
       { uri: "atlisp://dwg/context", name: "DWG Context", description: "\u5F53\u524D\u56FE\u7EB8\u4E0A\u4E0B\u6587\u6458\u8981\u3002\u8FD4\u56DE\u6587\u6863\u540D/\u8DEF\u5F84/\u5E03\u5C40/UCS/\u56FE\u5C42\u5217\u8868/\u5B9E\u4F53\u7EDF\u8BA1/\u7CFB\u7EDF\u53D8\u91CF\u7EC4\u5408\u4FE1\u606F\uFF0C\u5E2E\u52A9\u5FEB\u901F\u4E86\u89E3\u5F53\u524D CAD \u72B6\u6001", mimeType: "application/json", subscribable: true },
-      { uri: "atlisp://tools/relationships", name: "Tool Relationships", description: "\u5DE5\u5177\u4F9D\u8D56\u5173\u7CFB\u56FE\u3002\u63CF\u8FF0\u5DE5\u5177\u95F4\u7684\u8C03\u7528\u94FE\u5173\u7CFB\uFF08\u5982 select_entities \u2192 batch_delete\uFF09\uFF0C\u5E2E\u52A9\u7406\u89E3\u5DE5\u5177\u7EC4\u5408\u4F7F\u7528\u65B9\u5F0F", mimeType: "application/json", subscribable: false }
+      { uri: "atlisp://tools/relationships", name: "Tool Relationships", description: "\u5DE5\u5177\u4F9D\u8D56\u5173\u7CFB\u56FE\u3002\u63CF\u8FF0\u5DE5\u5177\u95F4\u7684\u8C03\u7528\u94FE\u5173\u7CFB\uFF08\u5982 select_entities \u2192 batch_delete\uFF09\uFF0C\u5E2E\u52A9\u7406\u89E3\u5DE5\u5177\u7EC4\u5408\u4F7F\u7528\u65B9\u5F0F", mimeType: "application/json", subscribable: false },
+      { uri: "atlisp://dwg/analysis", name: "Drawing Analysis", description: "\u5F53\u524D\u56FE\u7EB8\u7EFC\u5408\u5206\u6790\uFF1A\u5B9E\u4F53\u7C7B\u578B\u7EDF\u8BA1\u3001\u5757\u4F7F\u7528\u7EDF\u8BA1\u3001\u56FE\u5C42\u6458\u8981\u3001\u6587\u5B57\u7EDF\u8BA1\u3001\u7CFB\u7EDF\u53D8\u91CF\u5FEB\u7167\u3002\u652F\u6301 ?type=summary\uFF08\u9ED8\u8BA4\uFF09\u6216 ?type=detailed", mimeType: "application/json", subscribable: true },
+      { uri: "atlisp://tools/categories", name: "Tool Categories", description: "\u5DE5\u5177\u5206\u7C7B\u6982\u89C8\u3002\u5217\u51FA\u6240\u6709\u5206\u7C7B\u53CA\u5176\u5305\u542B\u7684\u5DE5\u5177\u6570\u91CF", mimeType: "application/json", subscribable: false },
+      { uri: "atlisp://dwg/standards/check", name: "Drawing Standards Check", description: "\u68C0\u67E5\u5F53\u524D\u56FE\u7EB8\u662F\u5426\u7B26\u5408\u52A0\u8F7D\u7684\u5236\u56FE\u89C4\u8303\uFF08\u56FE\u5C42\u547D\u540D\u3001\u989C\u8272\u3001\u7EBF\u578B\u7B49\u89C4\u5219\uFF09", mimeType: "application/json", subscribable: false }
     ];
     TBL_QUERIES = {
       layer: { name: "layer", lisp: `(progn
@@ -1528,49 +1565,70 @@ var init_resource_defs = __esm({
 });
 
 // src/handlers/resource-cache.js
+function _getCache() {
+  const key = _instanceKey || _defaultKey;
+  if (!_instanceCaches.has(key)) {
+    _instanceCaches.set(key, /* @__PURE__ */ new Map());
+  }
+  return _instanceCaches.get(key);
+}
+function _ttl() {
+  return config_default.resourceCacheTtl;
+}
 function ensureCleanup() {
   if (cleanupTimer) return;
   cleanupTimer = setInterval(() => {
     const now = Date.now();
-    for (const [key, entry] of resourceCache) {
-      if (now - entry.timestamp >= CACHE_TTL) {
-        resourceCache.delete(key);
+    const ttl = _ttl();
+    for (const cache of _instanceCaches.values()) {
+      for (const [key, entry] of cache) {
+        if (now - entry.timestamp >= ttl) {
+          cache.delete(key);
+        }
       }
     }
   }, CLEANUP_INTERVAL);
   cleanupTimer.unref();
 }
+function setInstanceKey(key) {
+  _instanceKey = key || null;
+}
 function getCached(key) {
-  const entry = resourceCache.get(key);
-  if (entry && Date.now() - entry.timestamp < CACHE_TTL) {
+  const cache = _getCache();
+  const entry = cache.get(key);
+  if (entry && Date.now() - entry.timestamp < _ttl()) {
     return entry.data;
   }
-  resourceCache.delete(key);
+  cache.delete(key);
   return null;
 }
 function setCache(key, data) {
-  resourceCache.set(key, { data, timestamp: Date.now() });
+  _getCache().set(key, { data, timestamp: Date.now() });
 }
 function clearCache(uri) {
-  const prefix = URI_CACHE_PREFIX[uri];
-  if (prefix) {
-    for (const key of resourceCache.keys()) {
-      if (key === prefix || key.startsWith(prefix + ":")) {
-        resourceCache.delete(key);
+  const basePrefix = URI_CACHE_PREFIX[uri];
+  if (basePrefix) {
+    const cache = _getCache();
+    for (const key of cache.keys()) {
+      if (key === basePrefix || key.startsWith(basePrefix + ":")) {
+        cache.delete(key);
       }
     }
   } else if (!uri) {
-    resourceCache.clear();
+    const key = _instanceKey || _defaultKey;
+    _instanceCaches.delete(key);
+    _instanceCaches.set(key, /* @__PURE__ */ new Map());
   }
 }
-var CACHE_TTL, resourceCache, CLEANUP_INTERVAL, cleanupTimer, URI_CACHE_PREFIX;
+var CLEANUP_INTERVAL, cleanupTimer, _instanceKey, _instanceCaches, _defaultKey, URI_CACHE_PREFIX;
 var init_resource_cache = __esm({
   "src/handlers/resource-cache.js"() {
     init_config();
-    CACHE_TTL = config_default.resourceCacheTtl;
-    resourceCache = /* @__PURE__ */ new Map();
     CLEANUP_INTERVAL = 6e4;
     cleanupTimer = null;
+    _instanceKey = null;
+    _instanceCaches = /* @__PURE__ */ new Map();
+    _defaultKey = "__default__";
     ensureCleanup();
     URI_CACHE_PREFIX = {
       "atlisp://cad/info": "cad:info",
@@ -1591,6 +1649,23 @@ function createError(code, details = {}) {
   const def = ERROR_DEFS[code] || ERROR_DEFS[ERROR_CODES.INTERNAL_ERROR];
   return new MCPError(code, def.message, details);
 }
+function toMcpError(error2) {
+  if (error2 instanceof MCPError) return error2;
+  if (error2 instanceof Error) {
+    return new MCPError(ERROR_CODES.INTERNAL_ERROR, error2.message, { stack: error2.stack });
+  }
+  return new MCPError(ERROR_CODES.INTERNAL_ERROR, String(error2));
+}
+function mcpErrorResponse(error2) {
+  const mcpErr = toMcpError(error2);
+  const json = mcpErr.toJSON();
+  return {
+    content: [{ type: "text", text: `[${json.code}] ${json.message}
+\u63D0\u793A: ${json.hint}
+\u5EFA\u8BAE\u5DE5\u5177: ${json.suggestedTools.join(", ") || "\u65E0"}` }],
+    isError: true
+  };
+}
 function mcpSuccessResponse(text) {
   return { content: [{ type: "text", text: String(text) }] };
 }
@@ -1604,9 +1679,14 @@ var init_errors = __esm({
       LISP_PAREN_MISMATCH: "LISP_PAREN_MISMATCH",
       TIMEOUT: "TIMEOUT",
       INVALID_PARAMS: "INVALID_PARAMS",
+      INVALID_ARGS: "INVALID_ARGS",
       METHOD_NOT_FOUND: "METHOD_NOT_FOUND",
+      HANDLER_NOT_FOUND: "HANDLER_NOT_FOUND",
       RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
       PACKAGE_NOT_FOUND: "PACKAGE_NOT_FOUND",
+      OPERATION_FAILED: "OPERATION_FAILED",
+      RATE_LIMITED: "RATE_LIMITED",
+      SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
       INTERNAL_ERROR: "INTERNAL_ERROR"
     };
     ERROR_DEFS = {
@@ -1640,6 +1720,31 @@ var init_errors = __esm({
         hint: "\u8BF7\u68C0\u67E5\u5DE5\u5177\u53C2\u6570\u683C\u5F0F\u662F\u5426\u6B63\u786E\u3002\u4F7F\u7528 search_tools \u6216 list_tools_by_category \u67E5\u770B\u5DE5\u5177\u53C2\u6570\u8981\u6C42",
         tools: ["search_tools", "list_tools_by_category"]
       },
+      [ERROR_CODES.INVALID_ARGS]: {
+        message: "\u53C2\u6570\u6821\u9A8C\u5931\u8D25",
+        hint: "\u5DE5\u5177\u6240\u9700\u53C2\u6570\u7F3A\u5931\u6216\u683C\u5F0F\u9519\u8BEF\u3002\u8BF7\u68C0\u67E5\u53C2\u6570\u7C7B\u578B\u548C\u5FC5\u586B\u5B57\u6BB5\uFF0C\u4F7F\u7528 search_tools \u67E5\u770B\u5DE5\u5177\u53C2\u6570\u8981\u6C42",
+        tools: ["search_tools", "list_tools_by_category"]
+      },
+      [ERROR_CODES.HANDLER_NOT_FOUND]: {
+        message: "\u5DE5\u5177\u672A\u627E\u5230",
+        hint: "\u5DE5\u5177\u540D\u79F0\u4E0D\u5B58\u5728\u3002\u4F7F\u7528 search_tools \u641C\u7D22\u53EF\u7528\u5DE5\u5177\uFF0C\u6216 list_tools_by_category \u6D4F\u89C8\u5168\u90E8\u5206\u7C7B",
+        tools: ["search_tools", "list_tools_by_category"]
+      },
+      [ERROR_CODES.OPERATION_FAILED]: {
+        message: "\u64CD\u4F5C\u6267\u884C\u5931\u8D25",
+        hint: "\u5DE5\u5177\u6267\u884C\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF\u3002\u53EF\u91CD\u8BD5\u64CD\u4F5C\uFF0C\u6216\u68C0\u67E5\u65E5\u5FD7\u83B7\u53D6\u8BE6\u7EC6\u4FE1\u606F",
+        tools: ["get_system_status", "get_cad_info"]
+      },
+      [ERROR_CODES.RATE_LIMITED]: {
+        message: "\u8C03\u7528\u9891\u7387\u8D85\u9650",
+        hint: "\u5DE5\u5177\u8C03\u7528\u8FC7\u4E8E\u9891\u7E41\u3002\u8BF7\u7B49\u5F85\u4E00\u6BB5\u65F6\u95F4\u540E\u518D\u8BD5",
+        tools: []
+      },
+      [ERROR_CODES.SESSION_NOT_FOUND]: {
+        message: "\u4F1A\u8BDD\u672A\u627E\u5230",
+        hint: "\u6307\u5B9A ID \u7684\u4F1A\u8BDD\u4E0D\u5B58\u5728\u3002\u8BF7\u68C0\u67E5 sessionId \u53C2\u6570\u662F\u5426\u6B63\u786E",
+        tools: ["lisp_repl_list"]
+      },
       [ERROR_CODES.METHOD_NOT_FOUND]: {
         message: "\u65B9\u6CD5\u4E0D\u5B58\u5728",
         hint: "\u5DE5\u5177\u540D\u79F0\u8F93\u5165\u9519\u8BEF\u3002\u4F7F\u7528 search_tools \u641C\u7D22\u53EF\u7528\u5DE5\u5177\uFF0C\u6216 list_tools_by_category \u6D4F\u89C8\u5168\u90E8\u5206\u7C7B",
@@ -1784,8 +1889,8 @@ __export(renderer_exports, {
   renderPrompt: () => renderPrompt,
   renderTemplate: () => renderTemplate
 });
-function resolvePath(obj, path20) {
-  const parts = path20.split(/[.\[\]]/g).filter(Boolean);
+function resolvePath(obj, path21) {
+  const parts = path21.split(/[.\[\]]/g).filter(Boolean);
   let val = obj;
   for (const p of parts) {
     if (val == null) return void 0;
@@ -1795,8 +1900,8 @@ function resolvePath(obj, path20) {
 }
 function renderTemplate(template, args) {
   return template.replace(PARAM_RE, (match, rawExpr, expr) => {
-    const path20 = rawExpr || expr;
-    const val = resolvePath(args, path20);
+    const path21 = rawExpr || expr;
+    const val = resolvePath(args, path21);
     if (val == null) return "";
     const strVal = String(val);
     if (rawExpr) return strVal;
@@ -2228,8 +2333,8 @@ var init_sse_session = __esm({
       sendMessage(data) {
         return this.sendEvent(SSE_EVENTS.MESSAGE, data);
       }
-      sendEndpoint(path20) {
-        return this.sendEvent(SSE_EVENTS.ENDPOINT, path20);
+      sendEndpoint(path21) {
+        return this.sendEvent(SSE_EVENTS.ENDPOINT, path21);
       }
       sendError(code, message, id = null) {
         return this.sendEvent(SSE_EVENTS.ERROR, { code, message }, id);
@@ -2951,7 +3056,8 @@ var init_info_tools = __esm({
         }
       },
       { name: "search_tools", description: "\u6309\u5173\u952E\u8BCD\u641C\u7D22\u53EF\u7528\u5DE5\u5177", inputSchema: { type: "object", properties: { query: { type: "string", description: "\u641C\u7D22\u5173\u952E\u8BCD(\u5339\u914D\u540D\u79F0\u548C\u63CF\u8FF0)" } }, required: ["query"] } },
-      { name: "list_tools_by_category", description: "\u6309\u5206\u7C7B\u5217\u51FA\u5DE5\u5177", inputSchema: { type: "object", properties: { category: { type: "string", description: "\u5206\u7C7B\u540D\u79F0(\u53EF\u9009,\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u7C7B)" } } } }
+      { name: "list_tools_by_category", description: "\u6309\u5206\u7C7B\u5217\u51FA\u5DE5\u5177", inputSchema: { type: "object", properties: { category: { type: "string", description: "\u5206\u7C7B\u540D\u79F0(\u53EF\u9009,\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u7C7B)" } } } },
+      { name: "get_tool_info", description: "\u83B7\u53D6\u5DE5\u5177\u7684\u8BE6\u7EC6\u4FE1\u606F\uFF08\u53C2\u6570\u3001\u5206\u7C7B\u3001\u53EA\u8BFB/\u7834\u574F\u6027\u6807\u8BB0\u7B49\uFF09", inputSchema: { type: "object", properties: { name: { type: "string", description: "\u5DE5\u5177\u540D\u79F0" } }, required: ["name"] } }
     ];
   }
 });
@@ -5492,12 +5598,12 @@ var init_pool_tools = __esm({
         inputSchema: {
           type: "object",
           properties: {
-            key: { type: "string", description: "\u5B9E\u4F8B\u6807\u8BC6\u952E\u540D\uFF08\u5982 autocad, zwcad, mycad\uFF09" },
+            key: { type: "string", description: "\u5B9E\u4F8B\u6807\u8BC6\u952E\u540D\uFF08\u5982 autocad, zwcad, mycad\uFF1B\u4E0D\u4F20\u65F6\u7531 pid \u81EA\u52A8\u6D3E\u751F\uFF09" },
             platform: { type: "string", description: "CAD \u5E73\u53F0: AutoCAD, ZWCAD, GStarCAD, BricsCAD\uFF08\u53EF\u9009\uFF0C\u81EA\u52A8\u68C0\u6D4B\uFF09" },
+            pid: { type: "number", description: "\u76EE\u6807\u8FDB\u7A0B PID\uFF08\u53EF\u9009\uFF0C\u901A\u8FC7 ROT \u67E5\u627E\u540E\u8FDE\u63A5\uFF0C\u53EF\u4E0E pid \u81EA\u52A8\u6D3E\u751F key\uFF09" },
             label: { type: "string", description: "\u5B9E\u4F8B\u663E\u793A\u6807\u7B7E\uFF08\u53EF\u9009\uFF09" },
             makeActive: { type: "boolean", description: "\u8FDE\u63A5\u540E\u8BBE\u4E3A\u6D3B\u52A8\u5B9E\u4F8B\uFF08\u9ED8\u8BA4 true\uFF09" }
-          },
-          required: ["key"]
+          }
         }
       },
       {
@@ -6374,7 +6480,149 @@ var init_lint_tools = __esm({
   }
 });
 
+// src/tools/debug-tools.js
+var tools41;
+var init_debug_tools = __esm({
+  "src/tools/debug-tools.js"() {
+    tools41 = [
+      {
+        name: "debug_start",
+        description: "\u542F\u52A8\u4EA4\u4E92\u5F0F\u8C03\u8BD5\u4F1A\u8BDD\u3002\u5C06\u4EE3\u7801\u6309\u5757\u62C6\u5206\u4E3A\u65AD\u70B9\u7EA7\u6267\u884C\uFF0C\u52A0\u8F7D\u8C03\u8BD5\u8F85\u52A9\u51FD\u6570\u5230 CAD\uFF0C\u8DF3\u8FC7\u975E\u65AD\u70B9\u524D\u7F6E\u5757",
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: { type: "string", description: "\u539F\u59CB AutoLISP \u4EE3\u7801" },
+            chunks: {
+              type: "array",
+              description: "\u7531\u6269\u5C55\u7AEF\u62C6\u5206\u597D\u7684\u4EE3\u7801\u5757\u5217\u8868",
+              items: {
+                type: "object",
+                properties: {
+                  id: { type: "integer", description: "\u5757\u5E8F\u53F7 (1-based)" },
+                  line: { type: "integer", description: "\u6E90\u6587\u4EF6\u884C\u53F7" },
+                  code: { type: "string", description: "\u5757\u7684 AutoLISP \u4EE3\u7801" },
+                  vars: { type: "array", items: { type: "string" }, description: "\u8BE5\u5757\u9700\u6355\u83B7\u7684\u53D8\u91CF\u540D" },
+                  isBreakpoint: { type: "boolean", description: "\u8BE5\u884C\u6709\u65AD\u70B9" },
+                  isDefunStart: { type: "boolean", description: "\u662F defun \u5B9A\u4E49\u5F00\u5934" }
+                },
+                required: ["id", "line", "code", "vars", "isBreakpoint"]
+              }
+            },
+            encoding: { type: "string", description: "\u7F16\u7801\uFF08\u9ED8\u8BA4 auto\uFF09" }
+          },
+          required: ["code", "chunks"]
+        }
+      },
+      {
+        name: "debug_step",
+        description: "\u6267\u884C\u4E00\u6B65\uFF08step\uFF09\u6216\u7EE7\u7EED\u5230\u4E0B\u4E00\u65AD\u70B9\uFF08continue\uFF09",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionId: { type: "string", description: "\u8C03\u8BD5\u4F1A\u8BDD ID" },
+            action: { type: "string", enum: ["step", "continue"], description: "step=\u6267\u884C\u4E00\u4E2A\u5757, continue=\u5230\u4E0B\u4E00\u65AD\u70B9/\u7ED3\u675F" }
+          },
+          required: ["sessionId", "action"]
+        }
+      },
+      {
+        name: "debug_evaluate",
+        description: "\u8C03\u8BD5\u6682\u505C\u65F6\u6C42\u503C AutoLISP \u8868\u8FBE\u5F0F",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionId: { type: "string", description: "\u8C03\u8BD5\u4F1A\u8BDD ID" },
+            expression: { type: "string", description: "\u4EFB\u610F AutoLISP \u8868\u8FBE\u5F0F" }
+          },
+          required: ["sessionId", "expression"]
+        }
+      },
+      {
+        name: "debug_get_state",
+        description: "\u67E5\u8BE2\u8C03\u8BD5\u4F1A\u8BDD\u5F53\u524D\u72B6\u6001",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionId: { type: "string", description: "\u8C03\u8BD5\u4F1A\u8BDD ID" }
+          },
+          required: ["sessionId"]
+        }
+      },
+      {
+        name: "debug_stop",
+        description: "\u505C\u6B62\u8C03\u8BD5\u4F1A\u8BDD\uFF0C\u6E05\u7406 CAD \u5168\u5C40\u53D8\u91CF\u548C\u8F85\u52A9\u51FD\u6570",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionId: { type: "string", description: "\u8C03\u8BD5\u4F1A\u8BDD ID" }
+          },
+          required: ["sessionId"]
+        }
+      }
+    ];
+  }
+});
+
+// src/tools/concurrent-tools.js
+var tools42;
+var init_concurrent_tools = __esm({
+  "src/tools/concurrent-tools.js"() {
+    tools42 = [
+      {
+        name: "batch_concurrent_tasks",
+        description: "\u5E76\u53D1\u6267\u884C\u591A\u5B9E\u4F8B\u5DE5\u5177 \u2014 \u5C06\u591A\u4E2A\u5DE5\u5177\u8C03\u7528\u540C\u65F6\u8DEF\u7531\u5230\u4E0D\u540C CAD \u5B9E\u4F8B\u5E76\u884C\u6267\u884C\u3002\u5185\u90E8\u4F7F\u7528 Promise.allSettled\uFF0C\u4E00\u4E2A\u5931\u8D25\u4E0D\u5F71\u54CD\u5176\u4ED6\u3002",
+        inputSchema: {
+          type: "object",
+          properties: {
+            tasks: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  tool: { type: "string", description: "\u5DE5\u5177\u540D\u79F0" },
+                  args: { type: "object", description: "\u5DE5\u5177\u53C2\u6570\uFF08\u4E0D\u542B instance\uFF09" },
+                  instance: { type: "string", description: "\u76EE\u6807\u5B9E\u4F8B key" }
+                },
+                required: ["tool", "instance"]
+              },
+              description: "\u8981\u5E76\u53D1\u6267\u884C\u7684\u4EFB\u52A1\u5217\u8868"
+            }
+          },
+          required: ["tasks"]
+        }
+      }
+    ];
+  }
+});
+
 // src/tools/index.js
+function getToolCategory(name) {
+  const n = name;
+  if (/^(draw_|create_3d_|create_box|create_cone|create_cylinder|create_sphere|create_torus|create_wedge|extrude_|revolve_|boolean_|slice_solid|thicken_|offset_surface|create_loft_|create_region)/.test(n)) return "\u7ED8\u56FE\u4E0E3D";
+  if (/^(move_|copy_|rotate_|scale_|mirror_|offset_|array_|batch_)/.test(n)) return "\u4FEE\u6539";
+  if (/^(trim_|extend_|fillet|chamfer|break_|join_|stretch)/.test(n)) return "\u7F16\u8F91";
+  if (/^(create_layer|delete_layer|set_layer|layer_)/.test(n)) return "\u56FE\u5C42";
+  if (/^(create_block|insert_block|explode_block|get_block|set_block|batch_get_block|batch_set_block)/.test(n)) return "\u5757";
+  if (/^(create_dim|list_dim|set_dim|create_hatch|set_hatch)/.test(n)) return "\u6807\u6CE8\u4E0E\u586B\u5145";
+  if (/^(create_ucs|set_ucs|delete_ucs|list_ucs|get_current_ucs|create_layout|delete_layout|rename_layout|set_layout|list_layouts|get_current_layout)/.test(n)) return "\u5750\u6807\u7CFB\u4E0E\u5E03\u5C40";
+  if (/^(create_viewport|set_viewport|lock_viewport|unlock_viewport|maximize_viewport)/.test(n)) return "\u89C6\u53E3";
+  if (/^find_/.test(n)) return "\u7A7A\u95F4\u67E5\u8BE2";
+  if (/^(select_|get_entity|set_entity|delete_entity|get_bounding_box)/.test(n)) return "\u9009\u62E9\u4E0E\u5C5E\u6027";
+  if (/^(open_dwg|save_dwg|export_|import_|close_dwg|publish_)/.test(n)) return "\u6587\u4EF6";
+  if (/^(plot_|save_pdf|batch_plot|publish_layouts)/.test(n)) return "\u6253\u5370";
+  if (/^(get_xdata|set_xdata|delete_xdata|list_xdata|copxy_xdata|search_by_xdata|export_xdata|import_xdata)/.test(n)) return "\u6269\u5C55\u6570\u636E";
+  if (/^(create_sheet|open_sheet|list_sheet|add_sheet|delete_sheet|publish_sheet|sheet_|reorder_sheet|create_subset|list_subset|set_sheet)/.test(n)) return "\u56FE\u7EB8\u96C6";
+  if (/^(attach_|detach_|reload_|list_attached|get_pdf|create_dgn|create_dwf|import_dxf|import_dgn|export_dgn|create_hyper|remove_hyper|xref|bind_xref|clip_xref|path_xref)/.test(n)) return "\u53C2\u7167\u4E0E\u5E95\u56FE";
+  if (/^(create_text|create_mleader|create_linetype|list_text|list_linetype|list_mleader|load_linetype|create_dimension_style|set_dimstyle|list_dimension_styles|set_mleader_style)/.test(n)) return "\u6837\u5F0F";
+  if (/^(purge_|drawing_audit|drawing_recover|overkill)/.test(n)) return "\u6E05\u7406";
+  if (/^(find_text|replace_text|set_text_|justify_|convert_text|explode_text)/.test(n)) return "\u6587\u5B57";
+  if (/^(eval_lisp|connect_cad|get_cad|get_platform|get_system|at_command|new_document|bring_to_front|install_atlisp|init_atlisp|get_system_status)/.test(n)) return "\u7CFB\u7EDF";
+  if (/^(list_packages|search_packages|install_package|get_function_usage|list_symbols|import_funlib)/.test(n)) return "\u5305\u4E0E\u51FD\u6570";
+  if (/^(watch_|lisp_repl|webhook_|sandbox_|audit_|cad_pool_|external_|list_data|export_to|import_external)/.test(n)) return "\u9AD8\u7EA7";
+  if (/^(list_prompts|get_prompt|search_tools|list_tools_by_category|get_tool_info)/.test(n)) return "\u5143\u5DE5\u5177";
+  if (/^(agent_)/.test(n)) return "Agent\u4E0A\u4E0B\u6587";
+  return "\u5176\u4ED6";
+}
 function addAnnotations(tool) {
   const isDeprecated = DEPRECATED_TOOLS.has(tool.name);
   const isPoolTool = tool.name.startsWith("cad_pool_") || tool.name === "session_pin_instance" || tool.name === "session_unpin_instance";
@@ -6394,11 +6642,12 @@ function addAnnotations(tool) {
       destructiveHint: tool.name.startsWith("delete_") || tool.name.startsWith("purge_") || tool.name.startsWith("boolean_") || EXTRA_DESTRUCTIVE.has(tool.name),
       idempotentHint: READ_ONLY_TOOLS.has(tool.name) || IDEMPOTENT_WRITE_TOOLS.has(tool.name),
       openWorldHint: OPEN_WORLD_TOOLS.has(tool.name),
+      category: getToolCategory(tool.name),
       ...isDeprecated ? { deprecatedReason: "This tool has been superseded. Check documentation for alternatives." } : {}
     }
   };
 }
-var READ_ONLY_TOOLS, DEPRECATED_TOOLS, EXTRA_DESTRUCTIVE, IDEMPOTENT_WRITE_TOOLS, OPEN_WORLD_TOOLS, tools41, toolsByName;
+var READ_ONLY_TOOLS, DEPRECATED_TOOLS, EXTRA_DESTRUCTIVE, IDEMPOTENT_WRITE_TOOLS, OPEN_WORLD_TOOLS, tools43, toolsByName;
 var init_tools = __esm({
   "src/tools/index.js"() {
     init_cad_tools();
@@ -6441,6 +6690,8 @@ var init_tools = __esm({
     init_context_tools();
     init_batch_transaction_tools();
     init_lint_tools();
+    init_debug_tools();
+    init_concurrent_tools();
     READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
       "get_cad_info",
       "get_platform_info",
@@ -6523,7 +6774,8 @@ var init_tools = __esm({
       "analyze_lisp_code",
       "format_lisp_code",
       "list_lint_rules",
-      "lint_project"
+      "lint_project",
+      "debug_get_state"
     ]);
     DEPRECATED_TOOLS = /* @__PURE__ */ new Set([]);
     EXTRA_DESTRUCTIVE = /* @__PURE__ */ new Set([
@@ -6579,7 +6831,7 @@ var init_tools = __esm({
       "import_page_setup",
       "load_linetype"
     ]);
-    tools41 = [
+    tools43 = [
       ...tools,
       ...tools2,
       ...tools3,
@@ -6619,9 +6871,11 @@ var init_tools = __esm({
       ...tools38,
       ...tools39,
       ...tools37,
-      ...tools40
+      ...tools40,
+      ...tools41,
+      ...tools42
     ].map(addAnnotations);
-    toolsByName = new Map(tools41.map((t) => [t.name, t]));
+    toolsByName = new Map(tools43.map((t) => [t.name, t]));
   }
 });
 
@@ -6674,7 +6928,7 @@ function parseLispList(str) {
   });
 }
 function createMcpServer(handlers = {}) {
-  const { tools: tools42 = [], handleToolCall: handleToolCall2 = () => ({ content: [] }) } = handlers;
+  const { tools: tools44 = [], handleToolCall: handleToolCall2 = () => ({ content: [] }) } = handlers;
   const server = new Server(
     { name: SERVER_NAME, version: SERVER_VERSION },
     {
@@ -6697,8 +6951,8 @@ function createMcpServer(handlers = {}) {
     const params = request.params || {};
     const cursor = decodeCursor(params.cursor);
     const PAGE_SIZE = 100;
-    const page = tools42.slice(cursor, cursor + PAGE_SIZE);
-    const nextCursor = cursor + PAGE_SIZE < tools42.length ? encodeCursor(cursor + PAGE_SIZE) : void 0;
+    const page = tools44.slice(cursor, cursor + PAGE_SIZE);
+    const nextCursor = cursor + PAGE_SIZE < tools44.length ? encodeCursor(cursor + PAGE_SIZE) : void 0;
     return { tools: page, nextCursor };
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -7047,11 +7301,11 @@ function createMcpServer(handlers = {}) {
         if (p.toLowerCase().startsWith(prefix)) values.push(p);
       }
     } else if (ref?.type === "tool") {
-      for (const t of tools42) {
+      for (const t of tools44) {
         if (t.name.toLowerCase().startsWith(prefix)) values.push(t.name);
       }
     } else if (ref?.type === "ref/parameter") {
-      const toolDef = tools42.find((t) => t.name === ref.name);
+      const toolDef = tools44.find((t) => t.name === ref.name);
       if (toolDef?.inputSchema?.properties) {
         const paramName = argument.name;
         const paramDef = toolDef.inputSchema.properties[paramName];
@@ -8565,82 +8819,435 @@ var init_constraint_handlers = __esm({
   }
 });
 
-// src/handlers/dim-hatch-handlers.js
-var dim_hatch_handlers_exports = {};
-__export(dim_hatch_handlers_exports, {
-  batchSetLayer: () => batchSetLayer,
-  createDimension: () => createDimension,
-  createHatch: () => createHatch,
-  createNamedView: () => createNamedView,
-  exportDwf: () => exportDwf,
-  exportDxf: () => exportDxf,
-  getBlockAttributes: () => getBlockAttributes,
-  getDimensionValue: () => getDimensionValue,
-  listNamedViews: () => listNamedViews,
-  restoreNamedView: () => restoreNamedView,
-  setBlockAttribute: () => setBlockAttribute,
-  setHatchProperties: () => setHatchProperties,
-  zoomToExtents: () => zoomToExtents,
-  zoomToWindow: () => zoomToWindow
-});
-function toSafePoint(pt) {
-  const parts = (Array.isArray(pt) ? pt : String(pt).split(/[,\s]+/)).map(Number);
-  return parts.filter((n) => !isNaN(n)).join(" ");
-}
-async function createDimension(type, points, style = {}) {
+// src/debug-engine.js
+import { randomUUID as randomUUID4 } from "crypto";
+async function ensureCad() {
   if (!cad.connected) {
+    log("Debug engine: CAD not connected, attempting auto-connect...");
     await cad.connect();
   }
-  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
-  let dimCode = "";
-  const validTypes = ["ALIGNED", "LINEAR", "ORDINATE", "RADIAL", "DIAMETER", "ANGULAR"];
-  const dimType = (type || "ALIGNED").toUpperCase();
-  if (!validTypes.includes(dimType)) {
-    return { content: [{ type: "text", text: `\u4E0D\u652F\u6301\u7684\u6807\u6CE8\u7C7B\u578B: ${type}` }], isError: true };
+  if (!cad.connected) {
+    throw new Error("CAD \u672A\u8FDE\u63A5");
   }
-  const defPt = toSafePoint(points.defPt || "0,0");
-  const pt1 = toSafePoint(points.pt1 || points.pt || "0,0");
-  const pt2 = toSafePoint(points.pt2 || "100,0");
-  const leaderLen = parseFloat(style.leaderLength) || 10;
-  switch (dimType) {
-    case "ALIGNED":
-      dimCode = `(command "._DIMALIGNED" (list ${pt1}) (list ${pt2}) (list ${defPt}))`;
-      break;
-    case "LINEAR":
-      dimCode = `(command "._DIMLINEAR" (list ${pt1}) (list ${pt2}) (list ${defPt}))`;
-      break;
-    case "ORDINATE":
-      dimCode = `(command "._DIMORDINATE" (list ${pt1}) (list ${defPt}))`;
-      break;
-    case "RADIAL":
-      dimCode = `(command "._DIMRADIUS" (list ${defPt}) "${leaderLen}")`;
-      break;
-    case "DIAMETER":
-      dimCode = `(command "._DIMDIAMETER" (list ${defPt}) "${leaderLen}")`;
-      break;
-    case "ANGULAR":
-      dimCode = `(command "._DIMANGULAR" (list ${pt1}) (list ${pt2}) (list ${defPt}))`;
-      break;
+}
+async function createSession(code, chunks, encoding) {
+  if (sessions.size >= MAX_SESSIONS2) {
+    let oldest = null;
+    for (const [id, s] of sessions) {
+      if (!oldest || s.createdAt < oldest.createdAt) oldest = { id, s };
+    }
+    if (oldest) {
+      sessions.delete(oldest.id);
+      log(`Debug session ${oldest.id} evicted (max sessions)`);
+    }
+  }
+  if (!chunks || chunks.length === 0) {
+    throw new Error("Chunks array is empty");
+  }
+  if (chunks.length > MAX_CHUNKS) {
+    throw new Error(`Too many chunks: ${chunks.length} (max ${MAX_CHUNKS})`);
+  }
+  for (const chunk of chunks) {
+    if (typeof chunk.id !== "number" || typeof chunk.code !== "string") {
+      throw new Error("Each chunk must have id (number) and code (string)");
+    }
   }
+  const sessionId = randomUUID4();
+  const session = new DebugSession(sessionId, code, chunks, encoding);
+  sessions.set(sessionId, session);
+  return sessionId;
+}
+function getSession(id) {
+  return sessions.get(id) || null;
+}
+async function closeSession(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session) return false;
   try {
-    await cad.sendCommand(dimCode + "\n");
-    return { content: [{ type: "text", text: `\u5DF2\u521B\u5EFA ${dimType} \u6807\u6CE8` }] };
+    if (cad.connected) {
+      await cad.sendCommand(CLEANUP_CODE + "\n");
+    }
   } catch (e) {
-    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
+    log(`Debug cleanup warning: ${e.message}`);
   }
+  sessions.delete(sessionId);
+  return true;
 }
-async function getDimensionValue(handle) {
-  if (!cad.connected) {
-    await cad.connect();
+async function loadHelpers(session) {
+  await ensureCad();
+  try {
+    await cad.sendCommand(HELPER_DEFUNS + "\n");
+  } catch (e) {
+    throw new Error(`Failed to load debug helpers: ${e.message}`);
   }
-  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
-  const code = `(progn
-        (vl-load-com)
-        (if (setq ent (handent "${escapeLispString(handle)}"))
-            (progn
-                (setq ed (entget ent) typ (cdr (assoc 0 ed)))
-                (if (wcmatch typ "DIMENSION")
-                    (list
+}
+async function fastForward(session) {
+  await ensureCad();
+  session.state = "running";
+  while (session.currentIndex < session.totalChunks) {
+    const chunk = session.chunks[session.currentIndex];
+    if (chunk.isBreakpoint) break;
+    try {
+      await cad.sendCommandWithResult(chunk.code, session.encoding);
+    } catch (e) {
+      session.state = "error";
+      session.error = `Fast-forward error at chunk ${chunk.id}: ${e.message}`;
+      throw new Error(session.error);
+    }
+    session.currentIndex++;
+  }
+  if (session.currentIndex >= session.totalChunks) {
+    session.state = "done";
+    return {
+      done: true,
+      finalResult: session.finalResult
+    };
+  }
+  session.state = "paused";
+  return {
+    done: false,
+    pausedAt: {
+      id: session.chunks[session.currentIndex].id,
+      line: session.chunks[session.currentIndex].line
+    }
+  };
+}
+async function executeStep(session) {
+  await ensureCad();
+  if (session.state !== "paused" && session.state !== "ready") {
+    throw new Error(`Invalid state: ${session.state} (expected paused or ready)`);
+  }
+  if (session.currentIndex >= session.totalChunks) {
+    session.state = "done";
+    return { done: true, finalResult: session.finalResult };
+  }
+  const chunk = session.chunks[session.currentIndex];
+  const vars = chunk.vars || [];
+  session.state = "running";
+  let rawResult;
+  try {
+    const varCapture = vars.length > 0 ? `(mapcar (function (lambda (v) (list (vl-prin1-to-string v) (if (boundp v) (vl-prin1-to-string (eval v)) nil)))) (list ${vars.map((v) => `'${v}`).join(" ")})` : "nil";
+    const lispCode = `(progn
+  (setq @::dbg/result (progn ${chunk.code}))
+  (list
+    (vl-prin1-to-string @::dbg/result)
+    ${varCapture}))`;
+    rawResult = await cad.sendCommandWithResult(lispCode, session.encoding);
+  } catch (e) {
+    session.state = "error";
+    session.error = `Step error at chunk ${chunk.id}: ${e.message}`;
+    throw new Error(session.error);
+  }
+  session.currentIndex++;
+  session.finalResult = rawResult;
+  let parsedResult = rawResult;
+  let variables = [];
+  try {
+    const parsed = parseLispRecursive(rawResult);
+    if (Array.isArray(parsed) && parsed.length >= 2) {
+      parsedResult = parsed[0] !== null ? String(parsed[0]) : "nil";
+      if (Array.isArray(parsed[1])) {
+        variables = parsed[1].map((item) => {
+          if (Array.isArray(item) && item.length >= 2) {
+            return { name: String(item[0] || ""), value: item[1] !== null ? String(item[1]) : "nil" };
+          }
+          return null;
+        }).filter(Boolean);
+      }
+    }
+  } catch {
+    parsedResult = rawResult || "nil";
+  }
+  const checkpoint = {
+    id: chunk.id,
+    line: chunk.line,
+    variables,
+    result: parsedResult
+  };
+  session.lastCheckpoint = checkpoint;
+  if (session.currentIndex >= session.totalChunks) {
+    session.state = "done";
+    return {
+      done: true,
+      checkpoint,
+      finalResult: parsedResult
+    };
+  }
+  session.state = "paused";
+  return { done: false, checkpoint };
+}
+async function continueExecution(session) {
+  await ensureCad();
+  if (session.state !== "paused" && session.state !== "ready") {
+    throw new Error(`Invalid state: ${session.state} (expected paused or ready)`);
+  }
+  while (session.currentIndex < session.totalChunks) {
+    const chunk = session.chunks[session.currentIndex];
+    if (chunk.isBreakpoint) {
+      return await executeStep(session);
+    }
+    try {
+      await cad.sendCommandWithResult(chunk.code, session.encoding);
+    } catch (e) {
+      session.state = "error";
+      session.error = `Continue error at chunk ${chunk.id}: ${e.message}`;
+      throw new Error(session.error);
+    }
+    session.currentIndex++;
+    session.finalResult = null;
+  }
+  session.state = "done";
+  return { done: true, finalResult: session.finalResult };
+}
+async function evaluateExpression(session, expression) {
+  await ensureCad();
+  if (session.state !== "paused") {
+    throw new Error(`Invalid state: ${session.state} (expected paused)`);
+  }
+  try {
+    const result = await cad.sendCommandWithResult(`(vl-prin1-to-string ${expression})`, session.encoding);
+    return { value: result || "nil" };
+  } catch (e) {
+    return { error: `CAD error: ${e.message}` };
+  }
+}
+var sessions, MAX_SESSIONS2, MAX_CHUNKS, HELPER_DEFUNS, CLEANUP_CODE, DebugSession;
+var init_debug_engine = __esm({
+  "src/debug-engine.js"() {
+    init_cad();
+    init_logger();
+    init_handler_utils();
+    sessions = /* @__PURE__ */ new Map();
+    MAX_SESSIONS2 = 10;
+    MAX_CHUNKS = 500;
+    HELPER_DEFUNS = `
+(defun @::dbg/exec-chunk (chunk-code var-names)
+  (setq @::dbg/result (eval (read chunk-code)))
+  (if var-names
+    (setq @::dbg/snapshot
+      (mapcar
+        (function (lambda (v)
+          (list (vl-prin1-to-string v)
+                (if (boundp v) (vl-prin1-to-string (eval v)) nil))))
+        var-names))
+    (setq @::dbg/snapshot nil))
+  (list @::dbg/result @::dbg/snapshot))
+`;
+    CLEANUP_CODE = `
+(if (not (vl-catch-all-error-p (vl-catch-all-apply (function (lambda ()
+  (mapcar (function (lambda (s) (set s nil)))
+    (quote (@::dbg/result @::dbg/snapshot @::dbg/state @::dbg/chunks @::dbg/idx @::dbg/encoding))))))))
+  (princ "ok"))
+`;
+    DebugSession = class {
+      constructor(sessionId, code, chunks, encoding) {
+        this.sessionId = sessionId;
+        this.code = code;
+        this.chunks = chunks;
+        this.totalChunks = chunks.length;
+        this.currentIndex = 0;
+        this.encoding = encoding || null;
+        this.state = "ready";
+        this.lastCheckpoint = null;
+        this.finalResult = null;
+        this.createdAt = Date.now();
+        this.error = null;
+      }
+    };
+  }
+});
+
+// src/handlers/debug-handlers.js
+var debug_handlers_exports = {};
+__export(debug_handlers_exports, {
+  debugEvaluate: () => debugEvaluate,
+  debugGetState: () => debugGetState,
+  debugStart: () => debugStart,
+  debugStep: () => debugStep,
+  debugStop: () => debugStop
+});
+async function debugGetState(args) {
+  try {
+    const { sessionId } = args || {};
+    if (!sessionId) return mcpError("Missing required argument: sessionId");
+    const session = getSession(sessionId);
+    if (!session) return mcpError(`Debug session not found: ${sessionId}`);
+    const checkpoint = session.lastCheckpoint;
+    return mcpSuccess(JSON.stringify({
+      state: session.state,
+      currentIndex: session.currentIndex,
+      totalChunks: session.totalChunks,
+      currentCheckpoint: checkpoint || void 0,
+      error: session.error
+    }));
+  } catch (e) {
+    return mcpError(e.message);
+  }
+}
+async function debugStop(args) {
+  try {
+    const { sessionId } = args || {};
+    if (!sessionId) return mcpError("Missing required argument: sessionId");
+    const session = getSession(sessionId);
+    if (!session) {
+      return mcpError(`Debug session not found: ${sessionId}`);
+    }
+    const ok = await closeSession(sessionId);
+    return mcpSuccess(JSON.stringify({ success: ok }));
+  } catch (e) {
+    return mcpError(e.message);
+  }
+}
+var debugStart, debugStep, debugEvaluate;
+var init_debug_handlers = __esm({
+  "src/handlers/debug-handlers.js"() {
+    init_handler_utils();
+    init_debug_engine();
+    debugStart = withCadConnection(async (args) => {
+      try {
+        const { code, chunks, encoding } = args || {};
+        if (!code) return mcpError("Missing required argument: code");
+        if (!chunks || !Array.isArray(chunks)) return mcpError("Missing required argument: chunks (must be an array)");
+        const sessionId = await createSession(code, chunks, encoding);
+        const session = getSession(sessionId);
+        if (!session) return mcpError("Failed to create debug session");
+        await loadHelpers(session);
+        const ffResult = await fastForward(session);
+        if (session.state === "error") {
+          await closeSession(sessionId);
+          return mcpError(session.error);
+        }
+        return mcpSuccess(JSON.stringify({
+          sessionId,
+          totalChunks: session.totalChunks,
+          ...ffResult
+        }));
+      } catch (e) {
+        return mcpError(e.message);
+      }
+    });
+    debugStep = withCadConnection(async (args) => {
+      try {
+        const { sessionId, action } = args || {};
+        if (!sessionId) return mcpError("Missing required argument: sessionId");
+        if (!action) return mcpError("Missing required argument: action");
+        const session = getSession(sessionId);
+        if (!session) return mcpError(`Debug session not found: ${sessionId}`);
+        if (session.state !== "paused" && session.state !== "ready") {
+          return mcpError(`Invalid state: ${session.state} (expected paused or ready)`);
+        }
+        let result;
+        if (action === "step") {
+          result = await executeStep(session);
+        } else if (action === "continue") {
+          result = await continueExecution(session);
+        } else {
+          return mcpError(`Invalid action: ${action} (expected step or continue)`);
+        }
+        if (session.state === "error") {
+          return mcpError(session.error);
+        }
+        return mcpSuccess(JSON.stringify(result));
+      } catch (e) {
+        return mcpError(e.message);
+      }
+    });
+    debugEvaluate = withCadConnection(async (args) => {
+      try {
+        const { sessionId, expression } = args || {};
+        if (!sessionId) return mcpError("Missing required argument: sessionId");
+        if (!expression) return mcpError("Missing required argument: expression");
+        const session = getSession(sessionId);
+        if (!session) return mcpError(`Debug session not found: ${sessionId}`);
+        if (session.state !== "paused") {
+          return mcpError(`Invalid state: ${session.state} (expected paused)`);
+        }
+        const result = await evaluateExpression(session, expression);
+        if (result.error) return mcpError(result.error);
+        return mcpSuccess(JSON.stringify({ value: result.value }));
+      } catch (e) {
+        return mcpError(e.message);
+      }
+    });
+  }
+});
+
+// src/handlers/dim-hatch-handlers.js
+var dim_hatch_handlers_exports = {};
+__export(dim_hatch_handlers_exports, {
+  batchSetLayer: () => batchSetLayer,
+  createDimension: () => createDimension,
+  createHatch: () => createHatch,
+  createNamedView: () => createNamedView,
+  exportDwf: () => exportDwf,
+  exportDxf: () => exportDxf,
+  getBlockAttributes: () => getBlockAttributes,
+  getDimensionValue: () => getDimensionValue,
+  listNamedViews: () => listNamedViews,
+  restoreNamedView: () => restoreNamedView,
+  setBlockAttribute: () => setBlockAttribute,
+  setHatchProperties: () => setHatchProperties,
+  zoomToExtents: () => zoomToExtents,
+  zoomToWindow: () => zoomToWindow
+});
+function toSafePoint(pt) {
+  const parts = (Array.isArray(pt) ? pt : String(pt).split(/[,\s]+/)).map(Number);
+  return parts.filter((n) => !isNaN(n)).join(" ");
+}
+async function createDimension(type, points, style = {}) {
+  if (!cad.connected) {
+    await cad.connect();
+  }
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  let dimCode = "";
+  const validTypes = ["ALIGNED", "LINEAR", "ORDINATE", "RADIAL", "DIAMETER", "ANGULAR"];
+  const dimType = (type || "ALIGNED").toUpperCase();
+  if (!validTypes.includes(dimType)) {
+    return { content: [{ type: "text", text: `\u4E0D\u652F\u6301\u7684\u6807\u6CE8\u7C7B\u578B: ${type}` }], isError: true };
+  }
+  const defPt = toSafePoint(points.defPt || "0,0");
+  const pt1 = toSafePoint(points.pt1 || points.pt || "0,0");
+  const pt2 = toSafePoint(points.pt2 || "100,0");
+  const leaderLen = parseFloat(style.leaderLength) || 10;
+  switch (dimType) {
+    case "ALIGNED":
+      dimCode = `(command "._DIMALIGNED" (list ${pt1}) (list ${pt2}) (list ${defPt}))`;
+      break;
+    case "LINEAR":
+      dimCode = `(command "._DIMLINEAR" (list ${pt1}) (list ${pt2}) (list ${defPt}))`;
+      break;
+    case "ORDINATE":
+      dimCode = `(command "._DIMORDINATE" (list ${pt1}) (list ${defPt}))`;
+      break;
+    case "RADIAL":
+      dimCode = `(command "._DIMRADIUS" (list ${defPt}) "${leaderLen}")`;
+      break;
+    case "DIAMETER":
+      dimCode = `(command "._DIMDIAMETER" (list ${defPt}) "${leaderLen}")`;
+      break;
+    case "ANGULAR":
+      dimCode = `(command "._DIMANGULAR" (list ${pt1}) (list ${pt2}) (list ${defPt}))`;
+      break;
+  }
+  try {
+    await cad.sendCommand(dimCode + "\n");
+    return { content: [{ type: "text", text: `\u5DF2\u521B\u5EFA ${dimType} \u6807\u6CE8` }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
+  }
+}
+async function getDimensionValue(handle) {
+  if (!cad.connected) {
+    await cad.connect();
+  }
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  const code = `(progn
+        (vl-load-com)
+        (if (setq ent (handent "${escapeLispString(handle)}"))
+            (progn
+                (setq ed (entget ent) typ (cdr (assoc 0 ed)))
+                (if (wcmatch typ "DIMENSION")
+                    (list
                         "type" typ
                         "handle" (cdr (assoc 5 ed))
                         "layer" (cdr (assoc 8 ed))
@@ -10231,6 +10838,87 @@ var init_lint_handlers = __esm({
   }
 });
 
+// src/handlers/meta-handlers.js
+var meta_handlers_exports = {};
+__export(meta_handlers_exports, {
+  get_prompt_handler: () => get_prompt_handler,
+  get_tool_info: () => get_tool_info,
+  list_prompts_handler: () => list_prompts_handler,
+  list_tools_by_category: () => list_tools_by_category,
+  search_tools: () => search_tools
+});
+async function search_tools(a) {
+  const q = (a.query || "").toLowerCase();
+  const results = tools43.filter((t) => t.name.toLowerCase().includes(q) || (t.description || "").toLowerCase().includes(q));
+  const text = results.length ? `\u627E\u5230 ${results.length} \u4E2A\u5DE5\u5177:
+${results.map((t) => `${t.name}: ${t.description}`).join("\n")}` : `\u672A\u627E\u5230\u5305\u542B "${a.query}" \u7684\u5DE5\u5177`;
+  return { content: [{ type: "text", text }] };
+}
+async function list_tools_by_category(a) {
+  const categories = {};
+  for (const t of tools43) {
+    const cat = t.annotations?.category || "\u5176\u4ED6";
+    if (!categories[cat]) categories[cat] = [];
+    categories[cat].push(t.name);
+  }
+  if (a.category) {
+    const names = categories[a.category];
+    return { content: [{ type: "text", text: names ? `${a.category} (${names.length}):
+${names.join("\n")}` : `\u672A\u627E\u5230\u5206\u7C7B: ${a.category}` }] };
+  }
+  const lines = [];
+  for (const [cat, names] of Object.entries(categories)) {
+    lines.push(`## ${cat} (${names.length})`);
+  }
+  lines.push(`
+\u5171 ${Object.keys(categories).length} \u4E2A\u5206\u7C7B`);
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function get_tool_info(a) {
+  if (!a.name) return { content: [{ type: "text", text: "\u9700\u8981 name \u53C2\u6570\uFF08\u5DE5\u5177\u540D\u79F0\uFF09" }], isError: true };
+  const tool = tools43.find((t) => t.name === a.name);
+  if (!tool) return { content: [{ type: "text", text: `\u672A\u627E\u5230\u5DE5\u5177: ${a.name}` }], isError: true };
+  const ann = tool.annotations || {};
+  const required = (tool.inputSchema?.required || []).join(", ") || "\u65E0";
+  const props = tool.inputSchema?.properties || {};
+  const params = Object.entries(props).map(([k, v]) => {
+    const req = required.includes(k) ? "\u5FC5\u586B" : "\u53EF\u9009";
+    const desc = v.description || "";
+    return `  ${k} (${req}): ${desc}`;
+  }).join("\n");
+  const lines = [
+    `## ${tool.name}`,
+    `\u63CF\u8FF0: ${tool.description || "\u65E0"}`,
+    `\u5206\u7C7B: ${ann.category || "\u5176\u4ED6"}`,
+    `\u53EA\u8BFB: ${ann.readOnlyHint ? "\u662F" : "\u5426"}`,
+    `\u7834\u574F\u6027: ${ann.destructiveHint ? "\u662F" : "\u5426"}`,
+    `\u5E42\u7B49: ${ann.idempotentHint ? "\u662F" : "\u5426"}`,
+    `\u5F00\u653E\u4E16\u754C: ${ann.openWorldHint ? "\u662F" : "\u5426"}`,
+    ``,
+    `\u53C2\u6570:`,
+    params || "  \u65E0\u53C2\u6570"
+  ];
+  if (ann.deprecatedReason) {
+    lines.push(`
+\u5DF2\u5F03\u7528: ${ann.deprecatedReason}`);
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function list_prompts_handler() {
+  const prompts = await listPrompts2();
+  return { content: [{ type: "text", text: JSON.stringify(prompts) }] };
+}
+async function get_prompt_handler(a) {
+  const prompt = await getPrompt2(a.name, a.args || {});
+  return { content: prompt.messages.map((m) => ({ type: "text", text: m.content.text || m.content })) };
+}
+var init_meta_handlers = __esm({
+  "src/handlers/meta-handlers.js"() {
+    init_tools();
+    init_prompt_handlers();
+  }
+});
+
 // src/handlers/package-handlers.js
 var package_handlers_exports = {};
 __export(package_handlers_exports, {
@@ -10240,7 +10928,7 @@ __export(package_handlers_exports, {
 });
 async function fetchPackages() {
   const now = Date.now();
-  if (cachedPackages && cachedAt2 && now - cachedAt2 < CACHE_TTL2) {
+  if (cachedPackages && cachedAt2 && now - cachedAt2 < CACHE_TTL) {
     return cachedPackages;
   }
   try {
@@ -10317,7 +11005,7 @@ async function installPackage(packageName) {
   }
   return { content: [{ type: "text", text: `\u5305 "${packageName}" \u5B89\u88C5\u547D\u4EE4\u5DF2\u53D1\u9001\uFF01` }] };
 }
-var PACKAGES_LIST_URL, cachedPackages, cachedAt2, CACHE_TTL2;
+var PACKAGES_LIST_URL, cachedPackages, cachedAt2, CACHE_TTL;
 var init_package_handlers = __esm({
   "src/handlers/package-handlers.js"() {
     init_logger();
@@ -10326,7 +11014,7 @@ var init_package_handlers = __esm({
     PACKAGES_LIST_URL = process.env.PACKAGES_LIST_URL || "http://s3.atlisp.cn/packages-list?fmt=json";
     cachedPackages = null;
     cachedAt2 = null;
-    CACHE_TTL2 = 10 * 60 * 1e3;
+    CACHE_TTL = 10 * 60 * 1e3;
   }
 });
 
@@ -12150,6 +12838,192 @@ var init_sheetset_handlers = __esm({
   }
 });
 
+// src/handlers/skill-handlers.js
+var skill_handlers_exports = {};
+__export(skill_handlers_exports, {
+  skill_install: () => skill_install,
+  skill_list_categories: () => skill_list_categories,
+  skill_list_installed: () => skill_list_installed,
+  skill_search: () => skill_search,
+  skill_uninstall: () => skill_uninstall
+});
+import fs8 from "fs";
+import path12 from "path";
+import os7 from "os";
+function readCache() {
+  try {
+    if (fs8.existsSync(CACHE_PATH)) return JSON.parse(fs8.readFileSync(CACHE_PATH, "utf-8"));
+  } catch {
+  }
+  return null;
+}
+function writeCache(data) {
+  try {
+    fs8.writeFileSync(CACHE_PATH, JSON.stringify(data, null, 2), "utf-8");
+  } catch {
+  }
+}
+async function fetchIndex() {
+  let index = readCache();
+  if (index && Date.now() - index.fetchedAt < 36e5) return index;
+  try {
+    const resp = await fetch(REGISTRY_URL, { headers: { "User-Agent": "atlisp-mcp" } });
+    if (resp.ok) {
+      index = await resp.json();
+      index.fetchedAt = Date.now();
+      writeCache(index);
+    }
+  } catch {
+  }
+  return index;
+}
+async function skill_search(a) {
+  const index = await fetchIndex();
+  if (!index?.skills) return { content: [{ type: "text", text: "\u65E0\u6CD5\u83B7\u53D6 skill \u6CE8\u518C\u8868\u7D22\u5F15" }], isError: true };
+  const q = (a.query || "").toLowerCase();
+  const results = index.skills.filter(
+    (s) => s.name.toLowerCase().includes(q) || (s.description || "").toLowerCase().includes(q) || (s.tags || []).some((t) => t.toLowerCase().includes(q))
+  );
+  if (!results.length) return { content: [{ type: "text", text: `\u672A\u627E\u5230\u5339\u914D "${a.query}" \u7684 skill` }] };
+  const lines = [`\u627E\u5230 ${results.length} \u4E2A skill:
+`];
+  for (const s of results) {
+    lines.push(`**${s.name}**`);
+    if (s.description) lines.push(`  \u63CF\u8FF0: ${s.description}`);
+    if (s.tags?.length) lines.push(`  \u6807\u7B7E: ${s.tags.join(", ")}`);
+    if (s.version) lines.push(`  \u7248\u672C: ${s.version}`);
+    lines.push("");
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function skill_install(a) {
+  if (!a.name) return { content: [{ type: "text", text: "\u9700\u8981 skill \u540D\u79F0" }], isError: true };
+  const index = await fetchIndex();
+  if (!index?.skills) return { content: [{ type: "text", text: "\u65E0\u6CD5\u83B7\u53D6 skill \u6CE8\u518C\u8868\u7D22\u5F15" }], isError: true };
+  const skill = index.skills.find((s) => s.name === a.name);
+  if (!skill) return { content: [{ type: "text", text: `\u672A\u627E\u5230 skill: ${a.name}` }], isError: true };
+  const downloadUrl = skill.download_url || skill.url;
+  if (!downloadUrl) return { content: [{ type: "text", text: `Skill "${a.name}" \u6CA1\u6709\u4E0B\u8F7D\u5730\u5740` }], isError: true };
+  let content;
+  try {
+    const resp = await fetch(downloadUrl, { headers: { "User-Agent": "atlisp-mcp" } });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    content = await resp.text();
+  } catch (e) {
+    return { content: [{ type: "text", text: `\u4E0B\u8F7D\u5931\u8D25: ${e.message}` }], isError: true };
+  }
+  try {
+    fs8.mkdirSync(SKILLS_DIR, { recursive: true });
+  } catch {
+  }
+  const safeName = a.name.replace(/[^a-zA-Z0-9\u4e00-\u9fff_-]/g, "-").substring(0, 40);
+  const skillFile = path12.join(SKILLS_DIR, `skill-${safeName}.md`);
+  if (fs8.existsSync(skillFile)) {
+    return { content: [{ type: "text", text: `Skill "${a.name}" \u5DF2\u5B89\u88C5 (${skillFile})` }], isError: true };
+  }
+  let finalContent = content;
+  if (!content.match(/^---\n/)) {
+    const tags = (skill.tags || []).join(", ");
+    finalContent = `---
+name: ${a.name}
+description: ${skill.description || ""}
+tags: ${tags}
+---
+
+${content}`;
+  }
+  fs8.writeFileSync(skillFile, finalContent, "utf-8");
+  return { content: [{ type: "text", text: `${skill.name} \u5B89\u88C5\u6210\u529F
+\u6587\u4EF6: ${skillFile}${skill.version ? `
+\u7248\u672C: ${skill.version}` : ""}` }] };
+}
+async function skill_list_installed() {
+  if (!fs8.existsSync(SKILLS_DIR)) return { content: [{ type: "text", text: "\u6682\u65E0\u5DF2\u5B89\u88C5\u7684 skill" }] };
+  const results = [];
+  try {
+    const entries = fs8.readdirSync(SKILLS_DIR, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const fullPath = path12.join(SKILLS_DIR, entry.name);
+        try {
+          const raw = fs8.readFileSync(fullPath, "utf-8");
+          const match = raw.match(/^---\n([\s\S]*?)\n---/);
+          if (match) {
+            const fm = {};
+            for (const line of match[1].split("\n")) {
+              const sep = line.indexOf(":");
+              if (sep > 0) fm[line.slice(0, sep).trim()] = line.slice(sep + 1).trim();
+            }
+            results.push({ name: fm.name || entry.name.replace(".md", ""), description: fm.description || "", tags: fm.tags || "" });
+          } else {
+            results.push({ name: entry.name.replace(".md", ""), description: "", tags: "" });
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  if (!results.length) return { content: [{ type: "text", text: "\u6682\u65E0\u5DF2\u5B89\u88C5\u7684 skill" }] };
+  const lines = [`\u5DF2\u5B89\u88C5 ${results.length} \u4E2A skill:
+`];
+  for (const s of results) {
+    lines.push(`**${s.name}**${s.description ? ` \u2014 ${s.description}` : ""}`);
+    if (s.tags) lines.push(`  \u6807\u7B7E: ${s.tags}`);
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function skill_uninstall(a) {
+  if (!a.name) return { content: [{ type: "text", text: "\u9700\u8981 skill \u540D\u79F0" }], isError: true };
+  if (!fs8.existsSync(SKILLS_DIR)) return { content: [{ type: "text", text: `\u672A\u5B89\u88C5 skill: ${a.name}` }], isError: true };
+  let found = null;
+  try {
+    const entries = fs8.readdirSync(SKILLS_DIR, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const fullPath = path12.join(SKILLS_DIR, entry.name);
+        try {
+          const raw = fs8.readFileSync(fullPath, "utf-8");
+          const match = raw.match(/^---\n([\s\S]*?)\n---/);
+          if (match) {
+            for (const line of match[1].split("\n")) {
+              if (line.startsWith("name:") && line.slice(5).trim() === a.name) {
+                found = fullPath;
+                break;
+              }
+            }
+          } else if (entry.name.replace(".md", "") === a.name) {
+            found = fullPath;
+          }
+        } catch {
+        }
+        if (found) break;
+      }
+    }
+  } catch {
+  }
+  if (!found) return { content: [{ type: "text", text: `\u672A\u5B89\u88C5 skill: ${a.name}` }], isError: true };
+  fs8.unlinkSync(found);
+  return { content: [{ type: "text", text: `${a.name} \u5DF2\u5378\u8F7D` }] };
+}
+async function skill_list_categories() {
+  const index = await fetchIndex();
+  if (!index?.skills) return { content: [{ type: "text", text: "\u65E0\u6CD5\u83B7\u53D6 skill \u6CE8\u518C\u8868\u7D22\u5F15" }], isError: true };
+  const cats = /* @__PURE__ */ new Set();
+  for (const s of index.skills) for (const t of s.tags || []) cats.add(t);
+  const sorted = Array.from(cats).sort();
+  return { content: [{ type: "text", text: sorted.length ? `\u6CE8\u518C\u8868\u5206\u7C7B (${sorted.length}):
+${sorted.join("\n")}` : "\u6682\u65E0\u5206\u7C7B" }] };
+}
+var SKILLS_DIR, REGISTRY_URL, CACHE_PATH;
+var init_skill_handlers = __esm({
+  "src/handlers/skill-handlers.js"() {
+    SKILLS_DIR = path12.join(os7.homedir(), ".atlisp", "skills");
+    REGISTRY_URL = process.env.SKILL_REGISTRY_URL || "https://raw.githubusercontent.com/atlisp/skill-registry/main/index.json";
+    CACHE_PATH = path12.join(os7.homedir(), ".atlisp", "skill-registry-cache.json");
+  }
+});
+
 // src/handlers/spatial-handlers.js
 var spatial_handlers_exports = {};
 __export(spatial_handlers_exports, {
@@ -13521,13 +14395,13 @@ function lispPoint(pt) {
 }
 async function attachXref(args) {
   try {
-    const path20 = esc3(args.path);
+    const path21 = esc3(args.path);
     const point = lispPoint(args.point);
     const scale = args.scale || 1;
     const rotation = args.rotation || 0;
     const overlay = args.overlay ? "_O" : "_A";
     const result = await cad.sendCommandWithResult(
-      `(command "_.XATTACH" "${path20}" "${overlay}" "${point}" "${scale}" "${rotation}") (princ)`
+      `(command "_.XATTACH" "${path21}" "${overlay}" "${point}" "${scale}" "${rotation}") (princ)`
     );
     return mcpSuccess(`\u5916\u90E8\u53C2\u7167\u5DF2\u9644\u7740: ${args.path}`);
   } catch (e) {
@@ -13845,6 +14719,7 @@ var init_ = __esm({
       "./handlers/block-handlers.js": () => Promise.resolve().then(() => (init_block_handlers(), block_handlers_exports)),
       "./handlers/cad-handlers.js": () => Promise.resolve().then(() => (init_cad_handlers(), cad_handlers_exports)),
       "./handlers/constraint-handlers.js": () => Promise.resolve().then(() => (init_constraint_handlers(), constraint_handlers_exports)),
+      "./handlers/debug-handlers.js": () => Promise.resolve().then(() => (init_debug_handlers(), debug_handlers_exports)),
       "./handlers/dim-hatch-handlers.js": () => Promise.resolve().then(() => (init_dim_hatch_handlers(), dim_hatch_handlers_exports)),
       "./handlers/draw-handlers.js": () => Promise.resolve().then(() => (init_draw_handlers(), draw_handlers_exports)),
       "./handlers/edit-handlers.js": () => Promise.resolve().then(() => (init_edit_handlers(), edit_handlers_exports)),
@@ -13854,6 +14729,7 @@ var init_ = __esm({
       "./handlers/function-handlers.js": () => Promise.resolve().then(() => (init_function_handlers(), function_handlers_exports)),
       "./handlers/layer-handlers.js": () => Promise.resolve().then(() => (init_layer_handlers(), layer_handlers_exports)),
       "./handlers/lint-handlers.js": () => Promise.resolve().then(() => (init_lint_handlers(), lint_handlers_exports)),
+      "./handlers/meta-handlers.js": () => Promise.resolve().then(() => (init_meta_handlers(), meta_handlers_exports)),
       "./handlers/package-handlers.js": () => Promise.resolve().then(() => (init_package_handlers(), package_handlers_exports)),
       "./handlers/parametric-handlers.js": () => Promise.resolve().then(() => (init_parametric_handlers(), parametric_handlers_exports)),
       "./handlers/pdf-annotation-handlers.js": () => Promise.resolve().then(() => (init_pdf_annotation_handlers(), pdf_annotation_handlers_exports)),
@@ -13862,6 +14738,7 @@ var init_ = __esm({
       "./handlers/query-print-handlers.js": () => Promise.resolve().then(() => (init_query_print_handlers(), query_print_handlers_exports)),
       "./handlers/resource-handlers.js": () => Promise.resolve().then(() => (init_resource_handlers(), resource_handlers_exports)),
       "./handlers/sheetset-handlers.js": () => Promise.resolve().then(() => (init_sheetset_handlers(), sheetset_handlers_exports)),
+      "./handlers/skill-handlers.js": () => Promise.resolve().then(() => (init_skill_handlers(), skill_handlers_exports)),
       "./handlers/spatial-handlers.js": () => Promise.resolve().then(() => (init_spatial_handlers(), spatial_handlers_exports)),
       "./handlers/style-handlers.js": () => Promise.resolve().then(() => (init_style_handlers(), style_handlers_exports)),
       "./handlers/text-handlers.js": () => Promise.resolve().then(() => (init_text_handlers(), text_handlers_exports)),
@@ -13874,8 +14751,8 @@ var init_ = __esm({
 });
 
 // src/handler-loader.js
-import fs8 from "fs";
-import path12 from "path";
+import fs9 from "fs";
+import path13 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function toolNameToFuncName(toolName) {
   if (FUNCTION_OVERRIDES[toolName]) return FUNCTION_OVERRIDES[toolName];
@@ -13925,10 +14802,10 @@ async function getHandlerModule(name) {
 async function initHandlerModules() {
   if (_handlerModulesInit) return;
   _handlerModulesInit = true;
-  const handlerDir = path12.join(__dirname5, "handlers");
+  const handlerDir = path13.join(__dirname5, "handlers");
   let names;
   try {
-    names = await fs8.promises.readdir(handlerDir);
+    names = await fs9.promises.readdir(handlerDir);
   } catch {
     log("Handler directory not found, using static manifest");
     return;
@@ -13939,6 +14816,7 @@ async function initHandlerModules() {
       handlerModules[name] = () => globImport_handlers_handlers_js(`./handlers/${name}-handlers.js`);
     }
   }
+  watchHandlers();
 }
 async function getHandler(toolName) {
   const resolved = await resolveHandler(toolName);
@@ -13947,12 +14825,40 @@ async function getHandler(toolName) {
   if (!mod || typeof mod[resolved.funcName] !== "function") return null;
   return mod[resolved.funcName];
 }
-var __dirname5, _handlerModulesInit, _handlerNameMapInit, handlerModules, moduleCache, resolvedCache, FUNCTION_OVERRIDES;
-var init_handler_loader = __esm({
+function watchHandlers() {
+  if (_watcherInitialized) return;
+  _watcherInitialized = true;
+  const handlerDir = path13.join(__dirname5, "handlers");
+  let debounceTimer = null;
+  try {
+    if (!fs9.existsSync(handlerDir)) return;
+    fs9.watch(handlerDir, (eventType, filename) => {
+      if (!filename || !filename.endsWith("-handlers.js")) return;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(async () => {
+        const name = filename.replace("-handlers.js", "");
+        moduleCache.delete(name);
+        resolvedCache.clear();
+        _handlerNameMapInit = false;
+        _handlerModulesInit = false;
+        try {
+          await initHandlerModules();
+          log(`Handler hot-reloaded: ${filename}`);
+        } catch (e) {
+          log(`Handler reload failed for ${filename}: ${e.message}`);
+        }
+      }, 300);
+    });
+  } catch (e) {
+    log(`Handler watch error: ${e.message}`);
+  }
+}
+var __dirname5, _handlerModulesInit, _handlerNameMapInit, handlerModules, moduleCache, resolvedCache, FUNCTION_OVERRIDES, _watcherInitialized;
+var init_handler_loader = __esm({
   "src/handler-loader.js"() {
     init_logger();
     init_();
-    __dirname5 = path12.dirname(fileURLToPath5(import.meta.url));
+    __dirname5 = path13.dirname(fileURLToPath5(import.meta.url));
     _handlerModulesInit = false;
     _handlerNameMapInit = false;
     handlerModules = {};
@@ -13964,16 +14870,18 @@ var init_handler_loader = __esm({
       get_dimension: "getDimensionValue",
       eval_lisp_with_result: "evalLisp"
     };
+    _watcherInitialized = false;
   }
 });
 
 // src/streaming.js
-async function streamEntitiesByType({ type = null, layer = null, chunk = STREAM_CHUNK_SIZE, offset = 0 }) {
-  const hasFilter = type || layer;
-  const filters = [];
-  if (type) filters.push(`(cons 0 "${type}")`);
-  if (layer) filters.push(`(cons 8 "${layer}")`);
-  const ssgetExpr = filters.length > 0 ? `(ssget "_X" (list ${filters.join(" ")}))` : `(ssget "_X")`;
+function escapeLispStr(str) {
+  if (typeof str !== "string") return "";
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+async function streamEntities({ filterExpr, extractFields, itemMapper, offset, limit, hasFilter, warnThreshold, overLimitMsg, resultProp }) {
+  const ssgetExpr = filterExpr ? `(ssget "_X" ${filterExpr})` : `(ssget "_X")`;
+  const extractCode = extractFields.length === 1 ? `(list ${extractFields.join(" ")})` : `(list ${extractFields.join(" ")})`;
   const lisp = `(progn
     (setq ss ${ssgetExpr})
     (setq total (if ss (sslength ss) 0))
@@ -13985,10 +14893,10 @@ async function streamEntitiesByType({ type = null, layer = null, chunk = STREAM_
           (setq result (list total))
           (setq i ${offset})
           (setq count 0)
-          (while (and (< i total) (< count ${chunk}))
+          (while (and (< i total) (< count ${limit}))
             (setq e (ssname ss i))
             (setq elist (entget e))
-            (setq result (cons (list (cdr (assoc 0 elist)) (cdr (assoc 5 elist)) (cdr (assoc 8 elist))) result))
+            (setq result (cons ${extractCode} result))
             (setq i (1+ i))
             (setq count (1+ count)))
           (reverse result)))))`;
@@ -14002,108 +14910,68 @@ async function streamEntitiesByType({ type = null, layer = null, chunk = STREAM_
         offset: 0,
         count: 0,
         hasMore: false,
-        entities: [],
-        error: `\u5B9E\u4F53\u6570\u91CF (${parsed[1]}) \u8D85\u8FC7\u6700\u5927\u9650\u5236 (${MAX_ENTITY_LIMIT})\uFF0C\u8BF7\u4F7F\u7528 type/layer \u8FC7\u6EE4`
+        [resultProp]: [],
+        error: `\u5B9E\u4F53\u6570\u91CF (${parsed[1]}) \u8D85\u8FC7\u6700\u5927\u9650\u5236 (${MAX_ENTITY_LIMIT})\uFF0C${overLimitMsg}`
       };
     }
-    const entities = parsed.slice(1);
-    const result = {
-      total,
-      offset,
-      count: entities.length,
-      hasMore: offset + entities.length < total,
-      entities
-    };
-    if (!hasFilter && total > UNFILTERED_WARN_THRESHOLD) {
-      result.warning = `\u672A\u63D0\u4F9B type/layer \u8FC7\u6EE4\uFF0C\u5168\u56FE\u626B\u63CF\u4E86 ${total} \u4E2A\u5B9E\u4F53\u3002\u5EFA\u8BAE\u6DFB\u52A0 type \u6216 layer \u53C2\u6570\u4EE5\u5927\u5E45\u63D0\u5347\u6027\u80FD\u548C\u964D\u4F4E\u5185\u5B58\u5360\u7528\u3002`;
+    const items = parsed.slice(1).map(itemMapper);
+    const result = { total, offset, count: items.length, hasMore: offset + items.length < total, [resultProp]: items };
+    if (!hasFilter && total > warnThreshold) {
+      result.warning = `\u672A\u63D0\u4F9B\u8FC7\u6EE4\u6761\u4EF6\uFF0C\u5168\u56FE\u626B\u63CF\u4E86 ${total} \u4E2A\u5B9E\u4F53\u3002\u5EFA\u8BAE\u6DFB\u52A0\u8FC7\u6EE4\u53C2\u6570\u4EE5\u63D0\u5347\u6027\u80FD\u3002`;
     }
     return result;
   } catch {
-    return { total: 0, offset: 0, count: 0, hasMore: false, entities: [] };
+    return { total: 0, offset: 0, count: 0, hasMore: false, [resultProp]: [] };
   }
 }
+async function streamEntitiesByType({ type = null, layer = null, chunk = STREAM_CHUNK_SIZE, offset = 0 }) {
+  const filters = [];
+  if (type) filters.push(`(cons 0 "${escapeLispStr(type)}")`);
+  if (layer) filters.push(`(cons 8 "${escapeLispStr(layer)}")`);
+  const filterExpr = filters.length > 0 ? `(list ${filters.join(" ")})` : null;
+  return streamEntities({
+    filterExpr,
+    extractFields: ["(list (cdr (assoc 0 elist)) (cdr (assoc 5 elist)) (cdr (assoc 8 elist)))"],
+    itemMapper: (item) => ({ type: item[0], handle: item[1], layer: item[2] }),
+    offset,
+    limit: chunk,
+    hasFilter: !!(type || layer),
+    warnThreshold: UNFILTERED_WARN_THRESHOLD,
+    overLimitMsg: "\u8BF7\u4F7F\u7528 type/layer \u8FC7\u6EE4",
+    resultProp: "entities"
+  });
+}
 async function streamTextContent({ layer = null, bbox = null, offset = 0, limit = 100 }) {
   const textFilters = [`(cons 0 "TEXT")`, `(cons 0 "MTEXT")`];
-  if (layer) textFilters.push(`(cons 8 "${layer}")`);
-  const lisp = `(progn
-    (setq ss (ssget "_X" (list '(-4 . "<OR") ${textFilters.join(" ")} '(-4 . "OR>"))))
-    (setq total (if ss (sslength ss) 0))
-    (if (> total ${MAX_ENTITY_LIMIT})
-      (list -1 total)
-      (if (>= ${offset} total)
-        (list total)
-        (progn
-          (setq result (list total))
-          (setq i ${offset})
-          (setq count 0)
-          (while (and (< i total) (< count ${limit}))
-            (setq e (ssname ss i))
-            (setq elist (entget e))
-            (setq txt (cdr (assoc 1 elist)))
-            (setq result (cons (list (cdr (assoc 5 elist)) txt (cdr (assoc 10 elist))) result))
-            (setq i (1+ i))
-            (setq count (1+ count)))
-          (reverse result)))))`;
-  const raw = await cad.sendCommandWithResult(lisp);
-  try {
-    const parsed = JSON.parse(raw);
-    const total = parsed[0] || 0;
-    if (total === -1) {
-      return {
-        total: parsed[1] || 0,
-        offset: 0,
-        count: 0,
-        hasMore: false,
-        texts: [],
-        error: `\u6587\u672C\u5B9E\u4F53\u6570\u91CF (${parsed[1]}) \u8D85\u8FC7\u6700\u5927\u9650\u5236 (${MAX_ENTITY_LIMIT})\uFF0C\u8BF7\u4F7F\u7528 layer \u8FC7\u6EE4`
-      };
-    }
-    const texts = parsed.slice(1).map((t) => ({ handle: t[0], text: t[1], point: t[2] }));
-    return { total, offset, count: texts.length, hasMore: offset + texts.length < total, texts };
-  } catch {
-    return { total: 0, offset: 0, count: 0, hasMore: false, texts: [] };
-  }
+  if (layer) textFilters.push(`(cons 8 "${escapeLispStr(layer)}")`);
+  const filterExpr = `(list '(-4 . "<OR") ${textFilters.join(" ")} '(-4 . "OR>"))`;
+  return streamEntities({
+    filterExpr,
+    extractFields: ["(list (cdr (assoc 5 elist)) (cdr (assoc 1 elist)) (cdr (assoc 10 elist)))"],
+    itemMapper: (item) => ({ handle: item[0], text: item[1], point: item[2] }),
+    offset,
+    limit,
+    hasFilter: !!layer,
+    warnThreshold: UNFILTERED_WARN_THRESHOLD,
+    overLimitMsg: "\u8BF7\u4F7F\u7528 layer \u8FC7\u6EE4",
+    resultProp: "texts"
+  });
 }
 async function streamBlockRefs({ blockName = null, offset = 0, limit = 100 }) {
   const filters = [`(cons 0 "INSERT")`];
-  if (blockName) filters.push(`(cons 2 "${blockName}")`);
-  const lisp = `(progn
-    (setq ss (ssget "_X" (list ${filters.join(" ")})))
-    (setq total (if ss (sslength ss) 0))
-    (if (> total ${MAX_ENTITY_LIMIT})
-      (list -1 total)
-      (if (>= ${offset} total)
-        (list total)
-        (progn
-          (setq result (list total))
-          (setq i ${offset})
-          (setq count 0)
-          (while (and (< i total) (< count ${limit}))
-            (setq e (ssname ss i))
-            (setq elist (entget e))
-            (setq result (cons (list (cdr (assoc 2 elist)) (cdr (assoc 5 elist)) (cdr (assoc 10 elist))) result))
-            (setq i (1+ i))
-            (setq count (1+ count)))
-          (reverse result)))))`;
-  const raw = await cad.sendCommandWithResult(lisp);
-  try {
-    const parsed = JSON.parse(raw);
-    const total = parsed[0] || 0;
-    if (total === -1) {
-      return {
-        total: parsed[1] || 0,
-        offset: 0,
-        count: 0,
-        hasMore: false,
-        refs: [],
-        error: `\u5757\u53C2\u7167\u6570\u91CF (${parsed[1]}) \u8D85\u8FC7\u6700\u5927\u9650\u5236 (${MAX_ENTITY_LIMIT})\uFF0C\u8BF7\u4F7F\u7528 blockName \u8FC7\u6EE4`
-      };
-    }
-    const refs = parsed.slice(1).map((r) => ({ blockName: r[0], handle: r[1], insertionPoint: r[2] }));
-    return { total, offset, count: refs.length, hasMore: offset + refs.length < total, refs };
-  } catch {
-    return { total: 0, offset: 0, count: 0, hasMore: false, refs: [] };
-  }
+  if (blockName) filters.push(`(cons 2 "${escapeLispStr(blockName)}")`);
+  const filterExpr = filters.length > 0 ? `(list ${filters.join(" ")})` : null;
+  return streamEntities({
+    filterExpr,
+    extractFields: ["(list (cdr (assoc 2 elist)) (cdr (assoc 5 elist)) (cdr (assoc 10 elist)))"],
+    itemMapper: (item) => ({ blockName: item[0], handle: item[1], insertionPoint: item[2] }),
+    offset,
+    limit,
+    hasFilter: !!blockName,
+    warnThreshold: UNFILTERED_WARN_THRESHOLD,
+    overLimitMsg: "\u8BF7\u4F7F\u7528 blockName \u8FC7\u6EE4",
+    resultProp: "refs"
+  });
 }
 var STREAM_CHUNK_SIZE, MAX_ENTITY_LIMIT, UNFILTERED_WARN_THRESHOLD;
 var init_streaming = __esm({
@@ -14115,6 +14983,74 @@ var init_streaming = __esm({
   }
 });
 
+// src/cad-rot-helper.js
+import edge from "edge-js";
+import path14 from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+function getRotHelper() {
+  if (_rotHelper) return _rotHelper;
+  const dllPath = path14.join(projectRoot, "dist", "cad-rothelper.dll");
+  try {
+    _rotHelper = edge.func({
+      assemblyFile: dllPath,
+      typeName: "CadRotHelper.RotEnumerator",
+      methodName: "EnumerateAll"
+    });
+    return _rotHelper;
+  } catch (e) {
+    error(`ROT \u5E2E\u52A9\u5668\u52A0\u8F7D\u5931\u8D25: ${e.message}`);
+    return null;
+  }
+}
+async function discoverCadInstances() {
+  const helper = getRotHelper();
+  if (!helper) {
+    log("ROT \u5E2E\u52A9\u5668\u4E0D\u53EF\u7528\uFF0C\u8DF3\u8FC7 CAD \u5B9E\u4F8B\u53D1\u73B0");
+    return [];
+  }
+  return new Promise((resolve) => {
+    helper(null, (err, result) => {
+      if (err) {
+        error(`ROT \u679A\u4E3E\u5931\u8D25: ${err.message}`);
+        resolve([]);
+        return;
+      }
+      if (!Array.isArray(result)) {
+        resolve([]);
+        return;
+      }
+      const seen = /* @__PURE__ */ new Set();
+      const instances = [];
+      for (const entry of result) {
+        if (!entry.appName) continue;
+        const pidKey = `${entry.appName}-${entry.pid}`;
+        if (seen.has(pidKey)) continue;
+        seen.add(pidKey);
+        const key = `${entry.appName.toLowerCase()}-${entry.pid}`;
+        instances.push({
+          key,
+          platform: entry.appName,
+          pid: entry.pid,
+          hwnd: entry.hwnd,
+          version: entry.version,
+          moniker: entry.name
+        });
+      }
+      log(`ROT \u53D1\u73B0: ${instances.length} \u4E2A CAD \u5B9E\u4F8B (${instances.map((i) => `${i.platform}#${i.pid}`).join(", ")})`);
+      resolve(instances);
+    });
+  });
+}
+var __filename, projectRoot, _rotHelper;
+var init_cad_rot_helper = __esm({
+  "src/cad-rot-helper.js"() {
+    init_logger();
+    __filename = fileURLToPath6(import.meta.url);
+    projectRoot = path14.dirname(path14.dirname(__filename));
+    _rotHelper = null;
+  }
+});
+
 // src/cad-pool.js
 var POOL_STRATEGIES, CadConnectionPool, pool;
 var init_cad_pool = __esm({
@@ -14122,6 +15058,8 @@ var init_cad_pool = __esm({
     init_cad();
     init_logger();
     init_config();
+    init_cad_rot_helper();
+    init_resource_cache();
     POOL_STRATEGIES = {
       ROUND_ROBIN: "round-robin",
       LEAST_BUSY: "least-busy",
@@ -14130,9 +15068,8 @@ var init_cad_pool = __esm({
     CadConnectionPool = class {
       _instances = /* @__PURE__ */ new Map();
       _maxPoolSize = 3;
-      _activeKey = "default";
+      _activeKey = null;
       _strategy = POOL_STRATEGIES.MANUAL;
-      _rrIndex = 0;
       _reconnectTimers = /* @__PURE__ */ new Map();
       _reconnectCounts = /* @__PURE__ */ new Map();
       _maxReconnectAttempts = 10;
@@ -14142,30 +15079,8 @@ var init_cad_pool = __esm({
         this._maxPoolSize = config_default.maxPoolSize || 3;
       }
       getConnection(key) {
-        this._ensureDefault();
         return this._instances.get(key)?.connection || null;
       }
-      /**
-       * Ensure the default entry exists. Created lazily to avoid
-       * calling getActiveConnection() at module import time (which
-       * breaks tests that mock cad.js).
-       */
-      _ensureDefault() {
-        if (!this._instances.has("default")) {
-          const defaultConn = getActiveConnection();
-          this._instances.set("default", {
-            key: "default",
-            connection: defaultConn,
-            platform: null,
-            version: null,
-            connected: false,
-            lastPing: Date.now(),
-            createdAt: Date.now(),
-            label: "\u9ED8\u8BA4 CAD",
-            autoReconnect: true
-          });
-        }
-      }
       /**
        * Connect to a CAD instance and add it to the pool.
        * @param {string} key - Instance identifier
@@ -14173,14 +15088,30 @@ var init_cad_pool = __esm({
        * @param {object} [options] - Additional options
        * @param {string} [options.label] - Human-readable label
        * @param {boolean} [options.autoReconnect=true] - Auto-reconnect on failure
+       * @param {number} [options.pid] - Target process PID (find via ROT)
        * @param {boolean} [options.makeActive=true] - Set as active after connecting
        */
       async connect(key = "default", platform = null, options = {}) {
-        this._ensureDefault();
-        const { label, autoReconnect = true, makeActive = true } = options || {};
+        const { label, autoReconnect = true, makeActive = true, pid } = options || {};
         if (this._instances.size >= this._maxPoolSize && !this._instances.has(key)) {
           throw new Error(`\u8FDE\u63A5\u6C60\u5DF2\u6EE1 (${this._maxPoolSize})\uFF0C\u65E0\u6CD5\u6DFB\u52A0\u65B0\u5B9E\u4F8B "${key}"`);
         }
+        if (pid != null) {
+          const instances = await discoverCadInstances();
+          const match = instances.find((i) => i.pid === pid);
+          if (!match) {
+            error(`\u8FDE\u63A5\u6C60: \u672A\u627E\u5230 PID ${pid} \u7684 CAD \u5B9E\u4F8B`);
+            return false;
+          }
+          platform = platform || match.platform;
+          if (key === "default" || key === pid.toString()) {
+            key = match.key;
+          }
+          if (match.moniker) {
+            if (!options) options = {};
+            options._moniker = match.moniker;
+          }
+        }
         let entry = this._instances.get(key);
         if (entry && entry.connected) {
           return true;
@@ -14202,7 +15133,9 @@ var init_cad_pool = __esm({
         }
         const conn = entry.connection;
         try {
-          const ok = await conn.connect(platform);
+          const moniker = options._moniker || entry.moniker;
+          const connectOpts = moniker ? { moniker, key } : {};
+          const ok = await conn.connect(platform, connectOpts);
           if (ok) {
             entry.connected = true;
             entry.platform = conn.getPlatform();
@@ -14226,17 +15159,6 @@ var init_cad_pool = __esm({
        * Disconnect and remove an instance from the pool.
        */
       async disconnect(key) {
-        this._ensureDefault();
-        if (key === "default") {
-          const entry2 = this._instances.get("default");
-          if (entry2) {
-            await entry2.connection.disconnect();
-            entry2.connected = false;
-            entry2.platform = null;
-            entry2.version = null;
-          }
-          return true;
-        }
         const entry = this._instances.get(key);
         if (!entry) return false;
         this._clearReconnectTimer(key);
@@ -14247,7 +15169,12 @@ var init_cad_pool = __esm({
         }
         this._instances.delete(key);
         if (this._activeKey === key) {
-          this.setActive("default");
+          const remaining = Array.from(this._instances.keys());
+          if (remaining.length > 0) {
+            this.setActive(remaining[0]);
+          } else {
+            this._activeKey = null;
+          }
         }
         log(`\u8FDE\u63A5\u6C60: \u5B9E\u4F8B "${key}" \u5DF2\u65AD\u5F00\u5E76\u79FB\u9664`);
         return true;
@@ -14256,7 +15183,6 @@ var init_cad_pool = __esm({
        * Set the active instance. All cad.* calls will be routed here.
        */
       setActive(key) {
-        this._ensureDefault();
         const entry = this._instances.get(key);
         if (!entry) {
           error(`\u8FDE\u63A5\u6C60: \u5B9E\u4F8B "${key}" \u4E0D\u5B58\u5728`);
@@ -14264,47 +15190,88 @@ var init_cad_pool = __esm({
         }
         this._activeKey = key;
         setActiveConnection(entry.connection);
+        setInstanceKey(key);
         cad.connected = entry.connected;
         log(`\u8FDE\u63A5\u6C60: \u5DF2\u5207\u6362\u5230\u5B9E\u4F8B "${key}"`);
+        if (this._onInstanceSwitch) {
+          try {
+            this._onInstanceSwitch(key, entry);
+          } catch (e) {
+            error(`\u5207\u6362\u56DE\u8C03\u7528\u9519\u8BEF: ${e.message}`);
+          }
+        }
         return true;
       }
+      /**
+       * Register a callback invoked after every instance switch.
+       * @param {function} fn - (key, entry) => void
+       */
+      onInstanceSwitch(fn) {
+        this._onInstanceSwitch = fn;
+      }
       /**
        * Discover and add all running CAD instances.
-       * Tries each platform to find running CAD processes.
+       * Uses ROT enumeration to find all instances (including multiple of the same platform).
+       * Falls back to GetActiveObject per platform when ROT is unavailable.
        */
       async discover() {
-        this._ensureDefault();
-        const platforms = ["AutoCAD", "ZWCAD", "GStarCAD", "BricsCAD"];
-        let foundCount = 0;
-        for (const platform of platforms) {
-          const key = platform.toLowerCase();
+        const resultEntries = [];
+        const rotInstances = await discoverCadInstances();
+        const rotHadResults = rotInstances.length > 0;
+        for (const inst of rotInstances) {
+          const key = inst.key;
           if (this._instances.has(key) && this._instances.get(key).connected) {
-            foundCount++;
+            resultEntries.push(this._instances.get(key));
             continue;
           }
-          try {
-            const tempConn = createCadConnection();
-            const ok = await tempConn.connect(platform);
-            if (ok) {
-              const label = `${platform} ${tempConn.getVersion() || ""}`.trim();
-              this._instances.set(key, {
-                key,
-                connection: tempConn,
-                platform: tempConn.getPlatform(),
-                version: tempConn.getVersion(),
-                connected: true,
-                lastPing: Date.now(),
-                createdAt: Date.now(),
-                label,
-                autoReconnect: true
-              });
-              foundCount++;
-              log(`\u8FDE\u63A5\u6C60: \u53D1\u73B0 ${label}`);
+          this._instances.set(key, {
+            key,
+            connection: null,
+            platform: inst.platform,
+            pid: inst.pid,
+            version: inst.version,
+            moniker: inst.moniker,
+            connected: false,
+            lastPing: Date.now(),
+            createdAt: Date.now(),
+            label: `${inst.platform} #${inst.pid} ${inst.version || ""}`.trim(),
+            autoReconnect: false
+          });
+          log(`\u8FDE\u63A5\u6C60: \u53D1\u73B0 ${inst.platform} \u5B9E\u4F8B PID=${inst.pid}`);
+          resultEntries.push(this._instances.get(key));
+        }
+        if (!rotHadResults) {
+          const connectWithTimeout = (conn, platform, ms = 4e3) => Promise.race([
+            conn.connect(platform),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), ms))
+          ]);
+          for (const platform of ["AutoCAD", "ZWCAD", "GStarCAD", "BricsCAD"]) {
+            const key = platform.toLowerCase();
+            if (this._instances.has(key) && this._instances.get(key).connected) continue;
+            try {
+              const tempConn = createCadConnection();
+              const ok = await connectWithTimeout(tempConn, platform);
+              if (ok) {
+                const label = `${platform} ${tempConn.getVersion() || ""}`.trim();
+                this._instances.set(key, {
+                  key,
+                  connection: tempConn,
+                  platform: tempConn.getPlatform(),
+                  version: tempConn.getVersion(),
+                  connected: true,
+                  lastPing: Date.now(),
+                  createdAt: Date.now(),
+                  label,
+                  autoReconnect: true
+                });
+                log(`\u8FDE\u63A5\u6C60: \u53D1\u73B0 ${label}`);
+                resultEntries.push(this._instances.get(key));
+              }
+            } catch (e) {
             }
-          } catch (e) {
           }
         }
-        return Array.from(this._instances.values()).map((e) => ({
+        return resultEntries.map((e) => ({
           key: e.key,
           connected: e.connected,
           platform: e.platform,
@@ -14317,7 +15284,6 @@ var init_cad_pool = __esm({
        * Health check for all instances.
        */
       async healthCheck() {
-        this._ensureDefault();
         const results = [];
         for (const [key, entry] of this._instances) {
           try {
@@ -14363,14 +15329,21 @@ var init_cad_pool = __esm({
        * Get the active instance.
        */
       getActive() {
-        this._ensureDefault();
         return this._instances.get(this._activeKey) || null;
       }
       /**
        * Get stats for all instances.
        */
       getStats() {
-        this._ensureDefault();
+        if (this._instances.size === 0) {
+          return {
+            total: 0,
+            maxPoolSize: this._maxPoolSize,
+            active: null,
+            strategy: this._strategy,
+            instances: []
+          };
+        }
         return {
           total: this._instances.size,
           maxPoolSize: this._maxPoolSize,
@@ -14382,7 +15355,7 @@ var init_cad_pool = __esm({
             platform: i.platform,
             version: i.version,
             label: i.label,
-            queueSize: i.connection._getQueueSize ? i.connection._getQueueSize() : 0,
+            queueSize: i.connection?._getQueueSize ? i.connection._getQueueSize() : 0,
             lastPingAgo: Date.now() - (i.lastPing || 0),
             uptime: i.connected ? Math.round((Date.now() - i.createdAt) / 1e3) : 0
           }))
@@ -14392,7 +15365,7 @@ var init_cad_pool = __esm({
        * List all instances.
        */
       listInstances() {
-        this._ensureDefault();
+        if (this._instances.size === 0) return [];
         return Array.from(this._instances.values()).map((i) => ({
           key: i.key,
           connected: i.connected,
@@ -14404,7 +15377,7 @@ var init_cad_pool = __esm({
         }));
       }
       /**
-       * Disconnect all instances.
+       * Disconnect all instances in parallel.
        */
       async disconnectAll() {
         this.stopHealthCheck();
@@ -14413,27 +15386,16 @@ var init_cad_pool = __esm({
         }
         this._reconnectTimers.clear();
         this._reconnectCounts.clear();
-        for (const [key, entry] of this._instances) {
+        const entries = Array.from(this._instances.entries());
+        this._instances.clear();
+        this._activeKey = null;
+        await Promise.allSettled(entries.map(async ([key, entry]) => {
           try {
             await entry.connection.disconnect();
           } catch (e) {
             error(`\u8FDE\u63A5\u6C60: \u65AD\u5F00 "${key}" \u51FA\u9519: ${e.message}`);
           }
-        }
-        this._instances.clear();
-        this._activeKey = "default";
-        const defaultConn = getActiveConnection();
-        this._instances.set("default", {
-          key: "default",
-          connection: defaultConn,
-          platform: null,
-          version: null,
-          connected: false,
-          lastPing: Date.now(),
-          createdAt: Date.now(),
-          label: "\u9ED8\u8BA4 CAD",
-          autoReconnect: true
-        });
+        }));
         log("\u8FDE\u63A5\u6C60: \u6240\u6709\u5B9E\u4F8B\u5DF2\u65AD\u5F00");
       }
       // --- Internal ---
@@ -14493,7 +15455,7 @@ var init_cad_pool = __esm({
 });
 
 // src/trigger-engine.js
-function escapeLispStr(v) {
+function escapeLispStr2(v) {
   if (typeof v !== "string") return v;
   return v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
@@ -14501,10 +15463,10 @@ function buildFilterExpr(filter) {
   if (!filter || typeof filter !== "object") return "nil";
   const parts = [];
   if (filter.type) {
-    parts.push(`(cons 0 "${escapeLispStr(filter.type)}")`);
+    parts.push(`(cons 0 "${escapeLispStr2(filter.type)}")`);
   }
   if (filter.layer) {
-    parts.push(`(cons 8 "${escapeLispStr(filter.layer)}")`);
+    parts.push(`(cons 8 "${escapeLispStr2(filter.layer)}")`);
   }
   if (parts.length === 0) return "nil";
   return `(list ${parts.join(" ")})`;
@@ -14553,7 +15515,7 @@ async function evaluateWatch(watch) {
         return { matched, data: { count } };
       }
       case "layer_exists": {
-        const lName = escapeLispStr(watch.layerName || "");
+        const lName = escapeLispStr2(watch.layerName || "");
         result = await cad.sendCommandWithResult(
           `(progn (if (tblsearch "LAYER" "${lName}") (list 1) (list 0)))`
         );
@@ -14561,7 +15523,7 @@ async function evaluateWatch(watch) {
         return { matched: exists, data: { exists, layerName: watch.layerName } };
       }
       case "doc_name": {
-        const pattern = escapeLispStr(watch.pattern || "*");
+        const pattern = escapeLispStr2(watch.pattern || "*");
         result = await cad.sendCommandWithResult(
           `(progn (setq _dn (getvar "dwgname")) (setq _dm (if (wcmatch _dn "${pattern}") 1 0)) (list _dm _dn))`
         );
@@ -14571,14 +15533,14 @@ async function evaluateWatch(watch) {
         return { matched, data: { matched: Boolean(matched), name } };
       }
       case "doc_path": {
-        const pattern = escapeLispStr(watch.pattern || "*");
+        const pattern = escapeLispStr2(watch.pattern || "*");
         result = await cad.sendCommandWithResult(
           `(progn (setq _dp (getvar "dwgprefix")) (setq _dm (if (wcmatch _dp "${pattern}") 1 0)) (list _dm _dp))`
         );
         const arr = parseLispList2(result) || [];
         const matched = Number(arr[0]) !== 0;
-        const path20 = String(arr[1] || "");
-        return { matched, data: { matched: Boolean(matched), path: path20 } };
+        const path21 = String(arr[1] || "");
+        return { matched, data: { matched: Boolean(matched), path: path21 } };
       }
       case "entity_selected": {
         result = await cad.sendCommandWithResult(
@@ -14748,53 +15710,6 @@ function stripStringsAndComments(code) {
   const withoutStrings = code.replace(/"([^"\\]*(?:\\.[^"\\]*)*)"/g, "");
   return withoutStrings.replace(/;.*$/gm, "");
 }
-var THREAT_BLOCK, THREAT_WARN, THREAT_ALLOW, CVT, SECURITY_RULES, _cachedLevel;
-var init_lisp_security = __esm({
-  "src/lisp-security.js"() {
-    init_logger();
-    init_config();
-    THREAT_BLOCK = "block";
-    THREAT_WARN = "warn";
-    THREAT_ALLOW = "allow";
-    CVT = {
-      strict: THREAT_BLOCK,
-      standard: THREAT_WARN,
-      relaxed: THREAT_ALLOW
-    };
-    SECURITY_RULES = [
-      { re: /\bstartapp\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 startapp \u51FD\u6570" },
-      { re: /\bvl-bt\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 vl-bt \u51FD\u6570" },
-      { re: /\bvlax-import-type-library\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u5BFC\u5165\u7C7B\u578B\u5E93" },
-      { re: /\bdos_command_string\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 dos_command_string" },
-      { re: /\beval\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 eval \u51FD\u6570" },
-      { re: /\bcommand\s*["\s]*[_(]?\s*["']?\.?\s*_?(?:shell|quit|exit|close|open|new|recover|audit|purge|wblock|export)/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528\u5371\u9669 CAD \u547D\u4EE4" },
-      { re: /\bload\s*[(\s"]/i, baseSeverity: THREAT_BLOCK, msg: "load \u51FD\u6570\u53EF\u80FD\u52A0\u8F7D\u5916\u90E8\u4EE3\u7801" },
-      { re: /\b(?:read-line|read-char|write-line|write-char)\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u6587\u4EF6 I/O \u64CD\u4F5C\u53EF\u80FD\u5F71\u54CD\u7CFB\u7EDF" },
-      { re: /\bvl-file-copy\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u6587\u4EF6\u590D\u5236" },
-      { re: /\bvl-file-delete\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u6587\u4EF6\u5220\u9664" },
-      { re: /\bvl-file-rename\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u6587\u4EF6\u91CD\u547D\u540D" },
-      { re: /\bvl-registry-write[\s\)]/i, baseSeverity: THREAT_BLOCK, msg: "vl-registry-write \u4F1A\u4FEE\u6539\u6CE8\u518C\u8868" },
-      { re: /\bvl-exit-with-value\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 vl-exit-with-value" },
-      { re: /\bvl-exit-with-error\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 vl-exit-with-error" },
-      { re: /\bvlax-add-cmd\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u6CE8\u518C\u65B0\u547D\u4EE4" },
-      { re: /\bvla-Delete\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u76F4\u63A5\u5220\u9664 vla \u5BF9\u8C61" },
-      { re: /\bvla-Save\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u76F4\u63A5\u4FDD\u5B58\u6587\u6863" },
-      { re: /\bdirectory\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 directory \u51FD\u6570" },
-      { re: /\bvla-deletefile\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u5220\u9664\u6587\u4EF6" },
-      { re: /\bvla-copyfile\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u590D\u5236\u6587\u4EF6" },
-      { re: /\bvla-movefile\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u79FB\u52A8\u6587\u4EF6" }
-    ];
-    _cachedLevel = null;
-    try {
-      onConfigChange(() => {
-        _cachedLevel = null;
-      });
-    } catch (_) {
-    }
-  }
-});
-
-// src/lisp-sandbox.js
 function getSessionAllowlist(sessionId) {
   if (!sessionAllowlist.has(sessionId)) {
     sessionAllowlist.set(sessionId, /* @__PURE__ */ new Set());
@@ -14838,66 +15753,103 @@ function validateLispCode(code, sessionId = null) {
     summary: blocked ? `\u5B89\u5168\u9650\u5236: ${results.filter((r) => r.blocked).map((r) => r.message).join("; ")}` : "\u901A\u8FC7"
   };
 }
-var RULES2, sessionAllowlist;
-var init_lisp_sandbox = __esm({
-  "src/lisp-sandbox.js"() {
+var THREAT_BLOCK, THREAT_WARN, THREAT_ALLOW, CVT, SECURITY_RULES, _cachedLevel, RULES2, sessionAllowlist;
+var init_lisp_security = __esm({
+  "src/lisp-security.js"() {
     init_logger();
     init_config();
-    init_lisp_security();
+    THREAT_BLOCK = "block";
+    THREAT_WARN = "warn";
+    THREAT_ALLOW = "allow";
+    CVT = {
+      strict: THREAT_BLOCK,
+      standard: THREAT_WARN,
+      relaxed: THREAT_ALLOW
+    };
+    SECURITY_RULES = [
+      { re: /\bstartapp\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 startapp \u51FD\u6570" },
+      { re: /\bvl-bt\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 vl-bt \u51FD\u6570" },
+      { re: /\bvlax-import-type-library\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u5BFC\u5165\u7C7B\u578B\u5E93" },
+      { re: /\bdos_command_string\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 dos_command_string" },
+      { re: /\beval\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 eval \u51FD\u6570" },
+      { re: /\bcommand\s*["\s]*[_(]?\s*["']?\.?\s*_?(?:shell|quit|exit|close|open|new|recover|audit|purge|wblock|export)/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528\u5371\u9669 CAD \u547D\u4EE4" },
+      { re: /\bload\s*[(\s"]/i, baseSeverity: THREAT_BLOCK, msg: "load \u51FD\u6570\u53EF\u80FD\u52A0\u8F7D\u5916\u90E8\u4EE3\u7801" },
+      { re: /\b(?:read-line|read-char|write-line|write-char)\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u6587\u4EF6 I/O \u64CD\u4F5C\u53EF\u80FD\u5F71\u54CD\u7CFB\u7EDF" },
+      { re: /\bvl-file-copy\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u6587\u4EF6\u590D\u5236" },
+      { re: /\bvl-file-delete\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u6587\u4EF6\u5220\u9664" },
+      { re: /\bvl-file-rename\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u6587\u4EF6\u91CD\u547D\u540D" },
+      { re: /\bvl-registry-write[\s\)]/i, baseSeverity: THREAT_BLOCK, msg: "vl-registry-write \u4F1A\u4FEE\u6539\u6CE8\u518C\u8868" },
+      { re: /\bvl-exit-with-value\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 vl-exit-with-value" },
+      { re: /\bvl-exit-with-error\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 vl-exit-with-error" },
+      { re: /\bvlax-add-cmd\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u6CE8\u518C\u65B0\u547D\u4EE4" },
+      { re: /\bvla-Delete\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u76F4\u63A5\u5220\u9664 vla \u5BF9\u8C61" },
+      { re: /\bvla-Save\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u76F4\u63A5\u4FDD\u5B58\u6587\u6863" },
+      { re: /\bdirectory\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u4F7F\u7528 directory \u51FD\u6570" },
+      { re: /\bvla-deletefile\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u5220\u9664\u6587\u4EF6" },
+      { re: /\bvla-copyfile\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u590D\u5236\u6587\u4EF6" },
+      { re: /\bvla-movefile\b/i, baseSeverity: THREAT_BLOCK, msg: "\u7981\u6B62\u79FB\u52A8\u6587\u4EF6" }
+    ];
+    _cachedLevel = null;
+    try {
+      onConfigChange(() => {
+        _cachedLevel = null;
+      });
+    } catch (_) {
+    }
     RULES2 = SECURITY_RULES;
     sessionAllowlist = /* @__PURE__ */ new Map();
   }
 });
 
 // src/repl-engine.js
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function ensureCleanup2() {
   if (cleanupTimer2) return;
   cleanupTimer2 = setInterval(() => {
     const now = Date.now();
-    for (const [id, session] of sessions) {
+    for (const [id, session] of sessions2) {
       if (now - session.createdAt > SESSION_TTL) {
-        sessions.delete(id);
+        sessions2.delete(id);
         log(`REPL session ${id} expired (TTL)`);
       }
     }
   }, CLEANUP_INTERVAL3);
   cleanupTimer2.unref();
 }
-function createSession() {
-  if (sessions.size >= MAX_SESSIONS2) {
+function createSession2() {
+  if (sessions2.size >= MAX_SESSIONS3) {
     let oldest = null;
-    for (const [id, s] of sessions) {
+    for (const [id, s] of sessions2) {
       if (!oldest || s.lastActivity < oldest.lastActivity) oldest = { id, s };
     }
     if (oldest) {
-      sessions.delete(oldest.id);
+      sessions2.delete(oldest.id);
       log(`REPL session ${oldest.id} evicted (max sessions reached)`);
     }
   }
   ensureCleanup2();
-  const sessionId = randomUUID4();
+  const sessionId = randomUUID5();
   const session = new ReplSession(sessionId);
-  sessions.set(sessionId, session);
+  sessions2.set(sessionId, session);
   return sessionId;
 }
 async function executeInSession(sessionId, code) {
-  let session = sessions.get(sessionId);
+  let session = sessions2.get(sessionId);
   if (!session) {
-    sessionId = createSession();
-    session = sessions.get(sessionId);
+    sessionId = createSession2();
+    session = sessions2.get(sessionId);
   }
   const result = await session.execute(code);
   return { sessionId, result, history: session.history };
 }
 function getHistory(sessionId) {
-  const session = sessions.get(sessionId);
+  const session = sessions2.get(sessionId);
   if (!session) return null;
   return session.history;
 }
-function listSessions() {
+function listSessions2() {
   const result = [];
-  for (const [id, session] of sessions) {
+  for (const [id, session] of sessions2) {
     result.push({
       sessionId: id,
       historyCount: session.history.length,
@@ -14907,20 +15859,20 @@ function listSessions() {
   }
   return result;
 }
-function closeSession(id) {
-  const session = sessions.get(id);
+function closeSession2(id) {
+  const session = sessions2.get(id);
   if (!session) return false;
-  sessions.delete(id);
+  sessions2.delete(id);
   return true;
 }
-var sessions, MAX_SESSIONS2, SESSION_TTL, CLEANUP_INTERVAL3, cleanupTimer2, SETQ_RE, ReplSession;
+var sessions2, MAX_SESSIONS3, SESSION_TTL, CLEANUP_INTERVAL3, cleanupTimer2, SETQ_RE, ReplSession;
 var init_repl_engine = __esm({
   "src/repl-engine.js"() {
     init_cad();
     init_logger();
     init_lint_analyzer();
-    sessions = /* @__PURE__ */ new Map();
-    MAX_SESSIONS2 = 50;
+    sessions2 = /* @__PURE__ */ new Map();
+    MAX_SESSIONS3 = 50;
     SESSION_TTL = 30 * 60 * 1e3;
     CLEANUP_INTERVAL3 = 5 * 60 * 1e3;
     cleanupTimer2 = null;
@@ -14964,13 +15916,13 @@ ${analysis.errors.map((e) => `  L${e.line}: [${e.rule}] ${e.message}`).join("\n"
 });
 
 // src/webhook-engine.js
-import fs9 from "fs";
-import path13 from "path";
-import os7 from "os";
+import fs10 from "fs";
+import path15 from "path";
+import os8 from "os";
 function loadWebhooks() {
   try {
-    if (fs9.existsSync(WEBHOOKS_FILE)) {
-      webhooks = JSON.parse(fs9.readFileSync(WEBHOOKS_FILE, "utf-8"));
+    if (fs10.existsSync(WEBHOOKS_FILE)) {
+      webhooks = JSON.parse(fs10.readFileSync(WEBHOOKS_FILE, "utf-8"));
     }
   } catch (e) {
     error(`Webhook load error: ${e.message}`);
@@ -14978,8 +15930,8 @@ function loadWebhooks() {
 }
 function saveWebhooks() {
   try {
-    ensureDir(path13.dirname(WEBHOOKS_FILE));
-    fs9.writeFileSync(WEBHOOKS_FILE, JSON.stringify(webhooks, null, 2), "utf-8");
+    ensureDir(path15.dirname(WEBHOOKS_FILE));
+    fs10.writeFileSync(WEBHOOKS_FILE, JSON.stringify(webhooks, null, 2), "utf-8");
   } catch (e) {
     error(`Webhook save error: ${e.message}`);
   }
@@ -15036,10 +15988,10 @@ function listWebhooks() {
 }
 function getWebhookLog(id) {
   const sanitized = String(id).replace(/[^a-zA-Z0-9_-]/g, "_");
-  const logPath = path13.join(os7.homedir(), ".atlisp", `webhook-${sanitized}.log`);
+  const logPath = path15.join(os8.homedir(), ".atlisp", `webhook-${sanitized}.log`);
   try {
-    if (!fs9.existsSync(logPath)) return [];
-    return fs9.readFileSync(logPath, "utf-8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+    if (!fs10.existsSync(logPath)) return [];
+    return fs10.readFileSync(logPath, "utf-8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
   } catch (e) {
     error(`Webhook log read error [${sanitized}]: ${e.message}`);
     return [];
@@ -15050,30 +16002,30 @@ var init_webhook_engine = __esm({
   "src/webhook-engine.js"() {
     init_logger();
     init_handler_utils();
-    WEBHOOKS_FILE = path13.join(os7.homedir(), ".atlisp", "webhooks.json");
+    WEBHOOKS_FILE = path15.join(os8.homedir(), ".atlisp", "webhooks.json");
     webhooks = [];
     loadWebhooks();
   }
 });
 
 // src/audit-log.js
-import fs10 from "fs";
-import path14 from "path";
-import os8 from "os";
+import fs11 from "fs";
+import path16 from "path";
+import os9 from "os";
 import zlib from "zlib";
 function rotateIfNeeded() {
   try {
-    if (fs10.existsSync(AUDIT_FILE) && fs10.statSync(AUDIT_FILE).size > MAX_LOG_SIZE2) {
+    if (fs11.existsSync(AUDIT_FILE) && fs11.statSync(AUDIT_FILE).size > MAX_LOG_SIZE2) {
       const rotated = AUDIT_FILE.replace(".log", `.${Date.now()}.log`);
-      fs10.renameSync(AUDIT_FILE, rotated);
+      fs11.renameSync(AUDIT_FILE, rotated);
       try {
-        const compressed = zlib.gzipSync(fs10.readFileSync(rotated));
-        fs10.writeFileSync(rotated + ".gz", compressed);
-        fs10.unlinkSync(rotated);
+        const compressed = zlib.gzipSync(fs11.readFileSync(rotated));
+        fs11.writeFileSync(rotated + ".gz", compressed);
+        fs11.unlinkSync(rotated);
       } catch (e) {
         error(`Audit log compression failed, keeping raw file: ${e.message}`);
         try {
-          fs10.unlinkSync(rotated + ".gz");
+          fs11.unlinkSync(rotated + ".gz");
         } catch {
         }
       }
@@ -15097,15 +16049,15 @@ function writeAuditEntry(entry) {
       user: entry.user || "",
       role: entry.role || ""
     }) + "\n";
-    fs10.appendFileSync(AUDIT_FILE, line, "utf-8");
+    fs11.appendFileSync(AUDIT_FILE, line, "utf-8");
   } catch (e) {
     error(`Audit log write error: ${e.message}`);
   }
 }
 function queryAuditLog(filters = {}) {
   try {
-    if (!fs10.existsSync(AUDIT_FILE)) return { total: 0, offset: 0, count: 0, entries: [] };
-    const content = fs10.readFileSync(AUDIT_FILE, "utf-8");
+    if (!fs11.existsSync(AUDIT_FILE)) return { total: 0, offset: 0, count: 0, entries: [] };
+    const content = fs11.readFileSync(AUDIT_FILE, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     let entries = lines.map((l) => {
       try {
@@ -15137,8 +16089,8 @@ function queryAuditLog(filters = {}) {
 }
 function getAuditStats() {
   try {
-    if (!fs10.existsSync(AUDIT_FILE)) return { totalEntries: 0, tools: {}, errors: 0 };
-    const content = fs10.readFileSync(AUDIT_FILE, "utf-8");
+    if (!fs11.existsSync(AUDIT_FILE)) return { totalEntries: 0, tools: {}, errors: 0 };
+    const content = fs11.readFileSync(AUDIT_FILE, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     const toolCounts = {};
     let errors = 0;
@@ -15154,7 +16106,7 @@ function getAuditStats() {
       totalEntries: lines.length,
       tools: toolCounts,
       errors,
-      fileSize: fs10.existsSync(AUDIT_FILE) ? fs10.statSync(AUDIT_FILE).size : 0,
+      fileSize: fs11.existsSync(AUDIT_FILE) ? fs11.statSync(AUDIT_FILE).size : 0,
       filePath: AUDIT_FILE
     };
   } catch (e) {
@@ -15166,8 +16118,8 @@ var init_audit_log = __esm({
   "src/audit-log.js"() {
     init_logger();
     init_handler_utils();
-    AUDIT_DIR = path14.join(os8.homedir(), "@lisp", "logs");
-    AUDIT_FILE = path14.join(AUDIT_DIR, "audit.log");
+    AUDIT_DIR = path16.join(os9.homedir(), "@lisp", "logs");
+    AUDIT_FILE = path16.join(AUDIT_DIR, "audit.log");
     MAX_LOG_SIZE2 = 10 * 1024 * 1024;
     MAX_LOG_AGE = 90 * 24 * 60 * 60 * 1e3;
   }
@@ -15201,14 +16153,17 @@ var init_agent_context = __esm({
 });
 
 // src/tool-validators.js
-function validateProps(args, props, required, path20 = "") {
+function validationError(msg) {
+  return new MCPError(ERROR_CODES.INVALID_ARGS, msg);
+}
+function validateProps(args, props, required, path21 = "") {
   for (const [key, prop] of Object.entries(props)) {
-    const fullKey = path20 ? `${path20}.${key}` : key;
+    const fullKey = path21 ? `${path21}.${key}` : key;
     const isOptional = !required.includes(key);
     const val = args[key];
     if (val === void 0 || val === null) {
       if (isOptional) continue;
-      throw new Error(`Missing required argument: ${fullKey}`);
+      throw validationError(`Missing required argument: ${fullKey}`);
     }
     if (prop.type === "object" && prop.properties && typeof val === "object" && !Array.isArray(val)) {
       const subRequired = prop.required || [];
@@ -15223,46 +16178,46 @@ function validateProps(args, props, required, path20 = "") {
     const actualType = typeof val;
     const expectedType = prop.type || "string";
     if (expectedType === "string" && actualType !== "string" && actualType !== "number") {
-      throw new Error(`Invalid type for argument ${fullKey}: expected string, got ${actualType}`);
+      throw validationError(`Invalid type for argument ${fullKey}: expected string, got ${actualType}`);
     }
     if ((expectedType === "object" || expectedType === "array") && (actualType !== "object" || val === null)) {
-      throw new Error(`Invalid type for argument ${fullKey}: expected ${expectedType}, got ${actualType}`);
+      throw validationError(`Invalid type for argument ${fullKey}: expected ${expectedType}, got ${actualType}`);
     }
     if (expectedType === "array" && !Array.isArray(val)) {
-      throw new Error(`Invalid type for argument ${fullKey}: expected array, got ${actualType}`);
+      throw validationError(`Invalid type for argument ${fullKey}: expected array, got ${actualType}`);
     }
     if (expectedType === "object" && Array.isArray(val)) {
-      throw new Error(`Invalid type for argument ${fullKey}: expected object, got array`);
+      throw validationError(`Invalid type for argument ${fullKey}: expected object, got array`);
     }
     if ((expectedType === "number" || expectedType === "integer") && actualType !== "number") {
       if (expectedType === "integer" && !Number.isInteger(val)) {
-        throw new Error(`Invalid type for argument ${fullKey}: expected integer, got ${actualType}`);
+        throw validationError(`Invalid type for argument ${fullKey}: expected integer, got ${actualType}`);
       }
       if (expectedType === "number") {
-        throw new Error(`Invalid type for argument ${fullKey}: expected number, got ${actualType}`);
+        throw validationError(`Invalid type for argument ${fullKey}: expected number, got ${actualType}`);
       }
     }
     if (expectedType === "boolean" && actualType !== "boolean") {
-      throw new Error(`Invalid type for argument ${fullKey}: expected boolean, got ${actualType}`);
+      throw validationError(`Invalid type for argument ${fullKey}: expected boolean, got ${actualType}`);
     }
     if (prop.enum && !prop.enum.includes(val)) {
-      throw new Error(`Invalid value for argument ${fullKey}: must be one of ${prop.enum.join(", ")}`);
+      throw validationError(`Invalid value for argument ${fullKey}: must be one of ${prop.enum.join(", ")}`);
     }
     if (expectedType === "string" && typeof prop.maxLength === "number" && String(val).length > prop.maxLength) {
-      throw new Error(`Argument ${fullKey} exceeds max length of ${prop.maxLength}`);
+      throw validationError(`Argument ${fullKey} exceeds max length of ${prop.maxLength}`);
     }
     if ((expectedType === "number" || expectedType === "integer") && prop.minimum != null && val < prop.minimum) {
-      throw new Error(`Argument ${fullKey} must be >= ${prop.minimum}`);
+      throw validationError(`Argument ${fullKey} must be >= ${prop.minimum}`);
     }
     if ((expectedType === "number" || expectedType === "integer") && prop.maximum != null && val > prop.maximum) {
-      throw new Error(`Argument ${fullKey} must be <= ${prop.maximum}`);
+      throw validationError(`Argument ${fullKey} must be <= ${prop.maximum}`);
     }
   }
 }
 function validateToolArgs(name, args) {
   const toolDef = toolsByName.get(name);
   if (!toolDef) {
-    throw new Error(`Unknown tool: ${name}`);
+    throw validationError(`Unknown tool: ${name}`);
   }
   const schema = toolDef.inputSchema;
   if (!schema || !schema.properties) return true;
@@ -15270,7 +16225,7 @@ function validateToolArgs(name, args) {
   const required = schema.required || [];
   for (const req of required) {
     if (!(req in (args || {}))) {
-      throw new Error(`Missing required argument: ${req}`);
+      throw validationError(`Missing required argument: ${req}`);
     }
   }
   validateProps(args || {}, props, required);
@@ -15279,6 +16234,7 @@ function validateToolArgs(name, args) {
 var init_tool_validators = __esm({
   "src/tool-validators.js"() {
     init_tools();
+    init_errors();
   }
 });
 
@@ -15389,7 +16345,7 @@ function registerTool(toolDef, handler) {
   }
   customTools.push(toolDef);
   customHandlers.set(toolDef.name, handler);
-  tools41.push(toolDef);
+  tools43.push(toolDef);
   return true;
 }
 function callCustomTool(name, args) {
@@ -15409,73 +16365,92 @@ var init_tool_registry = __esm({
 });
 
 // src/tool-executor.js
+function resolveConn(instance) {
+  if (instance) return pool.getConnection(instance) || resolveCadConnection();
+  return cad;
+}
+async function writeAuditSuccess(name, args, options) {
+  writeAuditEntry({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool: name,
+    args: args || {},
+    sessionId: options.sessionId || "",
+    result: "success"
+  });
+}
+async function writeAuditError(name, args, options, error2) {
+  writeAuditEntry({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool: name,
+    args: args || {},
+    sessionId: options.sessionId || "",
+    result: "error",
+    error: error2.message
+  });
+}
+async function beginUndo(instance) {
+  const conn = resolveConn(instance);
+  if (conn?.connected) {
+    try {
+      await conn.sendCommand('(command "_.UNDO" "_BEGIN")');
+      return true;
+    } catch (e) {
+      error(`UNDO_BEGIN failed: ${e.message}`);
+    }
+  }
+  return false;
+}
+async function endUndo(instance) {
+  const conn = resolveConn(instance);
+  try {
+    await conn.sendCommand('(command "_.UNDO" "_END")');
+  } catch (_) {
+  }
+}
 async function handleToolCall(name, args, options = {}) {
   const handler = TOOL_HANDLERS[name];
   if (!handler) {
     const customResult = callCustomTool(name, args);
     if (customResult !== null) return customResult;
-    return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
+    return mcpErrorResponse(new MCPError(ERROR_CODES.HANDLER_NOT_FOUND, `\u672A\u77E5\u5DE5\u5177: ${name}`));
   }
   const isReadOnly = READ_ONLY_TOOLS.has(name);
   const notifyProgress = options.notifyProgress || null;
   const rateCheck = checkToolRateLimit(name, isReadOnly, options.sessionId);
   if (!rateCheck.allowed) {
-    return { content: [{ type: "text", text: `\u5DE5\u5177\u8C03\u7528\u9891\u7387\u8D85\u9650 (${isReadOnly ? "\u8BFB" : "\u5199"}\u64CD\u4F5C)\uFF0C\u8BF7 ${rateCheck.retryAfter} \u79D2\u540E\u91CD\u8BD5` }], isError: true };
+    return mcpErrorResponse(new MCPError(ERROR_CODES.RATE_LIMITED, `\u5DE5\u5177\u8C03\u7528\u9891\u7387\u8D85\u9650\uFF0C\u8BF7 ${rateCheck.retryAfter} \u79D2\u540E\u91CD\u8BD5`));
   }
   return progressContext.run({ notifyProgress }, async () => {
     setNotifyProgress(notifyProgress);
+    const instance = args?.instance || null;
     let undoBegun = false;
     try {
       validateToolArgs(name, args || {});
-      const instance = args?.instance || null;
       if (instance) {
         const ctx = mcpContext.getStore();
         ctx._toolInstance = instance;
       }
       if (!isReadOnly) {
-        const targetConn = instance ? pool.getConnection(instance) : cad;
-        if (targetConn?.connected) {
-          try {
-            await targetConn.sendCommand('(command "_.UNDO" "_BEGIN")');
-            undoBegun = true;
-          } catch (e) {
-            error(`UNDO_BEGIN failed: ${e.message}`);
-          }
-        }
+        undoBegun = await beginUndo(instance);
       }
       const np = getNotifyProgress();
       if (np) np(1, 1, `\u6B63\u5728\u6267\u884C ${name}...`);
       const result = await handler(args || {});
       if (np) np(1, 1, `${name} \u6267\u884C\u5B8C\u6210`);
-      writeAuditEntry({
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        tool: name,
-        args: args || {},
-        sessionId: options.sessionId || "",
-        result: result?.isError ? "error" : "success"
-      });
+      await writeAuditSuccess(name, args, options);
       notifyResourceChanges(name);
       return result;
     } catch (e) {
       error(`Tool call error [${name}]: ${e.message}`, { tool: name, args });
-      writeAuditEntry({
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        tool: name,
-        args: args || {},
-        sessionId: options.sessionId || "",
-        result: "error",
-        error: e.message
-      });
-      return { content: [{ type: "text", text: `\u5DE5\u5177\u6267\u884C\u9519\u8BEF: ${e.message}` }], isError: true };
+      await writeAuditError(name, args, options, e);
+      if (e.message.startsWith("Missing required") || e.message.startsWith("Invalid type")) {
+        return mcpErrorResponse(new MCPError(ERROR_CODES.INVALID_ARGS, e.message));
+      }
+      return mcpErrorResponse(e);
     } finally {
       const ctx = mcpContext.getStore();
       if (ctx) ctx._toolInstance = null;
-      if (undoBegun) {
-        try {
-          await cad.sendCommand('(command "_.UNDO" "_END")');
-        } catch (_) {
-        }
-      }
+      if (undoBegun) await endUndo(instance);
     }
   });
 }
@@ -15492,14 +16467,12 @@ var init_tool_executor = __esm({
     init_cad();
     init_cad_pool();
     init_audit_log();
+    init_errors();
     init_tool_registry();
   }
 });
 
 // src/mcp-tools.js
-import fs11 from "fs";
-import path15 from "path";
-import os9 from "os";
 import { formatCode as formatCode2 } from "@atlisp/lint/dist/formatter.js";
 import { lintProject as lintProject2 } from "@atlisp/lint/dist/project.js";
 import { RULES as RULES3 } from "@atlisp/lint/dist/rules.js";
@@ -15516,7 +16489,6 @@ var TOOL_HANDLERS;
 var init_mcp_tools = __esm({
   "src/mcp-tools.js"() {
     init_handler_loader();
-    init_prompt_handlers();
     init_streaming();
     init_constants();
     init_cad();
@@ -15524,13 +16496,24 @@ var init_mcp_tools = __esm({
     init_tools();
     init_mcp_server_state();
     init_trigger_engine();
-    init_lisp_sandbox();
+    init_lisp_security();
     init_lint_analyzer();
     init_repl_engine();
     init_webhook_engine();
     init_audit_log();
     init_agent_context();
+    init_resource_handlers();
+    init_subscription_manager();
+    init_skill_handlers();
+    init_meta_handlers();
     init_tool_executor();
+    pool.onInstanceSwitch(() => {
+      for (const uri of CAD_RESOURCE_URIS) {
+        if (isSubscribed(uri)) {
+          notify2(uri, null);
+        }
+      }
+    });
     TOOL_HANDLERS = {
       // === CAD Connection ===
       connect_cad: lazy("connect_cad", (a) => a?.platform),
@@ -15567,14 +16550,8 @@ ${CAD_PLATFORMS.join("\n")}
         return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
       },
       // === Prompts ===
-      list_prompts: async () => {
-        const prompts = await listPrompts2();
-        return { content: [{ type: "text", text: JSON.stringify(prompts) }] };
-      },
-      get_prompt: async (a) => {
-        const prompt = await getPrompt2(a.name, a.args || {});
-        return { content: prompt.messages.map((m) => ({ type: "text", text: m.content.text || m.content })) };
-      },
+      list_prompts: list_prompts_handler,
+      get_prompt: get_prompt_handler,
       // === Entity Operations ===
       get_entity: lazy("get_entity", (a) => a?.handle),
       set_entity: lazy("set_entity", (a) => [a?.handle, a?.property, a?.value]),
@@ -15861,6 +16838,35 @@ ${CAD_PLATFORMS.join("\n")}
       draw_ray: lazy("draw_ray", (a) => [a.point, a.direction]),
       draw_leader: lazy("draw_leader", (a) => [a.points, a.annotation]),
       draw_table: lazy("draw_table", (a) => [a.insertionPoint, a.rows, a.columns, a.rowHeight, a.colWidth]),
+      // === Batch Concurrent ===
+      batch_concurrent_tasks: async (a) => {
+        if (!a.tasks || !Array.isArray(a.tasks) || a.tasks.length === 0) {
+          return { content: [{ type: "text", text: "\u9700\u8981 tasks \u6570\u7EC4" }], isError: true };
+        }
+        if (a.tasks.length > 50) {
+          return { content: [{ type: "text", text: "\u6700\u591A\u652F\u6301 50 \u4E2A\u5E76\u53D1\u4EFB\u52A1" }], isError: true };
+        }
+        const results = await Promise.allSettled(a.tasks.map(async (task, idx) => {
+          const handler = TOOL_HANDLERS[task.tool];
+          if (!handler) return { index: idx, tool: task.tool, instance: task.instance, ok: false, error: `\u672A\u77E5\u5DE5\u5177: ${task.tool}` };
+          const ctx = mcpContext.getStore();
+          const prevInstance = ctx?._toolInstance || null;
+          if (ctx && task.instance) ctx._toolInstance = task.instance;
+          try {
+            const result = await handler(task.args || {});
+            return { index: idx, tool: task.tool, instance: task.instance, ok: !result.isError, data: result.content?.[0]?.text || result };
+          } catch (e) {
+            return { index: idx, tool: task.tool, instance: task.instance, ok: false, error: e.message };
+          } finally {
+            if (ctx) ctx._toolInstance = prevInstance;
+          }
+        }));
+        const output = results.map((r, idx) => {
+          if (r.status === "fulfilled") return r.value;
+          return { index: idx, tool: a.tasks[idx].tool, instance: a.tasks[idx].instance, ok: false, error: r.reason?.message || "Unknown error" };
+        });
+        return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+      },
       // === Batch Transaction ===
       batch_transaction: lazy("batch_transaction"),
       // === Watch / Trigger ===
@@ -15907,10 +16913,10 @@ ${CAD_PLATFORMS.join("\n")}
         return { content: [{ type: "text", text: JSON.stringify(history) }] };
       },
       lisp_repl_list: () => {
-        return { content: [{ type: "text", text: JSON.stringify(listSessions()) }] };
+        return { content: [{ type: "text", text: JSON.stringify(listSessions2()) }] };
       },
       lisp_repl_close: (a) => {
-        const ok = closeSession(a.sessionId);
+        const ok = closeSession2(a.sessionId);
         return { content: [{ type: "text", text: JSON.stringify({ success: ok }) }] };
       },
       // === Streaming ===
@@ -15982,6 +16988,12 @@ ${CAD_PLATFORMS.join("\n")}
           return { content: [{ type: "text", text: `\u9879\u76EE\u5206\u6790\u5931\u8D25: ${e.message}` }], isError: true };
         }
       },
+      // === Debug ===
+      debug_start: lazy("debug_start", (a) => a),
+      debug_step: lazy("debug_step", (a) => a),
+      debug_evaluate: lazy("debug_evaluate", (a) => a),
+      debug_get_state: lazy("debug_get_state", (a) => a),
+      debug_stop: lazy("debug_stop", (a) => a),
       // === Sandbox (Security) ===
       sandbox_validate: (a) => {
         const result = validateLispCode(a.code, a.sessionId || null);
@@ -16011,6 +17023,14 @@ ${CAD_PLATFORMS.join("\n")}
       },
       cad_pool_switch: (a) => {
         const ok = pool.setActive(a.key);
+        if (ok) {
+          clearCache();
+          for (const uri of CAD_RESOURCE_URIS) {
+            if (isSubscribed(uri)) {
+              notify2(uri, null);
+            }
+          }
+        }
         return { content: [{ type: "text", text: ok ? `\u5DF2\u5207\u6362\u5230\u5B9E\u4F8B ${a.key}` : `\u5B9E\u4F8B ${a.key} \u4E0D\u5B58\u5728` }] };
       },
       cad_pool_health: async () => {
@@ -16022,8 +17042,9 @@ ${CAD_PLATFORMS.join("\n")}
         return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
       },
       cad_pool_connect: async (a) => {
-        const ok = await pool.connect(a.key, a.platform, { label: a.label, makeActive: a.makeActive !== false });
-        return { content: [{ type: "text", text: ok ? `\u5B9E\u4F8B "${a.key}" \u5DF2\u8FDE\u63A5` : `\u5B9E\u4F8B "${a.key}" \u8FDE\u63A5\u5931\u8D25` }] };
+        const ok = await pool.connect(a.key, a.platform, { label: a.label, pid: a.pid, makeActive: a.makeActive !== false });
+        const label = a.key || (a.pid != null ? `PID ${a.pid}` : "default");
+        return { content: [{ type: "text", text: ok ? `\u5B9E\u4F8B "${label}" \u5DF2\u8FDE\u63A5` : `\u5B9E\u4F8B "${label}" \u8FDE\u63A5\u5931\u8D25` }] };
       },
       cad_pool_disconnect: async (a) => {
         const ok = await pool.disconnect(a.key);
@@ -16073,261 +17094,15 @@ ${CAD_PLATFORMS.join("\n")}
         return { content: [{ type: "text", text: "\u4E0A\u4E0B\u6587\u5DF2\u6E05\u9664" }] };
       },
       // === Meta Tools ===
-      search_tools: async (a) => {
-        const q = (a.query || "").toLowerCase();
-        const results = tools41.filter((t) => t.name.toLowerCase().includes(q) || (t.description || "").toLowerCase().includes(q));
-        const text = results.length ? `\u627E\u5230 ${results.length} \u4E2A\u5DE5\u5177:
-${results.map((t) => `${t.name}: ${t.description}`).join("\n")}` : `\u672A\u627E\u5230\u5305\u542B "${a.query}" \u7684\u5DE5\u5177`;
-        return { content: [{ type: "text", text }] };
-      },
-      list_tools_by_category: async (a) => {
-        const categories = {};
-        for (const t of tools41) {
-          let cat = "\u5176\u4ED6";
-          const n = t.name;
-          if (/^(draw_|create_3d_|create_box|create_cone|create_cylinder|create_sphere|create_torus|create_wedge|extrude_|revolve_|boolean_|slice_solid|thicken_|offset_surface|create_loft_|create_region)/.test(n)) cat = "\u7ED8\u56FE\u4E0E3D";
-          else if (/^(move_|copy_|rotate_|scale_|mirror_|offset_|array_|batch_)/.test(n)) cat = "\u4FEE\u6539";
-          else if (/^(trim_|extend_|fillet|chamfer|break_|join_|stretch)/.test(n)) cat = "\u7F16\u8F91";
-          else if (/^(create_layer|delete_layer|set_layer|layer_)/.test(n)) cat = "\u56FE\u5C42";
-          else if (/^(create_block|insert_block|explode_block|get_block|set_block|batch_get_block|batch_set_block)/.test(n)) cat = "\u5757";
-          else if (/^(create_dim|list_dim|set_dim|create_hatch|set_hatch)/.test(n)) cat = "\u6807\u6CE8\u4E0E\u586B\u5145";
-          else if (/^(create_ucs|set_ucs|delete_ucs|list_ucs|get_current_ucs|create_layout|delete_layout|rename_layout|set_layout|list_layouts|get_current_layout)/.test(n)) cat = "\u5750\u6807\u7CFB\u4E0E\u5E03\u5C40";
-          else if (/^(create_viewport|set_viewport|lock_viewport|unlock_viewport|maximize_viewport)/.test(n)) cat = "\u89C6\u53E3";
-          else if (/^find_/.test(n)) cat = "\u7A7A\u95F4\u67E5\u8BE2";
-          else if (/^(select_|get_entity|set_entity|delete_entity|get_bounding_box)/.test(n)) cat = "\u9009\u62E9\u4E0E\u5C5E\u6027";
-          else if (/^(open_dwg|save_dwg|export_|import_|close_dwg|publish_)/.test(n)) cat = "\u6587\u4EF6";
-          else if (/^(plot_|save_pdf|batch_plot|publish_layouts)/.test(n)) cat = "\u6253\u5370";
-          else if (/^(get_xdata|set_xdata|delete_xdata|list_xdata|copxy_xdata|search_by_xdata|export_xdata|import_xdata)/.test(n)) cat = "\u6269\u5C55\u6570\u636E";
-          else if (/^(create_sheet|open_sheet|list_sheet|add_sheet|delete_sheet|publish_sheet|sheet_|reorder_sheet|create_subset|list_subset|set_sheet)/.test(n)) cat = "\u56FE\u7EB8\u96C6";
-          else if (/^(attach_|detach_|reload_|list_attached|get_pdf|create_dgn|create_dwf|import_dxf|import_dgn|export_dgn|create_hyper|remove_hyper|xref|bind_xref|clip_xref|path_xref)/.test(n)) cat = "\u53C2\u7167\u4E0E\u5E95\u56FE";
-          else if (/^(create_text|create_mleader|create_linetype|list_text|list_linetype|list_mleader|load_linetype|create_dimension_style|set_dimstyle|list_dimension_styles|set_mleader_style)/.test(n)) cat = "\u6837\u5F0F";
-          else if (/^(purge_|drawing_audit|drawing_recover|overkill)/.test(n)) cat = "\u6E05\u7406";
-          else if (/^(find_text|replace_text|set_text_|justify_|convert_text|explode_text)/.test(n)) cat = "\u6587\u5B57";
-          else if (/^(eval_lisp|connect_cad|get_cad|get_platform|get_system|at_command|new_document|bring_to_front|install_atlisp|init_atlisp|get_system_status)/.test(n)) cat = "\u7CFB\u7EDF";
-          else if (/^(list_packages|search_packages|install_package|get_function_usage|list_symbols|import_funlib)/.test(n)) cat = "\u5305\u4E0E\u51FD\u6570";
-          else if (/^(pipeline_|watch_|lisp_repl|webhook_|sandbox_|audit_|cad_pool_|external_|list_data|export_to|import_external)/.test(n)) cat = "\u9AD8\u7EA7";
-          else if (/^(list_prompts|get_prompt|search_tools|list_tools_by_category)/.test(n)) cat = "\u5143\u5DE5\u5177";
-          else if (/^(agent_)/.test(n)) cat = "Agent\u4E0A\u4E0B\u6587";
-          if (!categories[cat]) categories[cat] = [];
-          categories[cat].push(t.name);
-        }
-        if (a.category) {
-          const names = categories[a.category];
-          return { content: [{ type: "text", text: names ? `${a.category} (${names.length}):
-${names.join("\n")}` : `\u672A\u627E\u5230\u5206\u7C7B: ${a.category}` }] };
-        }
-        const lines = [];
-        for (const [cat, names] of Object.entries(categories)) {
-          lines.push(`## ${cat} (${names.length})`);
-        }
-        lines.push(`
-\u5171 ${Object.keys(categories).length} \u4E2A\u5206\u7C7B`);
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      },
+      search_tools,
+      list_tools_by_category,
+      get_tool_info,
       // === Skill Management ===
-      skill_search: async (a) => {
-        const registryUrl = process.env.SKILL_REGISTRY_URL || "https://raw.githubusercontent.com/atlisp/skill-registry/main/index.json";
-        const cachePath = path15.join(os9.homedir(), ".atlisp", "skill-registry-cache.json");
-        let cache = null;
-        try {
-          if (fs11.existsSync(cachePath)) cache = JSON.parse(fs11.readFileSync(cachePath, "utf-8"));
-        } catch {
-        }
-        let index = cache && Date.now() - cache.fetchedAt < 36e5 ? cache : null;
-        if (!index) {
-          try {
-            const resp = await fetch(registryUrl, { headers: { "User-Agent": "atlisp-mcp" } });
-            if (resp.ok) {
-              index = await resp.json();
-              index.fetchedAt = Date.now();
-              try {
-                fs11.writeFileSync(cachePath, JSON.stringify(index, null, 2), "utf-8");
-              } catch {
-              }
-            }
-          } catch {
-          }
-        }
-        if (!index || !index.skills) return { content: [{ type: "text", text: "\u65E0\u6CD5\u83B7\u53D6 skill \u6CE8\u518C\u8868\u7D22\u5F15" }], isError: true };
-        const q = (a.query || "").toLowerCase();
-        const results = index.skills.filter(
-          (s) => s.name.toLowerCase().includes(q) || (s.description || "").toLowerCase().includes(q) || (s.tags || []).some((t) => t.toLowerCase().includes(q))
-        );
-        if (!results.length) return { content: [{ type: "text", text: `\u672A\u627E\u5230\u5339\u914D "${a.query}" \u7684 skill` }] };
-        const lines = [`\u627E\u5230 ${results.length} \u4E2A skill:
-`];
-        for (const s of results) {
-          lines.push(`**${s.name}**`);
-          if (s.description) lines.push(`  \u63CF\u8FF0: ${s.description}`);
-          if (s.tags?.length) lines.push(`  \u6807\u7B7E: ${s.tags.join(", ")}`);
-          if (s.version) lines.push(`  \u7248\u672C: ${s.version}`);
-          lines.push("");
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      },
-      skill_install: async (a) => {
-        if (!a.name) return { content: [{ type: "text", text: "\u9700\u8981 skill \u540D\u79F0" }], isError: true };
-        const registryUrl = process.env.SKILL_REGISTRY_URL || "https://raw.githubusercontent.com/atlisp/skill-registry/main/index.json";
-        const cachePath = path15.join(os9.homedir(), ".atlisp", "skill-registry-cache.json");
-        let cache = null;
-        try {
-          if (fs11.existsSync(cachePath)) cache = JSON.parse(fs11.readFileSync(cachePath, "utf-8"));
-        } catch {
-        }
-        let index = cache;
-        if (!index || Date.now() - index.fetchedAt > 36e5) {
-          try {
-            const resp = await fetch(registryUrl, { headers: { "User-Agent": "atlisp-mcp" } });
-            if (resp.ok) {
-              index = await resp.json();
-              index.fetchedAt = Date.now();
-              try {
-                fs11.writeFileSync(cachePath, JSON.stringify(index, null, 2), "utf-8");
-              } catch {
-              }
-            }
-          } catch {
-          }
-        }
-        if (!index || !index.skills) return { content: [{ type: "text", text: "\u65E0\u6CD5\u83B7\u53D6 skill \u6CE8\u518C\u8868\u7D22\u5F15" }], isError: true };
-        const skill = index.skills.find((s) => s.name === a.name);
-        if (!skill) return { content: [{ type: "text", text: `\u672A\u627E\u5230 skill: ${a.name}` }], isError: true };
-        const downloadUrl = skill.download_url || skill.url;
-        if (!downloadUrl) return { content: [{ type: "text", text: `Skill "${a.name}" \u6CA1\u6709\u4E0B\u8F7D\u5730\u5740` }], isError: true };
-        let content;
-        try {
-          const resp = await fetch(downloadUrl, { headers: { "User-Agent": "atlisp-mcp" } });
-          if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-          content = await resp.text();
-        } catch (e) {
-          return { content: [{ type: "text", text: `\u4E0B\u8F7D\u5931\u8D25: ${e.message}` }], isError: true };
-        }
-        const skillsDir = path15.join(os9.homedir(), ".atlisp", "skills");
-        try {
-          fs11.mkdirSync(skillsDir, { recursive: true });
-        } catch {
-        }
-        const safeName = a.name.replace(/[^a-zA-Z0-9\u4e00-\u9fff_-]/g, "-").substring(0, 40);
-        const skillFile = path15.join(skillsDir, `skill-${safeName}.md`);
-        if (fs11.existsSync(skillFile)) {
-          return { content: [{ type: "text", text: `Skill "${a.name}" \u5DF2\u5B89\u88C5 (${skillFile})` }], isError: true };
-        }
-        let finalContent = content;
-        if (!content.match(/^---\n/)) {
-          const tags = (skill.tags || []).join(", ");
-          finalContent = `---
-name: ${a.name}
-description: ${skill.description || ""}
-tags: ${tags}
----
-
-${content}`;
-        }
-        fs11.writeFileSync(skillFile, finalContent, "utf-8");
-        return { content: [{ type: "text", text: `\u2705 ${skill.name} \u5B89\u88C5\u6210\u529F
-\u6587\u4EF6: ${skillFile}${skill.version ? `
-\u7248\u672C: ${skill.version}` : ""}` }] };
-      },
-      skill_list_installed: async () => {
-        const skillsDir = path15.join(os9.homedir(), ".atlisp", "skills");
-        if (!fs11.existsSync(skillsDir)) return { content: [{ type: "text", text: "\u6682\u65E0\u5DF2\u5B89\u88C5\u7684 skill" }] };
-        const results = [];
-        try {
-          const entries = fs11.readdirSync(skillsDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isFile() && entry.name.endsWith(".md")) {
-              const fullPath = path15.join(skillsDir, entry.name);
-              try {
-                const raw = fs11.readFileSync(fullPath, "utf-8");
-                const match = raw.match(/^---\n([\s\S]*?)\n---/);
-                if (match) {
-                  const fm = {};
-                  for (const line of match[1].split("\n")) {
-                    const sep = line.indexOf(":");
-                    if (sep > 0) fm[line.slice(0, sep).trim()] = line.slice(sep + 1).trim();
-                  }
-                  results.push({ name: fm.name || entry.name.replace(".md", ""), description: fm.description || "", tags: fm.tags || "" });
-                } else {
-                  results.push({ name: entry.name.replace(".md", ""), description: "", tags: "" });
-                }
-              } catch {
-              }
-            }
-          }
-        } catch {
-        }
-        if (!results.length) return { content: [{ type: "text", text: "\u6682\u65E0\u5DF2\u5B89\u88C5\u7684 skill" }] };
-        const lines = [`\u5DF2\u5B89\u88C5 ${results.length} \u4E2A skill:
-`];
-        for (const s of results) {
-          lines.push(`**${s.name}**${s.description ? ` \u2014 ${s.description}` : ""}`);
-          if (s.tags) lines.push(`  \u6807\u7B7E: ${s.tags}`);
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      },
-      skill_uninstall: async (a) => {
-        if (!a.name) return { content: [{ type: "text", text: "\u9700\u8981 skill \u540D\u79F0" }], isError: true };
-        const skillsDir = path15.join(os9.homedir(), ".atlisp", "skills");
-        if (!fs11.existsSync(skillsDir)) return { content: [{ type: "text", text: `\u672A\u5B89\u88C5 skill: ${a.name}` }], isError: true };
-        let found = null;
-        try {
-          const entries = fs11.readdirSync(skillsDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isFile() && entry.name.endsWith(".md")) {
-              const fullPath = path15.join(skillsDir, entry.name);
-              try {
-                const raw = fs11.readFileSync(fullPath, "utf-8");
-                const match = raw.match(/^---\n([\s\S]*?)\n---/);
-                if (match) {
-                  for (const line of match[1].split("\n")) {
-                    if (line.startsWith("name:") && line.slice(5).trim() === a.name) {
-                      found = fullPath;
-                      break;
-                    }
-                  }
-                } else if (entry.name.replace(".md", "") === a.name) {
-                  found = fullPath;
-                }
-              } catch {
-              }
-              if (found) break;
-            }
-          }
-        } catch {
-        }
-        if (!found) return { content: [{ type: "text", text: `\u672A\u5B89\u88C5 skill: ${a.name}` }], isError: true };
-        fs11.unlinkSync(found);
-        return { content: [{ type: "text", text: `\u2705 ${a.name} \u5DF2\u5378\u8F7D` }] };
-      },
-      skill_list_categories: async () => {
-        const registryUrl = process.env.SKILL_REGISTRY_URL || "https://raw.githubusercontent.com/atlisp/skill-registry/main/index.json";
-        const cachePath = path15.join(os9.homedir(), ".atlisp", "skill-registry-cache.json");
-        let cache = null;
-        try {
-          if (fs11.existsSync(cachePath)) cache = JSON.parse(fs11.readFileSync(cachePath, "utf-8"));
-        } catch {
-        }
-        let index = cache && Date.now() - cache.fetchedAt < 36e5 ? cache : null;
-        if (!index) {
-          try {
-            const resp = await fetch(registryUrl, { headers: { "User-Agent": "atlisp-mcp" } });
-            if (resp.ok) {
-              index = await resp.json();
-              try {
-                fs11.writeFileSync(cachePath, JSON.stringify(index, null, 2), "utf-8");
-              } catch {
-              }
-            }
-          } catch {
-          }
-        }
-        if (!index || !index.skills) return { content: [{ type: "text", text: "\u65E0\u6CD5\u83B7\u53D6 skill \u6CE8\u518C\u8868\u7D22\u5F15" }], isError: true };
-        const cats = /* @__PURE__ */ new Set();
-        for (const s of index.skills) for (const t of s.tags || []) cats.add(t);
-        const sorted = Array.from(cats).sort();
-        return { content: [{ type: "text", text: sorted.length ? `\u6CE8\u518C\u8868\u5206\u7C7B (${sorted.length}):
-${sorted.join("\n")}` : "\u6682\u65E0\u5206\u7C7B" }] };
-      }
+      skill_search,
+      skill_install,
+      skill_list_installed,
+      skill_uninstall,
+      skill_list_categories
     };
   }
 });
@@ -16418,7 +17193,7 @@ var init_mcp_server_state = __esm({
     progressContext = new AsyncLocalStorage();
     sessionServers = /* @__PURE__ */ new Map();
     sessionTransports = /* @__PURE__ */ new Map();
-    mcpHandlers = { tools: tools41, handleToolCall };
+    mcpHandlers = { tools: tools43, handleToolCall };
     _stdioServer = null;
     _pendingResourceUpdated = /* @__PURE__ */ new Set();
     _resourceUpdatedTimer = null;
@@ -16442,11 +17217,12 @@ function mcpError(text) {
   return { content: [{ type: "text", text: String(text) }], isError: true };
 }
 async function ensureCadConnected() {
-  const { cad: cad2 } = await Promise.resolve().then(() => (init_cad(), cad_exports));
-  if (!cad2.connected) {
-    await cad2.connect();
+  const { cad: cad2, resolveCadConnection: resolveCadConnection2 } = await Promise.resolve().then(() => (init_cad(), cad_exports));
+  const conn = resolveCadConnection2();
+  if (!conn.connected) {
+    await conn.connect();
   }
-  if (!cad2.connected) {
+  if (!conn.connected) {
     throw createError(ERROR_CODES.CAD_NOT_CONNECTED);
   }
 }
@@ -16631,7 +17407,7 @@ __export(resource_handlers_exports, {
   readResource: () => readResource
 });
 import fs13 from "fs";
-import path16 from "path";
+import path17 from "path";
 function propertyPairsToObject(pairs) {
   if (!Array.isArray(pairs)) return null;
   const obj = {};
@@ -16642,7 +17418,7 @@ function propertyPairsToObject(pairs) {
   }
   return obj;
 }
-async function ensureCad() {
+async function ensureCad2() {
   if (!cad.connected) await cad.connect();
   if (!cad.connected) throw createError(ERROR_CODES.CAD_NOT_CONNECTED);
 }
@@ -16810,7 +17586,7 @@ function parseTableRecord(rec, tableName) {
   return obj.name ? obj : null;
 }
 async function getEntityByHandle(handle) {
-  await ensureCad();
+  await ensureCad2();
   const code = `(progn
     (vl-load-com)
         (if (setq ent (handent "${escapeLispString(handle)}"))
@@ -16920,7 +17696,7 @@ async function getEntities(params = {}) {
   const cacheKey = `dwg:entities:${JSON.stringify(params)}`;
   const cached = getCached(cacheKey);
   if (cached) return cached;
-  await ensureCad();
+  await ensureCad2();
   const hasFilter = params.type || params.layer || params.bbox;
   if (!hasFilter) {
     return await getEntitiesSummary(cacheKey);
@@ -16956,7 +17732,7 @@ async function getTextContent(params = {}) {
   const cacheKey = `dwg:text-content:${JSON.stringify(params)}`;
   const cached = getCached(cacheKey);
   if (cached) return cached;
-  await ensureCad();
+  await ensureCad2();
   const offset = Math.max(0, parseInt(params.offset) || 0);
   const limit = Math.min(Math.max(1, parseInt(params.limit) || 5e3), 5e3);
   try {
@@ -17106,7 +17882,7 @@ async function combineText(params = {}) {
   return { total: blocks.length, blocks, medianHeight: mh };
 }
 async function getDwgName() {
-  await ensureCad();
+  await ensureCad2();
   try {
     const code = `(vl-princ-to-string (getvar "dwgname"))`;
     const name = await cad.sendCommandWithResult(code);
@@ -17116,7 +17892,7 @@ async function getDwgName() {
   }
 }
 async function getDwgPath() {
-  await ensureCad();
+  await ensureCad2();
   try {
     const code = `(progn
       (setq prefix (vl-princ-to-string (getvar "dwgprefix")))
@@ -17149,7 +17925,7 @@ async function getBlockRefs(params = {}) {
   const cacheKey = `dwg:block-refs:${params.blockName || "all"}`;
   const cached = getCached(cacheKey);
   if (cached) return cached;
-  await ensureCad();
+  await ensureCad2();
   try {
     const code = buildBlockRefsCode(params.blockName);
     const resultStr = await cad.sendCommandWithResult(code);
@@ -17211,7 +17987,7 @@ async function getTables(params = {}) {
   const cacheKey = `dwg:tbl:${tblName}`;
   const cached = getCached(cacheKey);
   if (cached) return cached;
-  await ensureCad();
+  await ensureCad2();
   try {
     const code = buildTablesCode(tblName);
     const resultStr = await cad.sendCommandWithResult(code);
@@ -17293,7 +18069,7 @@ async function getPackages(filterName = null) {
   const cacheKey = filterName ? `packages:${filterName}` : "packages:all";
   const cached = getCached(cacheKey);
   if (cached) return cached;
-  await ensureCad();
+  await ensureCad2();
   try {
     const code = `(mapcar 'cdr @::*local-pkgs*)`;
     const result = await cad.sendCommandWithResult(code);
@@ -17366,7 +18142,7 @@ async function getDwgList() {
   const cacheKey = "cad:dwgs";
   const cached = getCached(cacheKey);
   if (cached) return cached;
-  await ensureCad();
+  await ensureCad2();
   try {
     const code = `(progn
       (vl-load-com)
@@ -17403,7 +18179,7 @@ async function getDwgList() {
   }
 }
 function loadStandardsFile(filename) {
-  const filePath = path16.join(STANDARDS_DIR, filename);
+  const filePath = path17.join(STANDARDS_DIR, filename);
   try {
     const raw = fs13.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
@@ -17436,7 +18212,7 @@ function getCodingStandards() {
   return data || { error: "\u7F16\u7801\u89C4\u8303\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25" };
 }
 async function getCadEvents(params) {
-  await ensureCad();
+  await ensureCad2();
   try {
     const code = `(progn (setq cnt 0) (if (setq ss (ssget "_X")) (setq cnt (sslength ss))) (list (cons "entityCount" cnt) (cons "dwgName" (getvar "dwgname")) (cons "dwgPath" (getvar "dwgprefix"))))`;
     const result = await cad.sendCommandWithResult(code);
@@ -17503,6 +18279,119 @@ async function getDwgContext() {
     };
   }
 }
+async function getDrawingAnalysis(params = {}) {
+  const snapshot = await getCadSnapshot();
+  if (!snapshot || !snapshot.cadConnected) {
+    return { connected: false, error: "CAD \u672A\u8FDE\u63A5" };
+  }
+  try {
+    const detailedCode = `(progn
+  (vl-load-com)
+  (setq r nil)
+  ;; entity counts by type
+  (if (setq ss (ssget "_X"))
+    (progn
+      (setq total (sslength ss) i 0 cnt nil)
+      (while (< i total)
+        (setq typ (cdr (assoc 0 (entget (ssname ss i)))))
+        (setq cnt (if (assoc typ cnt) (subst (cons typ (1+ (cdr (assoc typ cnt)))) (assoc typ cnt) cnt) (cons (cons typ 1) cnt)))
+        (setq i (1+ i)))
+      (setq r (cons (cons "entityCount" total) r))
+      (setq r (cons (cons "entityByType" cnt) r)))
+    (setq r (cons (cons "entityCount" 0) r)))
+  ;; block usage
+  (setq blocks nil)
+  (vlax-for b (vla-get-blocks (vla-get-activedocument (vlax-get-acad-object)))
+    (if (and (= (vla-get-IsXref b) :vlax-false) (/= (vla-get-Name b) "*Model_Space") (/= (vla-get-Name b) "*Paper_Space"))
+      (setq blocks (cons (list "name" (vla-get-Name b) "count" (vla-get-Count b) "isDynamic" (vla-get-IsDynamicBlock b)) blocks))))
+  (setq r (cons (cons "blockUsage" blocks) r))
+  ;; layer summary
+  (setq layers nil le (tblnext "layer" t))
+  (while le
+    (setq ln (cdr (assoc 2 le)) lc (cdr (assoc 62 le)) ll (cdr (assoc 6 le)))
+    (setq layers (cons (list "name" ln "color" (if (< lc 0) (- lc) lc) "off" (< lc 0) "linetype" ll) layers))
+    (setq le (tblnext "layer" nil)))
+  (setq r (cons (cons "layers" layers) r))
+  ;; text stats
+  (if (setq ts (ssget "_X" '((0 . "TEXT,MTEXT"))))
+    (progn
+      (setq tc (sslength ts) th nil ti 0)
+      (while (< ti tc)
+        (setq h (cdr (assoc 40 (entget (ssname ts ti)))))
+        (if h (setq th (cons h th)))
+        (setq ti (1+ ti)))
+      (setq th (vl-sort th '<))
+      (setq r (cons (cons "textCount" tc) r))
+      (setq r (cons (cons "textHeights" (list "min" (car th) "max" (last th) "median" (nth (fix (/ (length th) 2)) th))) r)))
+    (setq r (cons (cons "textCount" 0) r)))
+  ;; system variables
+  (setq r (cons (cons "sysvars" (list
+    (cons "ltscale" (getvar "ltscale"))
+    (cons "dimscale" (getvar "dimscale"))
+    (cons "insunits" (getvar "insunits"))
+    (cons "measurement" (getvar "measurement"))
+    (cons "celtype" (getvar "celtype"))
+    (cons "clayer" (getvar "clayer"))
+    (cons "cecolor" (getvar "cecolor"))
+    (cons "osmode" (getvar "osmode"))
+    (cons "snapmode" (getvar "snapmode"))
+    (cons "gridmode" (getvar "gridmode"))
+    (cons "orthomode" (getvar "orthomode"))
+    (cons "plinetype" (getvar "plinetype"))
+    (cons "fillmode" (getvar "fillmode"))
+    (cons "pickstyle" (getvar "pickstyle"))
+  )) r))
+  (vl-prin1-to-string (reverse r)))`;
+    const resultStr = await cad.sendCommandWithResult(detailedCode);
+    const parsed = parseLispRecursive(resultStr);
+    if (!parsed || !Array.isArray(parsed)) {
+      return { connected: true, error: "\u5206\u6790\u7ED3\u679C\u89E3\u6790\u5931\u8D25" };
+    }
+    const analysis = {};
+    for (const pair of parsed) {
+      if (Array.isArray(pair) && pair.length >= 2) {
+        analysis[String(pair[0])] = pair[1];
+      }
+    }
+    return { connected: true, ...analysis };
+  } catch (e) {
+    log(`getDrawingAnalysis error: ${e.message}`);
+    return { connected: true, error: e.message };
+  }
+}
+function getToolCategories() {
+  const cats = {};
+  for (const t of tools43) {
+    const cat = t.annotations?.category || "\u5176\u4ED6";
+    if (!cats[cat]) cats[cat] = { count: 0, tools: [] };
+    cats[cat].count++;
+    cats[cat].tools.push(t.name);
+  }
+  return Object.entries(cats).map(([category, info]) => ({
+    category,
+    count: info.count,
+    tools: info.tools
+  })).sort((a, b) => b.count - a.count);
+}
+async function checkDrawingStandards() {
+  const standards = getDraftingStandards();
+  if (!standards || standards.error) {
+    return { ok: false, error: standards?.error || "\u5236\u56FE\u89C4\u8303\u672A\u52A0\u8F7D" };
+  }
+  try {
+    const issues = [];
+    for (const rule of standards.layers || []) {
+      const code = `(tblsearch "LAYER" "${escapeLispString(rule.name || rule.pattern)}")`;
+      const exists = await cad.sendCommandWithResult(code);
+      if (rule.required && (!exists || exists === "nil" || exists === "")) {
+        issues.push({ type: "missing_layer", message: `\u7F3A\u5C11\u5FC5\u9700\u56FE\u5C42: ${rule.name}` });
+      }
+    }
+    return { ok: issues.length === 0, issues };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
 function getToolRelationships() {
   return {
     selection: {
@@ -17758,6 +18647,12 @@ async function readResource(uri) {
       return await getDwgContext();
     case "atlisp://tools/relationships":
       return getToolRelationships();
+    case "atlisp://dwg/analysis":
+      return await getDrawingAnalysis(params);
+    case "atlisp://tools/categories":
+      return getToolCategories();
+    case "atlisp://dwg/standards/check":
+      return await checkDrawingStandards();
     default:
       throw new Error(`\u8D44\u6E90\u4E0D\u5B58\u5728: ${uri}`);
   }
@@ -17773,6 +18668,7 @@ var init_resource_handlers = __esm({
     init_handler_utils();
     init_errors();
     init_config();
+    init_tools();
     ENTITY_PROPERTIES_LISP = `
 (defun entity:to-list (val)
   (cond
@@ -17852,11 +18748,11 @@ init_subscription_manager();
 init_subscription_manager();
 init_sse_session();
 init_config();
-import path19 from "path";
+import path20 from "path";
 import fs16 from "fs";
 import http from "http";
 import https from "https";
-import { fileURLToPath as fileURLToPath7 } from "url";
+import { fileURLToPath as fileURLToPath8 } from "url";
 import { createRequire as createRequire2 } from "module";
 import express2 from "express";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -17869,11 +18765,12 @@ init_cad_pool();
 init_subscription_manager();
 init_mcp_server_state();
 init_sse_session();
+import os10 from "os";
 import express from "express";
-import { randomUUID as randomUUID5, createHash } from "crypto";
+import { randomUUID as randomUUID6, createHash } from "crypto";
 import fs14 from "fs";
-import path17 from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import path18 from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
 import iconv from "iconv-lite";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
@@ -17986,7 +18883,6 @@ var TOOL_PERMISSIONS = {
   "measure_*": "read",
   "stream_*": "read",
   "watch_list": "read",
-  "pipeline_list": "read",
   // Write tools
   "create_*": "write",
   "set_*": "write",
@@ -18006,8 +18902,6 @@ var TOOL_PERMISSIONS = {
   "import_*": "import",
   // Admin
   "config_*": "admin",
-  "pipeline_save": "admin",
-  "pipeline_delete": "admin",
   "webhook_*": "admin",
   "watch_remove": "admin"
 };
@@ -18041,11 +18935,11 @@ function getApiKeyRole(apiKey2, config2) {
 
 // src/routes.js
 init_constants();
-var __dirname6 = path17.dirname(fileURLToPath6(import.meta.url));
-var htmlDir = path17.join(__dirname6, "html");
+var __dirname6 = path18.dirname(fileURLToPath7(import.meta.url));
+var htmlDir = path18.join(__dirname6, "html");
 function loadHtml(name, replacements = {}) {
   if (!htmlCache[name]) {
-    htmlCache[name] = fs14.readFileSync(path17.join(htmlDir, `${name}.html`), "utf-8");
+    htmlCache[name] = fs14.readFileSync(path18.join(htmlDir, `${name}.html`), "utf-8");
   }
   let html = htmlCache[name];
   for (const [key, value] of Object.entries(replacements)) {
@@ -18058,7 +18952,7 @@ var cachedToolsJson = null;
 var cachedToolsJsonAt = 0;
 function getToolsJson() {
   if (cachedToolsJson && Date.now() - cachedToolsJsonAt < 3e4) return cachedToolsJson;
-  cachedToolsJson = JSON.stringify(tools41.map((t) => ({
+  cachedToolsJson = JSON.stringify(tools43.map((t) => ({
     name: t.name,
     description: t.description,
     inputSchema: t.inputSchema
@@ -18128,15 +19022,45 @@ function createAuthMiddleware() {
     return res.status(401).json({ error: "Unauthorized" });
   };
 }
+function originMatches(pattern, origin) {
+  if (pattern === "*") return true;
+  if (!origin) return false;
+  const getHost = (s) => s.replace(/^https?:\/\//, "").replace(/:\d+$/, "").toLowerCase();
+  const oHost = getHost(origin);
+  let pHost = getHost(pattern);
+  if (pHost.startsWith("*.")) {
+    const suffix = pHost.slice(1);
+    return oHost === suffix.slice(1) || oHost.endsWith(suffix);
+  }
+  return oHost === pHost;
+}
 function createCorsMiddleware() {
+  const allowedOrigins = corsOrigin.split(",").map((s) => s.trim()).filter(Boolean);
+  const allowAll = allowedOrigins.includes("*");
   return (req, res, next) => {
     if (!enableCors) return next();
-    res.setHeader("Access-Control-Allow-Origin", corsOrigin);
+    const origin = req.headers.origin;
+    const isPnaPreflight = req.method === "OPTIONS" && req.headers["access-control-request-private-network"] === "true";
+    if (allowAll) {
+      if (isPnaPreflight && origin) {
+        res.setHeader("Access-Control-Allow-Origin", origin);
+        res.setHeader("Vary", "Origin");
+      } else {
+        res.setHeader("Access-Control-Allow-Origin", corsOrigin);
+      }
+    } else if (origin && allowedOrigins.some((p) => originMatches(p, origin))) {
+      res.setHeader("Access-Control-Allow-Origin", origin);
+      res.setHeader("Vary", "Origin");
+    } else if (!origin) {
+      res.setHeader("Access-Control-Allow-Origin", allowedOrigins[0] || "*");
+    } else {
+      return res.status(403).json({ error: "Origin not allowed" });
+    }
     res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS, CONNECT");
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Accept, mcp-session-id, last-event-id");
     res.setHeader("Access-Control-Expose-Headers", "mcp-session-id, content-type, x-accel-buffering");
     res.setHeader("Access-Control-Max-Age", "86400");
-    res.setHeader("Vary", "Accept");
+    res.setHeader("Access-Control-Allow-Private-Network", "true");
     if (req.method === "OPTIONS") return res.status(204).end();
     next();
   };
@@ -18227,7 +19151,7 @@ function setupRoutes(app) {
       },
       mcp: {
         sessions: sessionServers.size,
-        tools: tools41.length,
+        tools: tools43.length,
         sseSessions: sseCount
       },
       pool: {
@@ -18237,6 +19161,11 @@ function setupRoutes(app) {
       }
     });
   });
+  app.get("/go", (req, res) => {
+    const remoteUrl = "https://atlisp.cn/agent";
+    const cid = config_default.clientId || os10.hostname();
+    res.redirect(302, `${remoteUrl}?clientId=${encodeURIComponent(cid)}`);
+  });
   app.get("/health/full", async (req, res) => {
     const memUsage = process.memoryUsage();
     const poolStats = pool ? pool.getStats() : {};
@@ -18250,7 +19179,7 @@ function setupRoutes(app) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       cad: { connected: cad.connected, platform: cad.getPlatform?.(), version: cad.getVersion?.(), commandQueueSize: cad._getQueueSize ? cad._getQueueSize() : 0, restartCount: cad._getRestartCount ? cad._getRestartCount() : 0 },
       system: { uptime: process.uptime(), memory: { rssMB: Math.round(memUsage.rss / 1024 / 1024), heapUsedMB: Math.round(memUsage.heapUsed / 1024 / 1024), heapTotalMB: Math.round(memUsage.heapTotal / 1024 / 1024) }, cpu: process.cpuUsage() },
-      mcp: { sessions: sessionServers.size, tools: tools41.length, sseSessions: sseCount },
+      mcp: { sessions: sessionServers.size, tools: tools43.length, sseSessions: sseCount },
       pool: poolStats
     });
   });
@@ -18288,7 +19217,7 @@ function setupRoutes(app) {
   app.get("/api/docs", (req, res) => {
     const html = loadHtml("api-docs", {
       VERSION: SERVER_VERSION,
-      TOOLS_COUNT: tools41.length
+      TOOLS_COUNT: tools43.length
     });
     res.setHeader("Content-Type", "text/html; charset=utf-8");
     res.send(html);
@@ -18309,7 +19238,7 @@ function setupRoutes(app) {
       SESSIONS_COUNT: sessionServers.size,
       CAD_STATUS_CLASS: cadConnected ? "status-ok" : "status-error",
       CAD_STATUS_TEXT: cadStatusText,
-      TOOLS_COUNT: tools41.length
+      TOOLS_COUNT: tools43.length
     });
     res.setHeader("Content-Type", "text/html; charset=utf-8");
     res.send(html);
@@ -18327,7 +19256,7 @@ function setupRoutes(app) {
   app.get("/sse", mcpLimiter, handleSse);
   app.post("/message", mcpLimiter, handleMessage);
   app.get("/cad/events", (req, res) => {
-    const sessionId = randomUUID5();
+    const sessionId = randomUUID6();
     subscribeEvents(sessionId, res);
     req.on("close", () => {
       unsubscribeEvents(sessionId);
@@ -18337,7 +19266,7 @@ function setupRoutes(app) {
   return app;
 }
 async function handleMcpPost(req, res) {
-  const sessionId = req.headers["mcp-session-id"] || req.query.sessionId || randomUUID5();
+  const sessionId = req.headers["mcp-session-id"] || req.query.sessionId || randomUUID6();
   sessionManager.createSession(sessionId);
   const body = req.body;
   if (!body) {
@@ -18405,7 +19334,7 @@ async function getMcpResponse(sessionId, body) {
 }
 async function handleSse(req, res) {
   const lastEventId = parseLastEventId(req);
-  let sessionId = randomUUID5();
+  let sessionId = randomUUID6();
   let resumeMessages = [];
   if (lastEventId !== null) {
     const existingSession = sessionManager.get(sessionId);
@@ -18471,7 +19400,7 @@ init_cad();
 init_constants();
 init_tools();
 init_subscription_manager();
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { WebSocketServer } from "ws";
 var PING_INTERVAL = 3e4;
 var CAD_POLL_INTERVAL = 5e3;
@@ -18501,7 +19430,7 @@ function sendWelcome(ws, clientId) {
         server: { name: SERVER_NAME, version: SERVER_VERSION },
         capabilities: SERVER_CAPABILITIES,
         clientId,
-        toolCount: tools41.length,
+        toolCount: tools43.length,
         cadConnected: cad.connected,
         cadPlatform: cad.connected ? cad.getPlatform() : null,
         cadVersion: cad.connected ? cad.getVersion() : null
@@ -18668,7 +19597,7 @@ function createWebSocketServer(httpServer) {
   startCadPolling();
   _wss = new WebSocketServer({ server: httpServer, path: "/ws" });
   _wss.on("connection", (ws, req) => {
-    const clientId = randomUUID6();
+    const clientId = randomUUID7();
     connectedClients.set(clientId, ws);
     log(`WebSocket connected: ${clientId} (${connectedClients.size} total) from ${req.socket.remoteAddress}`);
     sendWelcome(ws, clientId);
@@ -18753,9 +19682,9 @@ function createWebSocketServer(httpServer) {
 // src/plugin-loader.js
 init_logger();
 import fs15 from "fs";
-import path18 from "path";
-import os10 from "os";
-var PLUGIN_DIR = path18.join(os10.homedir(), ".atlisp", "mcp-plugins");
+import path19 from "path";
+import os11 from "os";
+var PLUGIN_DIR = path19.join(os11.homedir(), ".atlisp", "mcp-plugins");
 var loadedPlugins = [];
 var watchCallbacks = [];
 var watcher = null;
@@ -18780,7 +19709,7 @@ function clearModuleCache(pluginPath) {
   if (key) delete import.meta[key];
 }
 async function loadSinglePlugin(file) {
-  const pluginPath = path18.join(PLUGIN_DIR, file);
+  const pluginPath = path19.join(PLUGIN_DIR, file);
   clearModuleCache(pluginPath);
   try {
     const plugin = await import(`${pluginPath}?t=${Date.now()}`);
@@ -18830,7 +19759,7 @@ function startPluginWatcher() {
       if (!filename || !filename.endsWith(".js") || filename.startsWith("_")) return;
       const existingIndex = loadedPlugins.findIndex((p) => p.name === filename.replace(".js", "") || p._file === filename);
       if (eventType === "rename") {
-        const filePath = path18.join(PLUGIN_DIR, filename);
+        const filePath = path19.join(PLUGIN_DIR, filename);
         if (!fs15.existsSync(filePath)) {
           if (existingIndex !== -1) {
             loadedPlugins.splice(existingIndex, 1);
@@ -18870,19 +19799,104 @@ function stopPluginWatcher() {
 init_tool_registry();
 init_mcp_server_state();
 
+// src/health-reporter.js
+init_config();
+init_cad();
+init_cad_pool();
+init_mcp_server_state();
+init_subscription_manager();
+init_logger();
+import os12 from "os";
+var REPORT_URL = "https://atlisp.cn/api/mcp/health";
+var REPORT_INTERVAL = 3e4;
+var intervalHandle = null;
+function gatherHealth() {
+  let cadResponseTime = 0;
+  if (cad.connected) {
+    const t0 = Date.now();
+    try {
+      cad.ping();
+    } catch {
+    }
+    cadResponseTime = Date.now() - t0;
+  }
+  const memUsage = process.memoryUsage();
+  let sseCount = 0;
+  try {
+    sseCount = sessionManager?.count?.() || 0;
+  } catch {
+  }
+  return {
+    clientId: config_default.clientId || os12.hostname(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "ok",
+    cad: {
+      connected: cad.connected,
+      platform: cad.getPlatform ? cad.getPlatform() : null,
+      version: cad.getVersion ? cad.getVersion() : null,
+      responseTime: cadResponseTime,
+      commandQueueSize: cad._getQueueSize ? cad._getQueueSize() : 0,
+      restartCount: cad._getRestartCount ? cad._getRestartCount() : 0
+    },
+    system: {
+      uptime: process.uptime(),
+      memory: {
+        rss: Math.round(memUsage.rss / 1024 / 1024),
+        heapUsed: Math.round(memUsage.heapUsed / 1024 / 1024),
+        heapTotal: Math.round(memUsage.heapTotal / 1024 / 1024)
+      }
+    },
+    mcp: {
+      sessions: sessionServers.size,
+      sseSessions: sseCount
+    },
+    pool: pool ? {
+      total: pool.getStats().total,
+      active: pool.getStats().active,
+      instances: pool.getStats().instances
+    } : null
+  };
+}
+async function report() {
+  try {
+    const data = gatherHealth();
+    const res = await fetch(REPORT_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      error(`Health report failed: ${res.status}`);
+    }
+  } catch (e) {
+    error(`Health report error: ${e.message}`);
+  }
+}
+function startHealthReporter() {
+  report();
+  intervalHandle = setInterval(report, REPORT_INTERVAL);
+}
+function stopHealthReporter() {
+  if (intervalHandle) {
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+  }
+}
+
 // src/streamable-http.js
 init_logger();
 init_mcp_handlers();
 init_mcp_tools();
 import { StreamableHTTPServerTransport as StreamableHTTPServerTransport2 } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 var mcpServer = null;
 var streamableTransport = null;
 async function initStreamableHttpServer() {
   if (mcpServer) return;
-  mcpServer = createMcpServer({ tools: tools41, handleToolCall });
+  mcpServer = createMcpServer({ tools: tools43, handleToolCall });
   streamableTransport = new StreamableHTTPServerTransport2({
-    sessionIdGenerator: () => randomUUID7()
+    sessionIdGenerator: () => randomUUID8()
   });
   await mcpServer.connect(streamableTransport);
   streamableTransport.onerror = (err) => error(`Streamable HTTP transport error: ${err.message}`);
@@ -18931,9 +19945,9 @@ function setupStreamableHttpRoutes(app) {
 init_mcp_tools();
 init_function_handlers();
 init_constants();
-var __dirname7 = path19.dirname(fileURLToPath7(import.meta.url));
+var __dirname7 = path20.dirname(fileURLToPath8(import.meta.url));
 var require3 = createRequire2(import.meta.url);
-var { version: version2 } = require3(path19.join(__dirname7, "..", "package.json"));
+var { version: version2 } = require3(path20.join(__dirname7, "..", "package.json"));
 var isMcpScript = process.argv[1]?.includes("atlisp-mcp");
 if (isMcpScript) {
   const cliArgs2 = process.argv.slice(2);
@@ -18967,6 +19981,7 @@ Options:
   --no-lint                    Disable lint pre-check for eval_lisp
   --lint-off                   Same as --no-lint
   --api-key <key>              API key for authentication
+  --client-id <id>             Client identifier for remote health report
   --security-level <type>      Security level: strict, standard, relaxed (default: strict)
 
 Environment Variables:
@@ -18987,7 +20002,8 @@ Environment Variables:
   LINT_LEVEL            Lint level (error/warn/off)
   NO_LINT               Disable lint (true/false)
   REQUEST_LOG_ENABLED   Enable request logging (true/false, default: true)
-  CORS_ORIGIN           CORS origin (default: *)
+  CORS_ORIGIN           CORS origin (default: https://atlisp.cn)
+  CLIENT_ID             Client identifier for remote health report
   RATE_LIMIT_WINDOW     Rate limit window in ms (default: 60000)
   RATE_LIMIT_MAX        Max requests per window (default: 100)
 
@@ -19043,6 +20059,8 @@ For more info: https://atlisp.cn
       process.env.SSL_CERT_PATH = cliArgs2[++i];
     } else if (arg === "--api-key" && cliArgs2[i + 1]) {
       process.env.MCP_API_KEY = cliArgs2[++i];
+    } else if (arg === "--client-id" && cliArgs2[i + 1]) {
+      process.env.CLIENT_ID = cliArgs2[++i];
     } else if (arg === "--metrics-enabled" && cliArgs2[i + 1]) {
       process.env.METRICS_ENABLED = cliArgs2[++i];
     }
@@ -19065,7 +20083,7 @@ async function initCadConnection() {
 }
 async function startServer() {
   await loadPlugins();
-  initPlugins({ cad, config: config_default, log, registerTool, tools: tools41 });
+  initPlugins({ cad, config: config_default, log, registerTool, tools: tools43 });
   onPluginChange((type, name) => {
     log(`Plugin changed: ${type} ${name}`);
     broadcastToolListChanged();
@@ -19075,7 +20093,7 @@ async function startServer() {
   startPluginWatcher();
   let promptsWatcher = null;
   try {
-    const promptsDir = path19.join(__dirname7, "..", "prompts");
+    const promptsDir = path20.join(__dirname7, "..", "prompts");
     if (fs16.existsSync(promptsDir)) {
       promptsWatcher = fs16.watch(promptsDir, (eventType, filename) => {
         if (filename && filename.endsWith(".json")) {
@@ -19089,7 +20107,7 @@ async function startServer() {
   }
   if (config_default.transport === "stdio") {
     await initCadConnection();
-    const mcpServer2 = createStdioServer({ tools: tools41, handleToolCall });
+    const mcpServer2 = createStdioServer({ tools: tools43, handleToolCall });
     const transport = new StdioServerTransport();
     const sessionId = "stdio-session";
     sessionManager.createSession(sessionId);
@@ -19137,10 +20155,12 @@ async function startServer() {
       const proto = useSsl ? "https" : "http";
       const mode = config_default.transport === "ws" ? "WebSocket" : config_default.transport === "streamable-http" ? "Streamable HTTP" : "\u591A\u4F1A\u8BDD";
       console.error(`@lisp MCP Server \u542F\u52A8 - ${proto}://${config_default.host}:${config_default.port} (${mode}\u6A21\u5F0F)`);
+      startHealthReporter();
     });
     async function shutdown(signal) {
       console.error(`
 \u6536\u5230 ${signal}\uFF0C\u6B63\u5728\u4F18\u96C5\u5173\u95ED...`);
+      stopHealthReporter();
       stopPluginWatcher();
       if (promptsWatcher) {
         promptsWatcher.close();
@@ -19190,5 +20210,5 @@ export {
   handleToolCall,
   loadAtlibFunctionLib,
   startServer,
-  tools41 as tools
+  tools43 as tools
 };