micro-models-agent 0.9.0 → 0.11.0

package/dist/main.js

@@ -2688,6 +2688,25 @@ var en_default = {
   "tool.screenshot_unavailable": "[Screenshot captured — image not available for text-only model]",
   "tool.timeout": "Tool {name} timed out after {seconds} seconds",
   "tool.interactive_disabled": "Interactive tool is disabled in exit-on-complete mode. Proceed without asking the user.",
+  "proc.started": `Started background process {id} (PID {pid}).
+Command: {command}`,
+  "proc.detected_hint": "[Long-running command detected — started in background]",
+  "proc.manage_hint": "Check output: process_log id={id}. Stop it: process_kill id={id}. List all: process_list.",
+  "proc.none": "No background processes running.",
+  "proc.not_found": "Process not found: {id}",
+  "proc.killed": "Process {id} (PID {pid}) killed.",
+  "proc.kill_failed": "Failed to kill process {id}",
+  "proc.list_header": "Background processes",
+  "proc.log_header": "Process {id} ({status}) output:",
+  "proc.log_empty": "(no output yet)",
+  "proc.timed_out": "Command timed out after {ms} ms and was killed.",
+  "proc.hint": "Manage them with {list}, {log}, {kill}.",
+  "proc.status_running": "running",
+  "proc.status_exited": "exited",
+  "proc.status_killed": "killed",
+  "tool.friendly.process_list": "Listing background processes",
+  "tool.friendly.process_log": "Process output",
+  "tool.friendly.process_kill": "Stopping process",
   "plan.created": "Plan created: {title} ({steps} steps)",
   "plan.step_done": "Step {n}/{total}: {description} ✓",
   "plan.complete": "Task complete: {summary}",
@@ -3118,6 +3137,25 @@ var ru_default = {
   "tool.screenshot_unavailable": "[Скриншот сделан — изображение недоступно для текстовой модели]",
   "tool.timeout": "Инструмент {name} превысил таймаут ({seconds} сек)",
   "tool.interactive_disabled": "Интерактивный инструмент отключён в режиме exit-on-complete. Продолжай без вопроса пользователю.",
+  "proc.started": `Фоновый процесс запущен: {id} (PID {pid}).
+Команда: {command}`,
+  "proc.detected_hint": "[Обнаружена длительная команда — запущена в фоне]",
+  "proc.manage_hint": "Проверить вывод: process_log id={id}. Остановить: process_kill id={id}. Список всех: process_list.",
+  "proc.none": "Фоновых процессов нет.",
+  "proc.not_found": "Процесс не найден: {id}",
+  "proc.killed": "Процесс {id} (PID {pid}) остановлен.",
+  "proc.kill_failed": "Не удалось остановить процесс {id}",
+  "proc.list_header": "Фоновые процессы",
+  "proc.log_header": "Вывод процесса {id} ({status}):",
+  "proc.log_empty": "(вывода пока нет)",
+  "proc.timed_out": "Команда превысила таймаут {ms} мс и была остановлена.",
+  "proc.hint": "Управление: {list}, {log}, {kill}.",
+  "proc.status_running": "работает",
+  "proc.status_exited": "завершён",
+  "proc.status_killed": "остановлен",
+  "tool.friendly.process_list": "Список фоновых процессов",
+  "tool.friendly.process_log": "Вывод процесса",
+  "tool.friendly.process_kill": "Остановка процесса",
   "plan.created": "План создан: {title} ({steps} шагов)",
   "plan.step_done": "Шаг {n}/{total}: {description} ✓",
   "plan.complete": "Задача выполнена: {summary}",
@@ -3448,7 +3486,7 @@ function t(key, params) {
     return key;
   if (params) {
     for (const [k, v] of Object.entries(params)) {
-      template = template.replace(`{${k}}`, String(v));
+      template = template.replaceAll(`{${k}}`, String(v));
     }
   }
   return template;
@@ -4791,6 +4829,101 @@ class ToolRegistry {
   }
 }
 
+// src/modules/processes/runner.ts
+import { spawn } from "child_process";
+import { platform } from "os";
+var activeChildren = new Map;
+function killByCallId(callId) {
+  const entry = activeChildren.get(callId);
+  if (!entry)
+    return false;
+  activeChildren.delete(callId);
+  try {
+    entry.kill();
+  } catch {}
+  return true;
+}
+function killTree(child) {
+  const pid = child.pid;
+  if (!pid)
+    return;
+  if (platform() === "win32") {
+    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+      windowsHide: true,
+      stdio: "ignore"
+    });
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+    try {
+      child.kill("SIGKILL");
+    } catch {}
+  }
+}
+function runCommand(command, options = {}) {
+  const {
+    cwd,
+    callId,
+    timeoutMs = 120000,
+    maxBuffer = 10 * 1024 * 1024
+  } = options;
+  return new Promise((resolve) => {
+    let timedOut = false;
+    let stdout = "";
+    let stderr = "";
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      windowsHide: true,
+      detached: platform() !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const append = (ref, chunk) => {
+      const text = chunk.toString();
+      const next = ref.value.length + text.length;
+      if (next > maxBuffer) {
+        ref.value = ref.value.slice(ref.value.length + text.length - maxBuffer) + text;
+      } else {
+        ref.value = ref.value + text;
+      }
+    };
+    const stdoutRef = { value: stdout };
+    const stderrRef = { value: stderr };
+    child.stdout?.on("data", (chunk) => append(stdoutRef, chunk));
+    child.stderr?.on("data", (chunk) => append(stderrRef, chunk));
+    const entry = {
+      kill: () => killTree(child)
+    };
+    if (callId) {
+      activeChildren.set(callId, entry);
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killTree(child);
+    }, timeoutMs);
+    child.on("error", () => {
+      clearTimeout(timer);
+      if (callId)
+        activeChildren.delete(callId);
+      resolve({
+        stdout: stdoutRef.value,
+        stderr: stderrRef.value,
+        code: null,
+        signal: null,
+        timedOut
+      });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      if (callId)
+        activeChildren.delete(callId);
+      resolve({ stdout: stdoutRef.value, stderr: stderrRef.value, code, signal, timedOut });
+    });
+  });
+}
+
 // src/tools/executor.ts
 var TOOL_EXECUTION_TIMEOUT_MS = 60000;
 
