@defai.digital/automatosx 11.3.1 → 11.3.2

package/dist/mcp/index.js

@@ -3,6 +3,7 @@ import * as path4 from 'path';
 import path4__default, { dirname, join, extname as extname$1, basename, resolve, relative, isAbsolute, sep, parse, delimiter } from 'path';
 import { fileURLToPath } from 'url';
 import { mkdir, appendFile, readFile, readdir, writeFile, rename, unlink, copyFile, access, stat, realpath } from 'fs/promises';
+import * as fs3 from 'fs';
 import { existsSync, readFileSync, promises, mkdirSync, createWriteStream, writeFileSync, unlinkSync, constants } from 'fs';
 import Database2 from 'better-sqlite3';
 import { glob } from 'glob';
@@ -23,9 +24,7 @@ import { randomUUID } from 'crypto';
 import yaml from 'yaml';
 
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -39,15 +38,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var init_esm_shims = __esm({
   "node_modules/tsup/assets/esm_shims.js"() {
   }
@@ -328,16 +318,16 @@ var init_errors = __esm({
       constructor(message, code = "E1001" /* CONFIG_INVALID */, suggestions = [], context) {
         super(message, code, suggestions, context);
       }
-      static notFound(path5) {
+      static notFound(path6) {
         return new _ConfigError(
-          `Configuration file not found: ${path5}`,
+          `Configuration file not found: ${path6}`,
           "E1000" /* CONFIG_NOT_FOUND */,
           [
             'Run "automatosx setup" to create a new configuration',
             "Specify a custom config path with --config option",
             "Check that you are in a valid AutomatosX project directory"
           ],
-          { path: path5 }
+          { path: path6 }
         );
       }
       static invalid(reason, context) {
@@ -352,7 +342,7 @@ var init_errors = __esm({
           context
         );
       }
-      static parseError(error, path5) {
+      static parseError(error, path6) {
         return new _ConfigError(
           `Failed to parse configuration: ${error.message}`,
           "E1002" /* CONFIG_PARSE_ERROR */,
@@ -361,7 +351,7 @@ var init_errors = __esm({
             "Use a JSON validator to find syntax errors",
             'Reset to default with "automatosx setup --force"'
           ],
-          { path: path5, originalError: error.message }
+          { path: path6, originalError: error.message }
         );
       }
     };
@@ -1174,11 +1164,11 @@ var init_workspace_indexer = __esm({
       /**
        * Detect file type and language
        */
-      detectTypeAndLanguage(path5, ext) {
-        if (path5.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
+      detectTypeAndLanguage(path6, ext) {
+        if (path6.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
           return { type: "config", language: "json" };
         }
-        if (path5.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path5.includes("__tests__")) {
+        if (path6.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path6.includes("__tests__")) {
           const lang = LANGUAGE_MAP[ext];
           return { type: "test", language: lang };
         }
@@ -1195,15 +1185,15 @@ var init_workspace_indexer = __esm({
        *
        * Higher score = more likely to be relevant
        */
-      calculateImportance(path5, type, size) {
+      calculateImportance(path6, type, size) {
         let score = 0.5;
-        if (path5.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
-        if (path5.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
-        if (path5.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
+        if (path6.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
+        if (path6.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
+        if (path6.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
         if (type === "config") score = 0.85;
-        if (path5.includes("/core/")) score += 0.15;
-        if (path5.includes("/types/")) score += 0.1;
-        if (path5.includes("/utils/")) score += 0.05;
+        if (path6.includes("/core/")) score += 0.15;
+        if (path6.includes("/types/")) score += 0.1;
+        if (path6.includes("/utils/")) score += 0.05;
         if (type === "test") score = Math.max(0.3, score - 0.3);
         if (type === "doc") score = Math.max(0.4, score - 0.2);
         if (size > 1e4) score += 0.05;
@@ -1679,10 +1669,10 @@ function findOnPathUnix(cmdBase) {
   try {
     const which = spawnSync("which", [cmdBase], { timeout: 3e3 });
     if (which.status === 0) {
-      const path5 = which.stdout.toString().trim();
-      if (path5) {
-        logger.debug("Found via which", { cmdBase, path: path5 });
-        return { found: true, path: path5 };
+      const path6 = which.stdout.toString().trim();
+      if (path6) {
+        logger.debug("Found via which", { cmdBase, path: path6 });
+        return { found: true, path: path6 };
       }
     }
   } catch (error) {
@@ -1981,15 +1971,6 @@ var init_streaming_progress_parser = __esm({
 });
 
 // src/providers/error-patterns.ts
-var error_patterns_exports = {};
-__export(error_patterns_exports, {
-  GENERIC_ERROR_PATTERNS: () => GENERIC_ERROR_PATTERNS,
-  PROVIDER_ERROR_PATTERNS: () => PROVIDER_ERROR_PATTERNS,
-  getProviderErrorPatterns: () => getProviderErrorPatterns,
-  isLimitError: () => isLimitError,
-  isQuotaError: () => isQuotaError,
-  isRateLimitError: () => isRateLimitError
-});
 function isQuotaError(error, providerName) {
   const patterns = PROVIDER_ERROR_PATTERNS[providerName] || GENERIC_ERROR_PATTERNS;
   const message = (error?.message || "").toLowerCase();
@@ -2031,9 +2012,6 @@ function isRateLimitError(error, providerName) {
 function isLimitError(error, providerName) {
   return isQuotaError(error, providerName) || isRateLimitError(error, providerName);
 }
-function getProviderErrorPatterns(providerName) {
-  return PROVIDER_ERROR_PATTERNS[providerName] || GENERIC_ERROR_PATTERNS;
-}
 var PROVIDER_ERROR_PATTERNS, GENERIC_ERROR_PATTERNS;
 var init_error_patterns = __esm({
   "src/providers/error-patterns.ts"() {
@@ -2254,6 +2232,7 @@ var init_base_provider = __esm({
     init_provider_schemas();
     init_streaming_progress_parser();
     init_verbosity_manager();
+    init_error_patterns();
     BaseProvider = class _BaseProvider {
       /**
        * Whitelist of allowed provider names for security
@@ -2286,6 +2265,10 @@ var init_base_provider = __esm({
         NO_UPDATE_NOTIFIER: "1",
         DEBIAN_FRONTEND: "noninteractive"
       };
+      /** Default CLI execution timeout in milliseconds */
+      static DEFAULT_TIMEOUT_MS = 12e4;
+      /** Time to wait after SIGTERM before escalating to SIGKILL */
+      static SIGKILL_ESCALATION_MS = 5e3;
       config;
       logger = logger;
       health;
@@ -2343,7 +2326,7 @@ var init_base_provider = __esm({
             useStdin,
             streaming: process.env.AUTOMATOSX_SHOW_PROVIDER_OUTPUT === "true"
           });
-          const result = useStdin ? await this.executeWithStdin(cliCommand, argsString.trim(), prompt) : await this.executeWithSpawn(fullCommand, cliCommand);
+          const result = useStdin ? await this.executeWithStdin(cliCommand, cliArgs, prompt) : await this.executeWithSpawn(fullCommand, cliCommand);
           if (!result.stdout) {
             throw new Error(`${cliCommand} CLI returned empty output. stderr: ${result.stderr || "none"}`);
           }
@@ -2365,8 +2348,8 @@ var init_base_provider = __esm({
       /**
        * Execute command using spawn() with streaming support (v8.4.18)
        *
-       * Replaces execWithCleanup to support real-time line-by-line output streaming.
-       * Maintains all timeout and cleanup behaviors from execWithCleanup.
+       * Supports real-time line-by-line output streaming with proper timeout
+       * and cleanup behaviors (SIGTERM → SIGKILL escalation pattern).
        *
        * @param command - Full command string to execute
        * @param cliCommand - CLI command name (for logging)
@@ -2377,7 +2360,7 @@ var init_base_provider = __esm({
           const child = spawn(command, [], {
             shell: true,
             // Auto-detects: cmd.exe on Windows, /bin/sh on Unix
-            timeout: this.config.timeout || 12e4,
+            timeout: this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS,
             env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
@@ -2488,7 +2471,7 @@ var init_base_provider = __esm({
             });
             reject(new Error(`Failed to spawn ${cliCommand} CLI: ${error.message}`));
           });
-          const timeout = this.config.timeout || 12e4;
+          const timeout = this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS;
           timeoutId = setTimeout(() => {
             if (child.pid && !child.killed) {
               logger.warn("Killing child process due to timeout", {
@@ -2502,7 +2485,7 @@ var init_base_provider = __esm({
                   logger.warn("Force killing child process", { pid: child.pid });
                   child.kill("SIGKILL");
                 }
-              }, 5e3);
+              }, _BaseProvider.SIGKILL_ESCALATION_MS);
             }
           }, timeout);
         });
@@ -2520,14 +2503,13 @@ var init_base_provider = __esm({
        */
       async executeWithStdin(cliCommand, cliArgs, prompt) {
         return new Promise((resolve5, reject) => {
-          const commandArgs = cliArgs ? cliArgs.split(" ").filter(Boolean) : [];
           logger.debug(`Executing ${cliCommand} CLI with stdin`, {
             command: cliCommand,
-            args: commandArgs,
+            args: cliArgs,
             promptLength: prompt.length
           });
-          const child = spawn(cliCommand, commandArgs, {
-            timeout: this.config.timeout || 12e4,
+          const child = spawn(cliCommand, cliArgs, {
+            timeout: this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS,
             env: { ...process.env, ..._BaseProvider.NON_INTERACTIVE_ENV }
           });
           let stdout = "";
@@ -2663,7 +2645,7 @@ var init_base_provider = __esm({
             });
             reject(new Error(`Failed to spawn ${cliCommand} CLI: ${error.message}`));
           });
-          const timeout = this.config.timeout || 12e4;
+          const timeout = this.config.timeout || _BaseProvider.DEFAULT_TIMEOUT_MS;
           timeoutId = setTimeout(() => {
             if (child.pid && !child.killed) {
               logger.warn("Killing child process due to timeout", {
@@ -2677,7 +2659,7 @@ var init_base_provider = __esm({
                   logger.warn("Force killing child process", { pid: child.pid });
                   child.kill("SIGKILL");
                 }
-              }, 5e3);
+              }, _BaseProvider.SIGKILL_ESCALATION_MS);
             }
           }, timeout);
         });
@@ -2743,9 +2725,7 @@ var init_base_provider = __esm({
 ${request.prompt}`;
           }
           if (process.env.AUTOMATOSX_DEBUG_PROMPT === "true") {
-            const fs3 = await import('fs');
-            const path5 = await import('path');
-            const debugPath = path5.join(process.cwd(), "automatosx/tmp/debug-prompt.txt");
+            const debugPath = path4.join(process.cwd(), "automatosx/tmp/debug-prompt.txt");
             fs3.writeFileSync(debugPath, `=== FULL PROMPT SENT TO ${this.getCLICommand()} ===
 
 ${fullPrompt}
@@ -2869,26 +2849,16 @@ ${fullPrompt}
        * @returns true if this is a rate limit or quota error
        */
       detectRateLimitError(error) {
-        const { isLimitError: isLimitError2 } = (init_error_patterns(), __toCommonJS(error_patterns_exports));
-        try {
-          const isLimited = isLimitError2(error, this.config.name);
-          if (isLimited) {
-            this.logger.debug("Rate limit error detected", {
-              provider: this.config.name,
-              message: error?.message,
-              code: error?.code,
-              status: error?.status || error?.statusCode
-            });
-          }
-          return isLimited;
-        } catch (detectionError) {
-          this.logger.warn("Rate limit detection failed, using fallback", {
+        const isLimited = isLimitError(error, this.config.name);
+        if (isLimited) {
+          this.logger.debug("Rate limit error detected", {
             provider: this.config.name,
-            error: detectionError
+            message: error?.message,
+            code: error?.code,
+            status: error?.status || error?.statusCode
           });
-          const message = (error?.message || "").toLowerCase();
-          return message.includes("rate limit") || message.includes("quota") || message.includes("resource_exhausted") || message.includes("too many requests");
         }
+        return isLimited;
       }
       /**
        * Escape shell command arguments to prevent injection
@@ -4578,11 +4548,11 @@ var VALIDATION_LIMITS = {
   MAX_PORT: 65535
   // Maximum port number
 };
-function isValidRelativePath(path5) {
-  if (!path5 || typeof path5 !== "string") {
+function isValidRelativePath(path6) {
+  if (!path6 || typeof path6 !== "string") {
     return false;
   }
-  const normalizedPath = path5.replace(/\\/g, "/");
+  const normalizedPath = path6.replace(/\\/g, "/");
   if (normalizedPath.startsWith("/")) {
     return false;
   }
@@ -5212,11 +5182,16 @@ var PRECOMPILED_CONFIG = {
   },
   "advanced": {
     "embedding": {
+      "model": "text-embedding-3-small",
       "timeout": 3e4,
       "retryDelay": 1e3,
       "dimensions": 1536,
       "maxRetries": 3
     },
+    "projectContext": {
+      "maxSizeBytes": 102400,
+      "cacheTtlMs": 3e5
+    },
     "security": {
       "enablePathValidation": true,
       "allowedExtensions": [
@@ -5272,7 +5247,23 @@ var PRECOMPILED_CONFIG = {
     "enableFreeTierPrioritization": true,
     "enableWorkloadAwareRouting": true
   },
-  "version": "11.3.1"
+  "axCliSdk": {
+    "maxToolRounds": 400,
+    "checkpoint": {
+      "maxCheckpoints": 10,
+      "flushTimeoutMs": 5e3
+    },
+    "subagent": {
+      "maxParallel": 4,
+      "timeoutMs": 3e5,
+      "maxToolRounds": 100
+    },
+    "instructions": {
+      "cacheTtlMs": 3e5,
+      "maxContextLength": 32e3
+    }
+  },
+  "version": "11.3.2"
 };
 
 // src/core/config/schemas.ts
@@ -5299,7 +5290,7 @@ var safeNameSchema = z.string().min(1).max(VALIDATION_LIMITS.MAX_NAME_LENGTH).re
   "Name must be alphanumeric with dash/underscore only"
 ).describe("Safe identifier name");
 var relativePathSchema = z.string().min(1).refine(
-  (path5) => !path5.includes("..") && !path5.startsWith("/"),
+  (path6) => !path6.includes("..") && !path6.startsWith("/"),
   "Path must be relative (no ../, no absolute paths)"
 ).describe("Relative path within project");
 var fileExtensionSchema = z.string().regex(
@@ -5639,16 +5630,16 @@ async function loadConfigUncached(projectDir) {
   });
   return config;
 }
-async function loadConfigFile(path5) {
+async function loadConfigFile(path6) {
   try {
-    const content = await readFile(path5, "utf-8");
+    const content = await readFile(path6, "utf-8");
     if (content.length > VALIDATION_LIMITS.MAX_CONFIG_FILE_SIZE) {
       throw ConfigError.parseError(
         new Error(`Config file too large (max ${VALIDATION_LIMITS.MAX_CONFIG_FILE_SIZE / 1024}KB, got ${Math.ceil(content.length / 1024)}KB)`),
-        path5
+        path6
       );
     }
-    const ext = extname(path5).toLowerCase();
+    const ext = extname(path6).toLowerCase();
     let userConfig;
     try {
       if (ext === ".yaml" || ext === ".yml") {
@@ -5657,7 +5648,7 @@ async function loadConfigFile(path5) {
         userConfig = JSON.parse(content);
       }
     } catch (parseError) {
-      throw ConfigError.parseError(parseError, path5);
+      throw ConfigError.parseError(parseError, path6);
     }
     const config = mergeConfig(DEFAULT_CONFIG, userConfig);
     if (config.execution && userConfig.execution?.maxConcurrentAgents === void 0) {
@@ -5673,35 +5664,35 @@ async function loadConfigFile(path5) {
     if (validationErrors.length > 0) {
       throw ConfigError.invalid(
         validationErrors.join("; "),
-        { path: path5, errors: validationErrors }
+        { path: path6, errors: validationErrors }
       );
     }
-    logger.info("Config loaded successfully", { path: normalizePath(path5), format: ext });
+    logger.info("Config loaded successfully", { path: normalizePath(path6), format: ext });
     return config;
   } catch (error) {
     if (error instanceof ConfigError) {
       throw error;
     }
     if (error.code === "ENOENT") {
-      throw ConfigError.notFound(path5);
+      throw ConfigError.notFound(path6);
     }
     if (error.code === "EACCES") {
       throw new ConfigError(
-        `Permission denied reading config: ${path5}`,
+        `Permission denied reading config: ${path6}`,
         "E1002" /* CONFIG_PARSE_ERROR */,
         [
           "Check file permissions",
           "Run with appropriate user privileges",
           "Verify the file is accessible"
         ],
-        { path: path5, error: error.message }
+        { path: path6, error: error.message }
       );
     }
     throw new ConfigError(
       `Failed to load config: ${error.message}`,
       "E1002" /* CONFIG_PARSE_ERROR */,
       ["Check file format and permissions"],
-      { path: path5, originalError: error.message }
+      { path: path6, originalError: error.message }
     );
   }
 }
@@ -5717,8 +5708,8 @@ function validateConfigWithZod(config) {
     return ["Configuration validation failed with unknown error structure"];
   }
   return result.error.issues.map((err) => {
-    const path5 = err.path.join(".");
-    return `${path5}: ${err.message}`;
+    const path6 = err.path.join(".");
+    return `${path6}: ${err.message}`;
   });
 }
 function validateConfig(config) {
@@ -6128,8 +6119,8 @@ var PathError = class extends Error {
 };
 
 // src/shared/validation/path-resolver.ts
-function isWindowsPath(path5) {
-  return /^[a-zA-Z]:[/\\]/.test(path5);
+function isWindowsPath(path6) {
+  return /^[a-zA-Z]:[/\\]/.test(path6);
 }
 async function detectProjectRoot(startDir = process.cwd()) {
   if (process.env.AUTOMATOSX_PROJECT_ROOT) {
@@ -6229,8 +6220,8 @@ var PathResolver = class {
   /**
    * Validate path is within allowed base directory
    */
-  validatePath(path5, baseDir) {
-    const normalized = normalizePath(resolvePath(path5));
+  validatePath(path6, baseDir) {
+    const normalized = normalizePath(resolvePath(path6));
     const base = normalizePath(resolvePath(baseDir));
     const separator = "/";
     const pathWithSep = normalized + separator;
@@ -6240,15 +6231,15 @@ var PathResolver = class {
   /**
    * Check if path is within allowed boundaries
    */
-  isPathAllowed(path5) {
-    const boundary = this.checkBoundaries(path5);
+  isPathAllowed(path6) {
+    const boundary = this.checkBoundaries(path6);
     return boundary === "agent_workspace" || boundary === "user_project";
   }
   /**
    * Check which boundary a path belongs to
    */
-  checkBoundaries(path5) {
-    const normalized = resolvePath(path5);
+  checkBoundaries(path6) {
+    const normalized = resolvePath(path6);
     if (this.validatePath(normalized, this.config.agentWorkspace)) {
       return "agent_workspace";
     }
@@ -6266,15 +6257,15 @@ var PathResolver = class {
   /**
    * Get relative path from project root
    */
-  getRelativeToProject(path5) {
-    const normalized = resolvePath(path5);
+  getRelativeToProject(path6) {
+    const normalized = resolvePath(path6);
     return normalizePath(getRelativePath(this.config.projectDir, normalized));
   }
   /**
    * Get relative path from working directory
    */
-  getRelativeToWorking(path5) {
-    const normalized = resolvePath(path5);
+  getRelativeToWorking(path6) {
+    const normalized = resolvePath(path6);
     return normalizePath(getRelativePath(this.config.workingDir, normalized));
   }
   /**
@@ -6293,11 +6284,11 @@ var PathResolver = class {
    * Validate path is within project boundaries
    * @throws PathError if outside project
    */
-  validateInProject(path5) {
-    const boundary = this.checkBoundaries(path5);
+  validateInProject(path6) {
+    const boundary = this.checkBoundaries(path6);
     if (boundary === "outside_boundaries" || boundary === "system_restricted") {
       throw new PathError("Path outside project directory", {
-        path: path5,
+        path: path6,
         projectDir: this.config.projectDir,
         boundary
       });
@@ -8164,18 +8155,18 @@ var ProviderSessionManager = class {
 };
 var providerSessionInstances = /* @__PURE__ */ new Map();
 async function getProviderSession(workspacePath) {
-  let path5;
+  let path6;
   {
     if (process.env.NODE_ENV === "test" || process.env.VITEST) {
-      path5 = process.cwd();
+      path6 = process.cwd();
     } else {
-      path5 = await detectProjectRoot();
+      path6 = await detectProjectRoot();
     }
   }
-  if (!providerSessionInstances.has(path5)) {
-    providerSessionInstances.set(path5, new ProviderSessionManager(path5));
+  if (!providerSessionInstances.has(path6)) {
+    providerSessionInstances.set(path6, new ProviderSessionManager(path6));
   }
-  return providerSessionInstances.get(path5);
+  return providerSessionInstances.get(path6);
 }
 
 // src/core/router/router.ts
@@ -9944,6 +9935,9 @@ var MemoryManager = class _MemoryManager {
         if (!Number.isInteger(offsetValue) || offsetValue < 0) {
           throw new Error(`Invalid offset value: ${options.offset}. Must be a non-negative integer.`);
         }
+        if (!limitClause) {
+          limitClause = "LIMIT -1";
+        }
         offsetClause = `OFFSET ${offsetValue}`;
       }
       const sql = `
@@ -10297,6 +10291,13 @@ var MemoryManager = class _MemoryManager {
       await this.initialize();
       logger.info("Database restored successfully (atomic operation)", { srcPath: normalizePath(srcPath) });
     } catch (error) {
+      try {
+        DatabaseFactory.close(this.db);
+      } finally {
+        this.initialized = false;
+        this.entryCount = 0;
+        this.statements = {};
+      }
       throw new MemoryError(
         `Failed to restore database: ${error.message}`,
         "DATABASE_ERROR",
@@ -10846,6 +10847,10 @@ var SessionManager = class _SessionManager {
   MAX_TASKS_PER_SESSION = 1e3;
   /** UUID v4 validation regex (static for performance) */
   static UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  /** Tracks whether manager has been destroyed to prevent late saves */
+  destroyed = false;
+  /** Last persistence error (reported during flush) */
+  lastSaveError;
   /**
    * Validate session ID format (must be valid UUID v4)
    *
@@ -11440,6 +11445,7 @@ var SessionManager = class _SessionManager {
    * ```
    */
   async destroy() {
+    this.destroyed = true;
     if (this.saveTimeout) {
       clearTimeout(this.saveTimeout);
       this.saveTimeout = void 0;
@@ -11450,9 +11456,12 @@ var SessionManager = class _SessionManager {
       logger.error("Error flushing save during destroy", {
         error: error.message
       });
+      this.lastSaveError = void 0;
     }
+    const sessionCount = this.activeSessions.size;
+    this.activeSessions.clear();
     logger.debug("SessionManager destroyed", {
-      sessions: this.activeSessions.size
+      sessions: sessionCount
     });
   }
   /**
@@ -11477,11 +11486,21 @@ var SessionManager = class _SessionManager {
         this.pendingSave = void 0;
       });
       await this.pendingSave;
+      if (this.lastSaveError) {
+        const err = this.lastSaveError;
+        this.lastSaveError = void 0;
+        throw err;
+      }
       return;
     }
     if (this.pendingSave) {
       try {
         await this.pendingSave;
+        if (this.lastSaveError) {
+          const err = this.lastSaveError;
+          this.lastSaveError = void 0;
+          throw err;
+        }
       } catch (err) {
         throw err;
       }
@@ -11646,7 +11665,7 @@ var SessionManager = class _SessionManager {
    * @private
    */
   saveToFile() {
-    if (!this.persistencePath) {
+    if (!this.persistencePath || this.destroyed) {
       return;
     }
     if (this.saveTimeout) {
@@ -11659,18 +11678,18 @@ var SessionManager = class _SessionManager {
       }
       this.saveNeeded = false;
       const executeNextSave = async () => {
-        await this.doSave();
+        try {
+          await this.doSave();
+          this.lastSaveError = void 0;
+        } catch (err) {
+          this.lastSaveError = err;
+        }
         if (this.saveNeeded) {
           this.saveNeeded = false;
           return executeNextSave();
         }
       };
-      this.pendingSave = executeNextSave().catch((err) => {
-        logger.error("Debounced save failed", {
-          error: err.message
-        });
-        throw err;
-      }).finally(() => {
+      this.pendingSave = executeNextSave().finally(() => {
         this.pendingSave = void 0;
       });
     }, 100);
@@ -15081,9 +15100,9 @@ var DependencyGraphBuilder = class {
   detectCycles(graph) {
     const visiting = /* @__PURE__ */ new Set();
     const visited = /* @__PURE__ */ new Set();
-    const visit = (nodeName, path5) => {
+    const visit = (nodeName, path6) => {
       if (visiting.has(nodeName)) {
-        throw new Error(`Circular dependency detected: ${[...path5, nodeName].join(" \u2192 ")}`);
+        throw new Error(`Circular dependency detected: ${[...path6, nodeName].join(" \u2192 ")}`);
       }
       if (visited.has(nodeName)) {
         return;
@@ -15098,7 +15117,7 @@ var DependencyGraphBuilder = class {
       }
       visiting.add(nodeName);
       for (const dependency of node.dependencies) {
-        visit(dependency, [...path5, nodeName]);
+        visit(dependency, [...path6, nodeName]);
       }
       visiting.delete(nodeName);
       visited.add(nodeName);
@@ -16831,59 +16850,59 @@ var DANGEROUS_PATH_PATTERNS = [
   // Common data drive (Windows, alt format)
 ];
 var SUSPICIOUS_PATH_CHARS = /[<>:|"]/;
-function validatePathParameter(path5, paramName, projectRoot = process.cwd()) {
-  if (!path5 || path5.trim() === "") {
+function validatePathParameter(path6, paramName, projectRoot = process.cwd()) {
+  if (!path6 || path6.trim() === "") {
     throw new ValidationError(
       `Invalid ${paramName}: path cannot be empty`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName }
+      { path: path6, paramName }
     );
   }
   for (const pattern of DANGEROUS_PATH_PATTERNS) {
-    if (path5.includes(pattern)) {
+    if (path6.includes(pattern)) {
       throw new ValidationError(
         `Invalid ${paramName}: path contains dangerous pattern "${pattern}"`,
         -32602 /* InvalidParams */,
-        { path: path5, paramName, pattern }
+        { path: path6, paramName, pattern }
       );
     }
   }
-  if (isAbsolute(path5)) {
+  if (isAbsolute(path6)) {
     throw new ValidationError(
       `Invalid ${paramName}: absolute paths are not allowed`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName }
+      { path: path6, paramName }
     );
   }
   try {
-    const resolvedPath = resolve(projectRoot, path5);
+    const resolvedPath = resolve(projectRoot, path6);
     const normalizedRoot = resolve(projectRoot);
     if (!resolvedPath.startsWith(normalizedRoot + sep) && resolvedPath !== normalizedRoot) {
       throw new ValidationError(
         `Invalid ${paramName}: path escapes project boundary`,
         -32602 /* InvalidParams */,
-        { path: path5, paramName, projectRoot, resolvedPath }
+        { path: path6, paramName, projectRoot, resolvedPath }
       );
     }
   } catch (error) {
     throw new ValidationError(
       `Invalid ${paramName}: path resolution failed`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName, error: String(error) }
+      { path: path6, paramName, error: String(error) }
     );
   }
-  if (path5.includes("\0")) {
+  if (path6.includes("\0")) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains null byte`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName }
+      { path: path6, paramName }
     );
   }
-  if (SUSPICIOUS_PATH_CHARS.test(path5)) {
+  if (SUSPICIOUS_PATH_CHARS.test(path6)) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains invalid characters`,
       -32602 /* InvalidParams */,
-      { path: path5, paramName }
+      { path: path6, paramName }
     );
   }
 }
@@ -17579,8 +17598,8 @@ function createMemoryExportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_export called", { input });
     try {
-      const { path: path5 } = input;
-      const absolutePath = resolveExportPath(deps.pathResolver, path5);
+      const { path: path6 } = input;
+      const absolutePath = resolveExportPath(deps.pathResolver, path6);
       const exported = await deps.memoryManager.exportToJSON(absolutePath);
       const result = {
         success: true,
@@ -17616,8 +17635,8 @@ function createMemoryImportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_import called", { input });
     try {
-      const { path: path5 } = input;
-      const absolutePath = resolveImportPath(deps.pathResolver, path5);
+      const { path: path6 } = input;
+      const absolutePath = resolveImportPath(deps.pathResolver, path6);
       const imported = await deps.memoryManager.importFromJSON(absolutePath);
       const result = {
         success: true,
@@ -18192,7 +18211,18 @@ var McpClient = class extends EventEmitter {
         timeout: timeoutHandle
       });
       const message = JSON.stringify(request) + "\n";
-      this.process.stdin.write(message);
+      try {
+        this.process.stdin.write(message);
+      } catch (error) {
+        const pending = this.pendingRequests.get(id);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.pendingRequests.delete(id);
+        }
+        const err = error instanceof Error ? error : new Error(String(error));
+        reject(err);
+        return;
+      }
       logger.debug("[MCP Client] Sent request", {
         id,
         method,