@@ -4832,14 +4965,18 @@ class ToolExecutor {
     }
     let result;
     try {
+      this.ctx.activeCallId = call.id;
       if (tool.interactive) {
         result = await tool.handler(this.ctx, call.arguments);
       } else {
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error(t("tool.timeout", {
-            name: call.name,
-            seconds: TOOL_EXECUTION_TIMEOUT_MS / 1000
-          }))), TOOL_EXECUTION_TIMEOUT_MS);
+          setTimeout(() => {
+            killByCallId(call.id);
+            reject(new Error(t("tool.timeout", {
+              name: call.name,
+              seconds: TOOL_EXECUTION_TIMEOUT_MS / 1000
+            })));
+          }, TOOL_EXECUTION_TIMEOUT_MS);
         });
         result = await Promise.race([
           tool.handler(this.ctx, call.arguments),
@@ -5889,10 +6026,6 @@ var fileInfoTool = {
   }
 };
 
-// src/tools/bash.ts
-import { execSync as execSync2 } from "child_process";
-import { platform } from "os";
-
 // src/modules/security/command-validator.ts
 var FALLBACK_BASH_CONFIG = {
   blacklist: ["rm", "dd", "chmod", "wget", "curl", "scp", "ssh", "nc", "netcat"],
@@ -5976,10 +6109,174 @@ function sanitizeCommandForLog(command) {
   }
   return sanitized;
 }
+// src/modules/processes/registry.ts
+import { spawn as spawn2 } from "child_process";
+import { platform as platform2 } from "os";
+var MAX_LOG_LINES = 300;
+var MAX_KEPT_PROCESSES = 20;
+var seq = 0;
+function killTree2(child) {
+  const pid = child.pid;
+  if (!pid)
+    return;
+  if (platform2() === "win32") {
+    spawn2("taskkill", ["/pid", String(pid), "/T", "/F"], {
+      windowsHide: true,
+      stdio: "ignore"
+    });
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+    try {
+      child.kill("SIGKILL");
+    } catch {}
+  }
+}
 
+class ProcessRegistry {
+  procs = new Map;
+  children = new Map;
+  start(command, cwd, sessionId) {
+    const id = `proc_${Date.now()}_${++seq}`;
+    const entry = {
+      id,
+      pid: 0,
+      command,
+      cwd,
+      sessionId,
+      status: "running",
+      exitCode: null,
+      startedAt: new Date().toISOString(),
+      log: []
+    };
+    this.trimOldEntries();
+    this.procs.set(id, entry);
+    const child = spawn2(command, {
+      cwd,
+      shell: true,
+      windowsHide: true,
+      detached: platform2() !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.children.set(id, child);
+    entry.pid = child.pid ?? 0;
+    let partial = "";
+    const append = (chunk) => {
+      const text = partial + chunk.toString();
+      const lines = text.split(/\r?\n/);
+      partial = lines.pop() ?? "";
+      for (const line of lines) {
+        if (entry.log.length >= MAX_LOG_LINES) {
+          entry.log.shift();
+        }
+        entry.log.push(line);
+      }
+    };
+    child.stdout?.on("data", append);
+    child.stderr?.on("data", append);
+    child.on("error", (err) => {
+      if (entry.status === "running") {
+        entry.status = "killed";
+      }
+      append(Buffer.from(`[process error] ${err.message}`));
+    });
+    child.on("close", (code) => {
+      if (entry.status === "running") {
+        entry.status = "exited";
+      }
+      entry.exitCode = code;
+      this.children.delete(id);
+      if (partial) {
+        entry.log.push(partial);
+        partial = "";
+      }
+    });
+    return entry;
+  }
+  list(sessionId) {
+    const all = Array.from(this.procs.values());
+    if (!sessionId)
+      return all;
+    return all.filter((p) => p.sessionId === sessionId);
+  }
+  get(id) {
+    return this.procs.get(id);
+  }
+  getLog(id, tail) {
+    const entry = this.procs.get(id);
+    if (!entry)
+      return "";
+    const lines = tail && tail > 0 ? entry.log.slice(-tail) : entry.log;
+    return lines.join(`
+`);
+  }
+  kill(id) {
+    const entry = this.procs.get(id);
+    if (!entry)
+      return false;
+    if (entry.status === "running") {
+      entry.status = "killed";
+      const child = this.children.get(id);
+      if (child) {
+        killTree2(child);
+      }
+    }
+    return true;
+  }
+  killAll(sessionId) {
+    const targets = this.list(sessionId);
+    for (const entry of targets) {
+      this.kill(entry.id);
+    }
+    return targets.length;
+  }
+  trimOldEntries() {
+    if (this.procs.size < MAX_KEPT_PROCESSES)
+      return;
+    const sorted = Array.from(this.procs.values()).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+    const toRemove = sorted.slice(0, sorted.length - MAX_KEPT_PROCESSES + 1);
+    for (const entry of toRemove) {
+      this.procs.delete(entry.id);
+      this.children.delete(entry.id);
+    }
+  }
+}
+var processRegistry = new ProcessRegistry;
+// src/modules/processes/detect.ts
+var LONG_RUNNING_PATTERNS = [
+  /\b(npm|pnpm|yarn|bun|npx)\s+(run\s+)?(dev|start|serve|preview|watch|server)\b/i,
+  /\b(deno|node)\s+.*\b(run\s+)?(dev|serve|watch|server)\b/i,
+  /(^|\s)--watch\b/i,
+  /(^|\s)-w\b/i,
+  /\bnodemon\b/i,
+  /\btsx watch\b/i,
+  /\b(ts-node|tsc)\s+.*--watch\b/i,
+  /\bvite(?!\s+(build|create))\b/i,
+  /\bwebpack(-dev-server|\s+serve)\b/i,
+  /\bastro dev\b/i,
+  /\bnext (dev|start)\b/i,
+  /\bnuxt (dev|start)\b/i,
+  /\bsvelte-kit (dev|preview)\b/i,
+  /\bgatsby develop\b/i,
+  /\bdocker(-compose)?\s+.*\bup\b/i,
+  /\buvicorn\b|\bgunicorn\b/i,
+  /\bpython\s+-m\s+http\.server\b/i,
+  /\bflask run\b/i,
+  /\bphp artisan serve\b/i,
+  /\brails (server|s)\b/i,
+  /\bvitest watch\b/i,
+  /\bjest --watch\b/i
+];
+function isLongRunningCommand(command) {
+  return LONG_RUNNING_PATTERNS.some((pattern) => pattern.test(command));
+}
 // src/tools/bash.ts
+import { platform as platform3 } from "os";
+var BASH_TIMEOUT_MS = 120000;
 function adaptCommandForWindows(command) {
-  if (platform() !== "win32")
+  if (platform3() !== "win32")
     return command;
   const trimmed = command.trim();
   if (trimmed.startsWith("mkdir -p ")) {
@@ -5992,13 +6289,14 @@ function adaptCommandForWindows(command) {
 }
 var bashTool = {
   name: "bash",
-  description: "Execute a shell command and return its output. Use for running tests, build, git, and shell operations.",
+  description: "Execute a shell command and return its output. Use for running tests, build, git, and shell operations. Long-running commands (dev servers, watchers) start in the background and return a process id immediately — manage them with process_list, process_log, process_kill. Set background=true to force background execution.",
   tags: ["shell", "code"],
   parameters: {
     type: "object",
     properties: {
       command: { type: "string", description: "Shell command to execute" },
-      workdir: { type: "string", description: "Working directory (default: baseDir)" }
+      workdir: { type: "string", description: "Working directory (default: baseDir)" },
+      background: { type: "boolean", description: "Start the command in the background and return immediately with a process id (default: auto-detect long-running commands)" }
     },
     required: ["command"]
   },
@@ -6020,26 +6318,156 @@ var bashTool = {
     if (securityConfig?.logCommands) {
       logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, `Working directory: ${workdir}`);
     }
+    const background = args.background === true || isLongRunningCommand(command);
+    if (background) {
+      const entry = processRegistry.start(command, workdir, ctx.sessionId);
+      if (securityConfig?.logCommands) {
+        logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Started in background: ${entry.id} (PID ${entry.pid})`);
+      }
+      const explicit = args.background === true;
+      return {
+        success: true,
+        output: `${t("proc.started", {
+          id: entry.id,
+          pid: entry.pid,
+          command
+        })}${explicit ? "" : `
+${t("proc.detected_hint")}`}
+${t("proc.manage_hint", {
+          id: entry.id
+        })}`
+      };
+    }
     try {
-      const output = execSync2(command, {
+      const res = await runCommand(command, {
         cwd: workdir,
-        encoding: "utf-8",
-        maxBuffer: 10 * 1024 * 1024,
-        timeout: 120000
+        callId: ctx.activeCallId,
+        timeoutMs: BASH_TIMEOUT_MS
       });
+      const parts = [res.stdout.trimEnd(), res.stderr.trimEnd()].filter(Boolean);
+      let output = parts.join(`
+`);
+      if (res.timedOut) {
+        output = `${output ? output + `
+` : ""}${t("proc.timed_out", {
+          ms: BASH_TIMEOUT_MS
+        })}`;
+      } else if (!output && res.code !== 0) {
+        output = `(exit code ${res.code})`;
+      }
       if (securityConfig?.logCommands) {
-        logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Working directory: ${workdir}, Output length: ${output.length}`);
+        logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), res.code === 0, `Working directory: ${workdir}, Output length: ${res.stdout.length}`);
       }
-      return { success: true, output: output.trimEnd() };
+      return { success: res.code === 0, output };
     } catch (e) {
-      const stderr = e.stderr?.toString() || "";
-      const stdout = e.stdout?.toString() || "";
-      const errorOutput = stderr || stdout || e.message;
       if (securityConfig?.logCommands) {
-        logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, `Working directory: ${workdir}, Error: ${errorOutput.slice(0, 100)}`);
+        logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, `Working directory: ${workdir}, Error: ${e.message?.slice(0, 100) || ""}`);
       }
-      return { success: false, output: errorOutput };
+      return { success: false, output: e.message || String(e) };
+    }
+  }
+};
+
+// src/tools/process-list.ts
+var processListTool = {
+  name: "process_list",
+  description: "List background processes started via the bash tool (dev servers, watchers, long-running commands). Shows id, pid, command, status, and recent output. Use with process_log and process_kill to inspect or stop them.",
+  tags: ["shell"],
+  parameters: {
+    type: "object",
+    properties: {}
+  },
+  handler: async (ctx) => {
+    const list = processRegistry.list(ctx.sessionId);
+    if (list.length === 0) {
+      return { success: true, output: t("proc.none") };
+    }
+    const statusLabel = (status) => {
+      if (status === "running")
+        return t("proc.status_running");
+      if (status === "exited")
+        return t("proc.status_exited");
+      return t("proc.status_killed");
+    };
+    const lines = [`${t("proc.list_header")} (${list.length}):`];
+    for (const entry of list) {
+      const tail = entry.log.length > 0 ? entry.log[entry.log.length - 1] : "";
+      const detail = tail ? ` — ${tail.slice(0, 80)}${tail.length > 80 ? "…" : ""}` : "";
+      lines.push(`  ${entry.id}  PID ${entry.pid}  ${statusLabel(entry.status)}  ${entry.command}${detail}`);
+    }
+    lines.push(`
+${t("proc.hint", {
+      list: "process_list",
+      log: "process_log",
+      kill: "process_kill"
+    })}`);
+    return { success: true, output: lines.join(`
+`) };
+  }
+};
+
+// src/tools/process-log.ts
+var processLogTool = {
+  name: "process_log",
+  description: "Show the buffered output of a background process started via bash. Use after starting a dev server to verify it came up without errors, and while it runs to check its state.",
+  tags: ["shell"],
+  parameters: {
+    type: "object",
+    properties: {
+      id: { type: "string", description: "Process id from bash output or process_list" },
+      tail: { type: "number", description: "Number of trailing lines to show (default: all buffered lines, max 300)" }
+    },
+    required: ["id"]
+  },
+  handler: async (ctx, args) => {
+    const id = String(args.id);
+    const entry = processRegistry.get(id);
+    if (!entry) {
+      return { success: false, output: t("proc.not_found", { id }) };
+    }
+    const status = entry.status === "running" ? t("proc.status_running") : entry.status === "exited" ? t("proc.status_exited") : t("proc.status_killed");
+    const tail = typeof args.tail === "number" ? args.tail : undefined;
+    const log = processRegistry.getLog(id, tail);
+    if (!log) {
+      return {
+        success: true,
+        output: `${t("proc.log_header", { id, status })} ${t("proc.log_empty")}`
+      };
+    }
+    return {
+      success: true,
+      output: `${t("proc.log_header", { id, status })}
+${log}`
+    };
+  }
+};
+
+// src/tools/process-kill.ts
+var processKillTool = {
+  name: "process_kill",
+  description: "Stop a background process started via bash (dev server, watcher). Kills the whole process tree (children included). Use the id returned by bash or process_list.",
+  tags: ["shell"],
+  parameters: {
+    type: "object",
+    properties: {
+      id: { type: "string", description: "Process id from bash output or process_list" }
+    },
+    required: ["id"]
+  },
+  handler: async (ctx, args) => {
+    const id = String(args.id);
+    const entry = processRegistry.get(id);
+    if (!entry) {
+      return { success: false, output: t("proc.not_found", { id }) };
+    }
+    const killed = processRegistry.kill(id);
+    if (!killed) {
+      return { success: false, output: t("proc.kill_failed", { id }) };
     }
+    return {
+      success: true,
+      output: t("proc.killed", { id, pid: entry.pid })
+    };
   }
 };
 
@@ -7429,7 +7857,7 @@ class MoEExecutor {
 // src/modules/execution/verifier.ts
 import { existsSync as existsSync16 } from "fs";
 import { resolve as resolve13, extname as extname2 } from "path";
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync2 } from "child_process";
 class StepVerifier {
   baseDir;
   constructor(baseDir) {
@@ -7445,7 +7873,7 @@ class StepVerifier {
   }
   async runScript(scriptName) {
     try {
-      execSync3(`bun run ${scriptName}`, {
+      execSync2(`bun run ${scriptName}`, {
         cwd: this.baseDir,
         encoding: "utf-8",
         timeout: 60000,
@@ -7462,7 +7890,7 @@ class StepVerifier {
       return { passed: true, message: "No tsconfig.json found — skipping type check" };
     }
     try {
-      execSync3("npx tsc --noEmit", {
+      execSync2("npx tsc --noEmit", {
         cwd: this.baseDir,
         encoding: "utf-8",
         timeout: 60000,
@@ -7545,7 +7973,7 @@ class StepVerifier {
     const ext = extname2(filePath);
     if (ext === ".ts" || ext === ".tsx") {
       try {
-        execSync3(`npx tsc --noEmit --skipLibCheck ${filePath}`, { stdio: "pipe", timeout: 1e4 });
+        execSync2(`npx tsc --noEmit --skipLibCheck ${filePath}`, { stdio: "pipe", timeout: 1e4 });
         return true;
       } catch (err) {
         if (err.status === 127 || err.message.includes("not found") || err.message.includes("ENOENT")) {
@@ -7560,7 +7988,7 @@ class StepVerifier {
     }
     if (ext === ".js" || ext === ".jsx") {
       try {
-        execSync3(`node --check ${filePath}`, { stdio: "pipe", timeout: 5000 });
+        execSync2(`node --check ${filePath}`, { stdio: "pipe", timeout: 5000 });
         return true;
       } catch {
         return false;
@@ -8205,6 +8633,10 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
   shutdown() {
     const { pluginManager, logger, sessionManager, contextManager } = this.deps;
     contextManager.onCompact = null;
+    const killed = processRegistry.killAll();
+    if (killed > 0) {
+      logger.info(`Killed ${killed} background process(es) on shutdown`);
+    }
     pluginManager.runOnSessionEnd({
       logger,
       sessionManager: sessionManager?.getActiveMeta()
@@ -9692,7 +10124,7 @@ ${logs.join(`
 };
 
 // src/modules/mcp/client.ts
-import { spawn } from "child_process";
+import { spawn as spawn3 } from "child_process";
 
 class MCPClient {
   serverName;
@@ -9799,7 +10231,7 @@ class MCPClient {
   }
   connectStdio() {
     return new Promise((resolve14, reject) => {
-      const child = spawn(this.config.command, this.config.args || [], {
+      const child = spawn3(this.config.command, this.config.args || [], {
         env: { ...process.env, ...this.config.env },
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -10824,6 +11256,9 @@ function registerAllTools(registry2, skillsModule) {
     fileInfoTool,
     bashTool,
     subagentTool,
+    processListTool,
+    processLogTool,
+    processKillTool,
     webSearchTool,
     webFetchTool,
     webBrowseTool,
@@ -10917,7 +11352,7 @@ class PluginLoader {
 }
 
 // src/modules/plugins/builtin/lint-on-write.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import { existsSync as existsSync20, readFileSync as readFileSync10 } from "fs";
 import { resolve as resolve14, extname as extname3, join as join13 } from "path";
 var projectTypeCheckPromise = null;
@@ -10954,7 +11389,7 @@ class LintOnWritePlugin {
   checkSyntax(filePath, ext, baseDir) {
     if (ext === ".ts" || ext === ".tsx") {
       try {
-        execSync4(`npx tsc --noEmit --skipLibCheck "${filePath}"`, { cwd: baseDir, stdio: "pipe", timeout: 1e4 });
+        execSync3(`npx tsc --noEmit --skipLibCheck "${filePath}"`, { cwd: baseDir, stdio: "pipe", timeout: 1e4 });
         return null;
       } catch (err) {
         if (err.status === 127 || err.message.includes("not found") || err.message.includes("ENOENT")) {
@@ -10971,7 +11406,7 @@ class LintOnWritePlugin {
     }
     if (ext === ".js" || ext === ".jsx") {
       try {
-        execSync4(`node --check "${filePath}"`, { cwd: baseDir, stdio: "pipe", timeout: 5000 });
+        execSync3(`node --check "${filePath}"`, { cwd: baseDir, stdio: "pipe", timeout: 5000 });
         return null;
       } catch (err) {
         const stderr = err.stderr?.toString() || "";
@@ -10994,7 +11429,7 @@ class LintOnWritePlugin {
         return;
       }
       ctx.logger.debug(`Running lint: ${lintScript}`);
-      execSync4(lintScript, { cwd: ctx.baseDir, stdio: "pipe" });
+      execSync3(lintScript, { cwd: ctx.baseDir, stdio: "pipe" });
       ctx.logger.debug("Lint passed");
     } catch (err) {
       ctx.logger.warn(`Lint failed: ${err.message}`);
@@ -11029,7 +11464,7 @@ class LintOnWritePlugin {
   }
   async runTscCheck(baseDir) {
     try {
-      execSync4(`npx tsc --noEmit --skipLibCheck`, { cwd: baseDir, stdio: "pipe", timeout: 30000 });
+      execSync3(`npx tsc --noEmit --skipLibCheck`, { cwd: baseDir, stdio: "pipe", timeout: 30000 });
       return null;
     } catch (err) {
       if (err.status === 127 || err.message.includes("not found") || err.message.includes("ENOENT")) {
@@ -11256,7 +11691,7 @@ class StuckDetector {
 }
 
 // src/modules/execution/auditor.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import { existsSync as existsSync21 } from "fs";
 import { resolve as resolve15, join as join14 } from "path";
 class Auditor {
@@ -11308,7 +11743,7 @@ class Auditor {
       return null;
     }
     try {
-      execSync5(`npx tsc --noEmit --skipLibCheck`, { cwd: this.baseDir, stdio: "pipe", timeout: 30000 });
+      execSync4(`npx tsc --noEmit --skipLibCheck`, { cwd: this.baseDir, stdio: "pipe", timeout: 30000 });
       return null;
     } catch (err) {
       if (err.status === 127 || err.message.includes("not found") || err.message.includes("ENOENT")) {
@@ -12103,7 +12538,7 @@ class SessionModule {
 // src/modules/user-profile/profile.ts
 import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync25, mkdirSync as mkdirSync11 } from "fs";
 import { join as join17 } from "path";
-import { homedir as homedir7, hostname, platform as platform2, type } from "os";
+import { homedir as homedir7, hostname, platform as platform4, type } from "os";
 import { env } from "process";
 
 // src/modules/user-profile/compressor.ts
@@ -12132,7 +12567,7 @@ class UserProfile {
   }
   collect() {
     this.info = {
-      platform: platform2(),
+      platform: platform4(),
       os: `${type()} ${hostname()}`,
       hostname: hostname(),
       shell: env.SHELL || env.ComSpec || "unknown",