cliskill 1.0.4 → 1.0.6

package/dist/{chunk-UJMUL64T.js → chunk-S4ZZPUPF.js}

@@ -90,6 +90,18 @@ var modelsSchema = z.object({
   fallbackModel: z.string().default("glm-5.1"),
   maxContextTokens: z.number().default(5e5)
 });
+var mcpServerSchema = z.object({
+  /** Unique name for this MCP server */
+  name: z.string().min(1),
+  /** Command to start the MCP server process */
+  command: z.string().min(1),
+  /** Arguments passed to the command */
+  args: z.array(z.string()).default([]),
+  /** Environment variables for the server process */
+  env: z.record(z.string()).optional(),
+  /** Transport type (currently only stdio supported) */
+  transport: z.enum(["stdio"]).default("stdio")
+});
 var appConfigSchema = z.object({
   /** Default provider name to use */
   defaultProvider: z.string().optional(),
@@ -136,7 +148,9 @@ var appConfigSchema = z.object({
     maxHistoryAge: z.number().default(60),
     maxMemorySize: z.number().default(50),
     idleThreshold: z.number().default(3e5)
-  }).default({})
+  }).default({}),
+  /** MCP servers — external tool providers via Model Context Protocol */
+  mcpServers: z.array(mcpServerSchema).default([])
 });
 
 // src/config/constants.ts
@@ -417,7 +431,7 @@ var BaseAdapter = class {
         if (attempt >= 5) throw err;
         const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
         log.warn(`Network error on ${url}: ${err.message}, retrying in ${delay}ms (attempt ${attempt})`);
-        await new Promise((resolve9) => setTimeout(resolve9, delay));
+        await new Promise((resolve10) => setTimeout(resolve10, delay));
         continue;
       }
       if (response.ok) return response;
@@ -436,7 +450,7 @@ var BaseAdapter = class {
         return response;
       }
       log.warn(`Retrying ${url} in ${Math.round(action.delay)}ms (attempt ${attempt})`);
-      await new Promise((resolve9) => setTimeout(resolve9, action.delay));
+      await new Promise((resolve10) => setTimeout(resolve10, action.delay));
     }
   }
 };
@@ -584,7 +598,16 @@ var GenericCompatAdapter = class extends BaseAdapter {
     let buffer = "";
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        let done;
+        let value;
+        try {
+          const result = await reader.read();
+          done = result.done;
+          value = result.value;
+        } catch (err) {
+          if (isAbortOrNetworkError(err)) break;
+          throw err;
+        }
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -649,6 +672,11 @@ var GenericCompatAdapter = class extends BaseAdapter {
     }
   }
 };
+function isAbortOrNetworkError(err) {
+  const name = err.name ?? "";
+  const msg = err.message ?? "";
+  return name === "AbortError" || msg.includes("abort") || msg.includes("Abort") || msg.includes("timeout") || msg.includes("Timeout") || msg.includes("fetch failed") || msg.includes("ECONNRESET") || msg.includes("network");
+}
 
 // src/connect/glm-adapter.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -808,7 +836,16 @@ var GLMAdapter = class extends BaseAdapter {
     let buffer = "";
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        let done;
+        let value;
+        try {
+          const result = await reader.read();
+          done = result.done;
+          value = result.value;
+        } catch (err) {
+          if (isAbortOrNetworkError2(err)) break;
+          throw err;
+        }
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -880,6 +917,11 @@ var GLMAdapter = class extends BaseAdapter {
     }
   }
 };
+function isAbortOrNetworkError2(err) {
+  const name = err.name ?? "";
+  const msg = err.message ?? "";
+  return name === "AbortError" || msg.includes("abort") || msg.includes("Abort") || msg.includes("timeout") || msg.includes("Timeout") || msg.includes("fetch failed") || msg.includes("ECONNRESET") || msg.includes("network");
+}
 
 // src/connect/registry.ts
 var AdapterRegistry = class {
@@ -921,6 +963,30 @@ var AdapterRegistry = class {
   }
 };
 
+// src/infra/errors.ts
+var AppError = class extends Error {
+  constructor(message, code, recoverable = true) {
+    super(message);
+    this.code = code;
+    this.recoverable = recoverable;
+    this.name = "AppError";
+  }
+  code;
+  recoverable;
+};
+var FallbackTriggeredError = class extends AppError {
+  constructor(message, originalError, fromModel, fallbackModel) {
+    super(message, "FALLBACK_TRIGGERED", true);
+    this.originalError = originalError;
+    this.fromModel = fromModel;
+    this.fallbackModel = fallbackModel;
+    this.name = "FallbackTriggeredError";
+  }
+  originalError;
+  fromModel;
+  fallbackModel;
+};
+
 // src/connect/model-router.ts
 var TASK_KEYWORDS = {
   reasoning: ["analyze", "reason", "think", "explain", "compare", "evaluate", "decide", "logic", "math", "prove"],
@@ -945,6 +1011,20 @@ var DEFAULT_PREFERENCES = {
   analysis: "balanced",
   default: "balanced"
 };
+var FALLBACK_TRIGGER_PATTERNS = ["529", "503", "Overloaded", "overloaded", "capacity", "rate_limit"];
+var FALLBACK_TRIGGER_CODES = /* @__PURE__ */ new Set([529, 503, 502]);
+function isFallbackTriggeredError(err) {
+  if (err instanceof FallbackTriggeredError) return true;
+  if (!(err instanceof Error)) return false;
+  const message = err.message;
+  for (const pattern of FALLBACK_TRIGGER_PATTERNS) {
+    if (message.includes(pattern)) return true;
+  }
+  if ("statusCode" in err && typeof err.statusCode === "number") {
+    return FALLBACK_TRIGGER_CODES.has(err.statusCode);
+  }
+  return false;
+}
 var ModelRouter = class {
   registry;
   modelAccess;
@@ -954,7 +1034,8 @@ var ModelRouter = class {
     this.modelAccess = modelAccess;
     this.config = {
       defaultModel: config?.defaultModel ?? modelAccess.getEffectiveModel(),
-      preferences: { ...DEFAULT_PREFERENCES, ...config?.preferences }
+      preferences: { ...DEFAULT_PREFERENCES, ...config?.preferences },
+      fallbackChain: config?.fallbackChain
     };
   }
   /** Resolve a model name or alias to a concrete adapter */
@@ -1012,6 +1093,116 @@ var ModelRouter = class {
   getEffectiveModel(requestedModel) {
     return this.modelAccess.getEffectiveModel(requestedModel);
   }
+  /**
+   * Resolve with fallback: if primary adapter fails (529/503/overloaded),
+   * try the fallback model. Returns both adapters for retry logic.
+   */
+  resolveWithFallback(primaryModel) {
+    const primary = this.resolve(primaryModel);
+    const fallbackModel = this.config.fallbackModel;
+    const fallback = fallbackModel && fallbackModel !== primaryModel ? this.resolve(fallbackModel) : this.findAlternativeAdapter(primary);
+    return { primary, fallback };
+  }
+  /**
+   * Build the full fallback chain for a given primary model.
+   * Returns adapters in priority order: [primary, ...fallbackChain].
+   * Skips duplicates and null entries.
+   */
+  resolveFallbackChain(primaryModel) {
+    const primary = this.resolve(primaryModel);
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    if (primary) {
+      chain.push(primary);
+      seen.add(primary.config.model);
+    }
+    const fallbackModels = this.config.fallbackChain ?? [];
+    if (this.config.fallbackModel && !fallbackModels.includes(this.config.fallbackModel)) {
+      fallbackModels.unshift(this.config.fallbackModel);
+    }
+    for (const modelOrAlias of fallbackModels) {
+      const adapter = this.resolve(modelOrAlias);
+      if (adapter && !seen.has(adapter.config.model)) {
+        chain.push(adapter);
+        seen.add(adapter.config.model);
+      }
+    }
+    for (const adapter of this.registry.getAll()) {
+      if (!seen.has(adapter.config.model)) {
+        chain.push(adapter);
+        seen.add(adapter.config.model);
+      }
+    }
+    return chain;
+  }
+  /**
+   * Stream with automatic fallback on overloaded errors.
+   * Tries each adapter in the fallback chain until one succeeds.
+   * Yields a mix of the primary response or fallback response events.
+   */
+  async *streamWithFallback(request, primaryModel) {
+    const chain = this.resolveFallbackChain(primaryModel);
+    const errors = [];
+    for (const adapter of chain) {
+      try {
+        yield* adapter.stream(request);
+        return;
+      } catch (err) {
+        const error = err;
+        errors.push(error);
+        if (!isFallbackTriggeredError(error)) {
+          throw error;
+        }
+        continue;
+      }
+    }
+    const lastError = errors[errors.length - 1];
+    if (chain.length > 1) {
+      throw new FallbackTriggeredError(
+        `All ${chain.length} models in fallback chain failed. Last error: ${lastError?.message ?? "unknown"}`,
+        lastError ?? new Error("unknown"),
+        chain[0]?.config.model ?? "unknown",
+        chain[chain.length - 1]?.config.model ?? "unknown"
+      );
+    }
+    throw lastError ?? new Error("No adapters available");
+  }
+  /**
+   * Complete with automatic fallback on overloaded errors.
+   * Tries each adapter in the fallback chain until one succeeds.
+   */
+  async completeWithFallback(request, primaryModel) {
+    const chain = this.resolveFallbackChain(primaryModel);
+    const errors = [];
+    for (const adapter of chain) {
+      try {
+        const result = await adapter.complete(request);
+        return { result, usedModel: adapter.config.model };
+      } catch (err) {
+        const error = err;
+        errors.push(error);
+        if (!isFallbackTriggeredError(error)) {
+          throw error;
+        }
+        continue;
+      }
+    }
+    const lastError = errors[errors.length - 1];
+    if (chain.length > 1) {
+      throw new FallbackTriggeredError(
+        `All ${chain.length} models in fallback chain failed. Last error: ${lastError?.message ?? "unknown"}`,
+        lastError ?? new Error("unknown"),
+        chain[0]?.config.model ?? "unknown",
+        chain[chain.length - 1]?.config.model ?? "unknown"
+      );
+    }
+    throw lastError ?? new Error("No adapters available");
+  }
+  /** Find an alternative adapter different from the excluded one */
+  findAlternativeAdapter(exclude) {
+    const adapters = this.registry.getAll();
+    return adapters.find((a) => a !== exclude) ?? null;
+  }
   findAdapterForModel(modelName) {
     const adapters = this.registry.getAll();
     return adapters.find((a) => a.config.model === modelName) ?? adapters.find((a) => a.config.model.includes(modelName)) ?? null;
@@ -1096,16 +1287,24 @@ var ModelAccessManager = class {
 // src/tools/registry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
-  /** Register a tool */
+  aliasMap = /* @__PURE__ */ new Map();
+  /** Register a tool (with optional aliases) */
   register(tool) {
     if (this.tools.has(tool.name)) {
       throw new Error(`Tool "${tool.name}" is already registered`);
     }
     this.tools.set(tool.name, tool);
+    if (tool.aliases) {
+      for (const alias of tool.aliases) {
+        if (!this.aliasMap.has(alias)) {
+          this.aliasMap.set(alias, tool);
+        }
+      }
+    }
   }
-  /** Get a tool by name */
+  /** Get a tool by name or alias */
   get(name) {
-    return this.tools.get(name);
+    return this.tools.get(name) ?? this.aliasMap.get(name);
   }
   /** Get all registered tools */
   getAll() {
@@ -1115,17 +1314,33 @@ var ToolRegistry = class {
   getToolDefinitions() {
     return this.getAll().map((t) => t.toToolDefinition());
   }
-  /** Check if a tool exists */
+  /** Check if a tool exists (by name or alias) */
   has(name) {
-    return this.tools.has(name);
+    return this.tools.has(name) || this.aliasMap.has(name);
+  }
+  /** Search tools by keyword in name, description, or searchHint */
+  search(keyword) {
+    const lower = keyword.toLowerCase();
+    return this.getAll().filter(
+      (t) => t.name.toLowerCase().includes(lower) || t.description.toLowerCase().includes(lower) || (t.searchHint?.toLowerCase().includes(lower) ?? false)
+    );
   }
-  /** Unregister a tool */
+  /** Unregister a tool (and its aliases) */
   unregister(name) {
-    this.tools.delete(name);
+    const tool = this.tools.get(name);
+    if (tool) {
+      this.tools.delete(name);
+      if (tool.aliases) {
+        for (const alias of tool.aliases) {
+          this.aliasMap.delete(alias);
+        }
+      }
+    }
   }
-  /** Clear all tools */
+  /** Clear all tools and aliases */
   clear() {
     this.tools.clear();
+    this.aliasMap.clear();
   }
 };
 
@@ -1308,7 +1523,7 @@ var BashTool = class extends BaseTool {
     }
     const timeoutMs = input.timeout ?? 3e4;
     const command = process.platform === "win32" ? `chcp 65001 >nul 2>&1 && ${input.command}` : input.command;
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const child = exec(
         command,
         {
@@ -1324,12 +1539,12 @@ var BashTool = class extends BaseTool {
           if (error) {
             result += (result ? "\n" : "") + `Exit code: ${error.code ?? "unknown"}`;
           }
-          resolve9(result || "(no output)");
+          resolve10(result || "(no output)");
         }
       );
       context.abortSignal.addEventListener("abort", () => {
         child.kill("SIGTERM");
-        resolve9("Error: Command was aborted by user");
+        resolve10("Error: Command was aborted by user");
       }, { once: true });
     });
   }
@@ -1567,10 +1782,10 @@ var GrepTool = class extends BaseTool {
     }
   }
   async isRgAvailable() {
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const cmd = process.platform === "win32" ? "rg.exe" : "rg";
       execFile(cmd, ["--version"], (err) => {
-        resolve9(!err);
+        resolve10(!err);
       });
     });
   }
@@ -1596,23 +1811,23 @@ var GrepTool = class extends BaseTool {
     args.push("--max-count", String(input.max_results));
     args.push(input.pattern, searchPath);
     const cmd = process.platform === "win32" ? "rg.exe" : "rg";
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       execFile(cmd, args, { maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
         if (error && !stdout) {
           if (error.code === "1") {
-            resolve9("No matches found.");
+            resolve10("No matches found.");
           }
-          resolve9(`Error: ${stderr || error.message}`);
+          resolve10(`Error: ${stderr || error.message}`);
           return;
         }
         const output = stdout.trim();
         if (!output) {
-          resolve9("No matches found.");
+          resolve10("No matches found.");
           return;
         }
         const lines = output.split("\n");
         const maxLines = lines.slice(0, input.max_results);
-        resolve9(maxLines.join("\n"));
+        resolve10(maxLines.join("\n"));
       });
     });
   }
@@ -2584,6 +2799,7 @@ var LspTool = class extends BaseTool {
 
 // src/tools/builtins/agent-tool.ts
 import { z as z15 } from "zod";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/services/streaming-tool-executor.ts
 var StreamingToolExecutor = class {
@@ -2592,6 +2808,9 @@ var StreamingToolExecutor = class {
   bashErrorDescription = "";
   siblingAbortController = new AbortController();
   discarded = false;
+  // P0.2: Progress events buffer
+  pendingProgress = [];
+  progressAvailableResolve = null;
   // Backward-compatible fields
   toolRegistry;
   executorConfig;
@@ -2623,10 +2842,19 @@ var StreamingToolExecutor = class {
     this.discarded = true;
     this.siblingAbortController.abort("discarded");
   }
+  /** P0.2: Emit a progress event for a running tool */
+  onToolProgress(toolName, toolId, message) {
+    this.pendingProgress.push({ toolName, toolId, message });
+    if (this.progressAvailableResolve) {
+      this.progressAvailableResolve();
+      this.progressAvailableResolve = null;
+    }
+  }
   /** Add a tool to the execution queue. Starts immediately if conditions allow. */
   addTool(toolCall) {
     const tool = this.toolRegistry.get(toolCall.name);
-    const isConcurrencySafe = tool ? tool.concurrencySafe : false;
+    const safeFlag = tool ? tool.concurrencySafe : false;
+    const isConcurrencySafe = typeof safeFlag === "function" ? safeFlag(toolCall.input) : safeFlag;
     this.tools.push({
       id: toolCall.id,
       name: toolCall.name,
@@ -2648,20 +2876,40 @@ var StreamingToolExecutor = class {
       }
     }
   }
-  /** Wait for all remaining tools and yield results as they complete */
+  /** Drain buffered progress events */
+  *drainProgress() {
+    while (this.pendingProgress.length > 0) {
+      yield this.pendingProgress.shift();
+    }
+  }
+  /** Wait for all remaining tools and yield results + progress events as they arrive */
   async *getRemainingResults() {
     while (this.hasUnfinishedTools()) {
       await this.processQueue();
+      for (const progress of this.drainProgress()) {
+        yield { type: "progress", progress };
+      }
       for (const result of this.getCompletedResults()) {
         yield result;
       }
       if (this.hasExecutingTools() && !this.hasCompletedResults()) {
         const executingPromises = this.tools.filter((t) => t.status === "executing" && t.promise).map((t) => t.promise);
+        const progressPromise = new Promise((resolve10) => {
+          this.progressAvailableResolve = resolve10;
+        });
         if (executingPromises.length > 0) {
-          await Promise.race(executingPromises);
+          await Promise.race([...executingPromises, progressPromise]);
+        } else {
+          await progressPromise;
+        }
+        for (const progress of this.drainProgress()) {
+          yield { type: "progress", progress };
         }
       }
     }
+    for (const progress of this.drainProgress()) {
+      yield { type: "progress", progress };
+    }
     for (const result of this.getCompletedResults()) {
       yield result;
     }
@@ -2720,6 +2968,8 @@ var StreamingToolExecutor = class {
     this.bashErrorDescription = "";
     this.siblingAbortController = new AbortController();
     this.discarded = false;
+    this.pendingProgress = [];
+    this.progressAvailableResolve = null;
   }
   canExecuteTool(isConcurrencySafe) {
     if (this.discarded) return false;
@@ -2750,12 +3000,29 @@ var StreamingToolExecutor = class {
       return;
     }
     const startTime = performance.now();
+    const externalSignal = context?.abortSignal ?? this.toolContext?.abortSignal;
+    const linkedController = new AbortController();
+    const onDiscard = () => linkedController.abort("discarded");
+    this.siblingAbortController.signal.addEventListener("abort", onDiscard);
+    if (externalSignal) {
+      externalSignal.addEventListener("abort", onDiscard);
+      if (externalSignal.aborted) linkedController.abort("external");
+    }
+    const progressCallback = (message) => {
+      this.onToolProgress(tool.name, tool.id, message);
+    };
     try {
       if (this.executeFn && this.autoMode && this.onPermissionRequest) {
+        const baseCtx = context ?? this.toolContext;
+        const ctxWithProgress = {
+          ...baseCtx,
+          abortSignal: linkedController.signal,
+          onProgress: progressCallback
+        };
         const result = await this.executeFn(
           { id: tool.id, name: tool.name, input: tool.input },
           this.toolRegistry,
-          context ?? this.toolContext,
+          ctxWithProgress,
           this.autoMode,
           this.onPermissionRequest
         );
@@ -2767,9 +3034,10 @@ var StreamingToolExecutor = class {
           tool.status = "completed";
           return;
         }
-        const ctx = context ?? { cwd: process.cwd(), abortSignal: new AbortController().signal, checkPermission: async () => true };
+        const ctx = context ?? { cwd: process.cwd(), abortSignal: linkedController.signal, checkPermission: async () => true };
+        const execCtx = { ...ctx, abortSignal: linkedController.signal, onProgress: progressCallback };
         const validatedInput = registeredTool.inputSchema.parse(tool.input);
-        const rawOutput = await registeredTool.execute(validatedInput, ctx);
+        const rawOutput = await registeredTool.execute(validatedInput, execCtx);
         const output = rawOutput.length > 5e4 ? rawOutput.slice(0, 5e4) + "\n\n... [truncated]" : rawOutput;
         tool.result = {
           toolResult: {
@@ -2814,6 +3082,11 @@ var StreamingToolExecutor = class {
           isError: true
         }
       };
+    } finally {
+      this.siblingAbortController.signal.removeEventListener("abort", onDiscard);
+      if (externalSignal) {
+        externalSignal.removeEventListener("abort", onDiscard);
+      }
     }
     tool.status = "completed";
     void this.processQueue(context);
@@ -2913,8 +3186,20 @@ function countLatinChars(text) {
 var DEFAULT_CONFIG = {
   maxTokens: 128e3,
   compactionThreshold: 0.8,
-  keepRecentMessages: 4
+  keepRecentMessages: 6
 };
+var AUTOCOMPACT_BUFFER_TOKENS = 13e3;
+var MAX_CONSECUTIVE_FAILURES = 3;
+function calculateTokenWarningState(tokenUsage, maxTokens) {
+  const usagePercent = tokenUsage / maxTokens;
+  return {
+    usagePercent,
+    isNormal: usagePercent <= 0.8,
+    isWarning: usagePercent > 0.8 && usagePercent <= 0.9,
+    isError: usagePercent > 0.9 && usagePercent <= 0.95,
+    shouldAutoCompact: usagePercent > 0.95
+  };
+}
 var SUMMARIZATION_PROMPT = `Summarize the following conversation history concisely, preserving:
 - Key decisions and their rationale
 - Important code changes made
@@ -2927,13 +3212,18 @@ Conversation to summarize:
 var ContextCompactor = class {
   config;
   adapter;
+  consecutiveFailures = 0;
   constructor(config, adapter) {
     this.config = { ...DEFAULT_CONFIG, ...config };
     this.adapter = adapter ?? null;
   }
   shouldCompact(messages) {
+    if (this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+      return false;
+    }
     const totalTokens = this.estimateMessagesTokens(messages);
-    const threshold = this.config.compactionThreshold * this.config.maxTokens;
+    const effectiveMax = this.config.maxTokens - AUTOCOMPACT_BUFFER_TOKENS;
+    const threshold = this.config.compactionThreshold * effectiveMax;
     return totalTokens > threshold;
   }
   async compact(messages, systemPrompt) {
@@ -2960,11 +3250,22 @@ var ContextCompactor = class {
       };
     }
     let summary;
-    if (this.adapter) {
-      summary = await this.generateSummary(oldMessages);
-    } else {
+    let succeeded = false;
+    try {
+      if (this.adapter) {
+        summary = await this.generateSummary(oldMessages);
+        succeeded = true;
+      } else {
+        summary = this.truncateMessages(oldMessages);
+        succeeded = true;
+      }
+    } catch {
+      this.consecutiveFailures++;
       summary = this.truncateMessages(oldMessages);
     }
+    if (succeeded) {
+      this.consecutiveFailures = 0;
+    }
     const summaryMessage = {
       role: "user",
       content: `[Previous conversation summary]
@@ -3018,30 +3319,96 @@ ${summary}`
 
 // src/services/cost-tracker.ts
 var DEFAULT_PRICES = {
+  // OpenAI
   "gpt-4o": { input: 2.5, output: 10, cacheRead: 1.25, cacheWrite: 2.5 },
   "gpt-4o-mini": { input: 0.15, output: 0.6, cacheRead: 0.075, cacheWrite: 0.15 },
   "gpt-4-turbo": { input: 10, output: 30, cacheRead: 5, cacheWrite: 10 },
   "gpt-3.5-turbo": { input: 0.5, output: 1.5, cacheRead: 0.25, cacheWrite: 0.5 },
+  "o1": { input: 15, output: 60, cacheRead: 7.5, cacheWrite: 15 },
+  "o1-mini": { input: 3, output: 12, cacheRead: 1.5, cacheWrite: 3 },
+  "o3-mini": { input: 1.1, output: 4.4, cacheRead: 0.55, cacheWrite: 1.1 },
+  // Anthropic
   "claude-3.5-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
   "claude-3-opus": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
   "claude-3-haiku": { input: 0.25, output: 1.25, cacheRead: 0.03, cacheWrite: 0.3 },
+  "claude-3.5-haiku": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  // DeepSeek
   "deepseek-chat": { input: 0.14, output: 0.28, cacheRead: 0.014, cacheWrite: 0.14 },
-  "deepseek-reasoner": { input: 0.55, output: 2.19, cacheRead: 0.14, cacheWrite: 0.55 }
+  "deepseek-reasoner": { input: 0.55, output: 2.19, cacheRead: 0.14, cacheWrite: 0.55 },
+  // Google
+  "gemini-2.0-flash": { input: 0.1, output: 0.4, cacheRead: 0.025, cacheWrite: 0.1 },
+  "gemini-1.5-pro": { input: 1.25, output: 5, cacheRead: 0.3125, cacheWrite: 1.25 },
+  "gemini-1.5-flash": { input: 0.075, output: 0.3, cacheRead: 0.01875, cacheWrite: 0.075 },
+  // GLM
+  "glm-4": { input: 1, output: 3, cacheRead: 0.5, cacheWrite: 1 },
+  "glm-4.5": { input: 1.5, output: 4.5, cacheRead: 0.75, cacheWrite: 1.5 },
+  "glm-4.7": { input: 2, output: 6, cacheRead: 1, cacheWrite: 2 },
+  "glm-5": { input: 2.5, output: 8, cacheRead: 1.25, cacheWrite: 2.5 },
+  "glm-5.1": { input: 3, output: 10, cacheRead: 1.5, cacheWrite: 3 },
+  "glm-5-turbo": { input: 0.5, output: 2, cacheRead: 0.25, cacheWrite: 0.5 },
+  // Qwen
+  "qwen-2.5-72b": { input: 0.4, output: 1.2, cacheRead: 0.2, cacheWrite: 0.4 },
+  // Llama
+  "llama-3.1-405b": { input: 3, output: 9, cacheRead: 1.5, cacheWrite: 3 }
 };
+var MODEL_PATTERNS2 = [
+  { pattern: /gpt-4o-mini/i, baseModel: "gpt-4o-mini" },
+  { pattern: /gpt-4o/i, baseModel: "gpt-4o" },
+  { pattern: /gpt-4-turbo/i, baseModel: "gpt-4-turbo" },
+  { pattern: /gpt-3\.5/i, baseModel: "gpt-3.5-turbo" },
+  { pattern: /o1-mini/i, baseModel: "o1-mini" },
+  { pattern: /o3-mini/i, baseModel: "o3-mini" },
+  { pattern: /o1/i, baseModel: "o1" },
+  { pattern: /claude-3\.5-sonnet/i, baseModel: "claude-3.5-sonnet" },
+  { pattern: /claude-3\.5-haiku/i, baseModel: "claude-3.5-haiku" },
+  { pattern: /claude-3-opus/i, baseModel: "claude-3-opus" },
+  { pattern: /claude-3-haiku/i, baseModel: "claude-3-haiku" },
+  { pattern: /deepseek-reasoner/i, baseModel: "deepseek-reasoner" },
+  { pattern: /deepseek-chat/i, baseModel: "deepseek-chat" },
+  { pattern: /deepseek/i, baseModel: "deepseek-chat" },
+  { pattern: /gemini-2\.0-flash/i, baseModel: "gemini-2.0-flash" },
+  { pattern: /gemini-1\.5-pro/i, baseModel: "gemini-1.5-pro" },
+  { pattern: /gemini-1\.5-flash/i, baseModel: "gemini-1.5-flash" },
+  { pattern: /gemini/i, baseModel: "gemini-2.0-flash" },
+  { pattern: /glm-5-turbo/i, baseModel: "glm-5-turbo" },
+  { pattern: /glm-5\.1/i, baseModel: "glm-5.1" },
+  { pattern: /glm-5/i, baseModel: "glm-5" },
+  { pattern: /glm-4\.7/i, baseModel: "glm-4.7" },
+  { pattern: /glm-4\.5/i, baseModel: "glm-4.5" },
+  { pattern: /glm-4/i, baseModel: "glm-4" },
+  { pattern: /glm/i, baseModel: "glm-5.1" },
+  { pattern: /qwen.*72b/i, baseModel: "qwen-2.5-72b" },
+  { pattern: /qwen/i, baseModel: "qwen-2.5-72b" },
+  { pattern: /llama.*405b/i, baseModel: "llama-3.1-405b" },
+  { pattern: /llama/i, baseModel: "llama-3.1-405b" }
+];
 var CostTracker = class {
   entries = [];
   config;
   sessionStart;
+  lastBudgetLevel = "normal";
   constructor(config) {
     this.config = {
       prices: { ...DEFAULT_PRICES, ...config?.prices },
-      budgetLimit: config?.budgetLimit
+      budgetLimit: config?.budgetLimit,
+      warningThreshold: config?.warningThreshold ?? 0.75,
+      criticalThreshold: config?.criticalThreshold ?? 0.9
     };
     this.sessionStart = Date.now();
   }
+  /** Find prices for a model — exact match first, then fuzzy pattern matching */
+  findPrices(model) {
+    if (this.config.prices[model]) return this.config.prices[model];
+    for (const { pattern, baseModel } of MODEL_PATTERNS2) {
+      if (pattern.test(model)) {
+        return this.config.prices[baseModel];
+      }
+    }
+    return void 0;
+  }
   /** Record token usage for a model */
   recordUsage(model, usage) {
-    const prices = this.config.prices[model];
+    const prices = this.findPrices(model);
     let cost = 0;
     if (prices) {
       const inputCost = usage.inputTokens / 1e6 * prices.input;
@@ -3128,6 +3495,66 @@ var CostTracker = class {
       percent
     };
   }
+  /**
+   * Get detailed budget status with warning levels.
+   * Returns current budget level and whether it changed since last check.
+   */
+  getBudgetStatus() {
+    const used = this.getSessionTotal();
+    const limit = this.config.budgetLimit;
+    if (!limit) {
+      return { level: "normal", used, percent: 0 };
+    }
+    const percent = used / limit * 100;
+    const ratio = used / limit;
+    let level = "normal";
+    if (ratio >= 1) level = "exceeded";
+    else if (ratio >= (this.config.criticalThreshold ?? 0.9)) level = "critical";
+    else if (ratio >= (this.config.warningThreshold ?? 0.75)) level = "warning";
+    return {
+      level,
+      used,
+      limit,
+      percent,
+      remainingBudget: limit - used
+    };
+  }
+  /**
+   * Check if budget level changed since last call.
+   * Returns the new status if it escalated, null if unchanged.
+   * Use this to emit budget warnings to the user.
+   */
+  checkBudgetWarning() {
+    const status = this.getBudgetStatus();
+    const levels = ["normal", "warning", "critical", "exceeded"];
+    const currentIdx = levels.indexOf(status.level);
+    const lastIdx = levels.indexOf(this.lastBudgetLevel);
+    if (currentIdx > lastIdx) {
+      this.lastBudgetLevel = status.level;
+      return status;
+    }
+    this.lastBudgetLevel = status.level;
+    return null;
+  }
+  /** Get cache efficiency metrics */
+  getCacheMetrics() {
+    let totalCacheReads = 0;
+    let totalCacheWrites = 0;
+    let savings = 0;
+    for (const entry of this.entries) {
+      totalCacheReads += entry.cacheReadTokens;
+      totalCacheWrites += entry.cacheCreationTokens;
+      const prices = this.findPrices(entry.model);
+      if (prices) {
+        const fullInputCost = entry.inputTokens / 1e6 * prices.input;
+        const actualInputCost = (entry.inputTokens - entry.cacheReadTokens) / 1e6 * prices.input + entry.cacheReadTokens / 1e6 * prices.cacheRead;
+        savings += fullInputCost - actualInputCost;
+      }
+    }
+    const totalInputTokens = this.entries.reduce((sum, e) => sum + e.inputTokens, 0);
+    const cacheHitRate = totalInputTokens > 0 ? totalCacheReads / totalInputTokens : 0;
+    return { totalCacheReads, totalCacheWrites, cacheHitRate, savings };
+  }
   /** Get session duration in ms */
   getSessionDuration() {
     return Date.now() - this.sessionStart;
@@ -3136,6 +3563,7 @@ var CostTracker = class {
   reset() {
     this.entries = [];
     this.sessionStart = Date.now();
+    this.lastBudgetLevel = "normal";
   }
 };
 
@@ -3246,6 +3674,41 @@ function extractToolCalls(content) {
   );
 }
 
+// src/infra/abort-controller.ts
+import { setMaxListeners } from "events";
+var DEFAULT_MAX_LISTENERS = 50;
+function createAbortController(maxListeners = DEFAULT_MAX_LISTENERS) {
+  const controller = new AbortController();
+  setMaxListeners(maxListeners, controller.signal);
+  return controller;
+}
+function createChildAbortController(parent, maxListeners) {
+  const child = createAbortController(maxListeners);
+  const parentSignal = parent instanceof AbortController ? parent.signal : parent.signal;
+  if (parentSignal.aborted) {
+    child.abort(parentSignal.reason);
+    return child;
+  }
+  const weakChild = new WeakRef(child);
+  const weakParentRef = new WeakRef(parent);
+  const handler = () => {
+    const p = weakParentRef.deref();
+    const signal = p instanceof AbortController ? p.signal : p.signal;
+    weakChild.deref()?.abort(signal.reason);
+  };
+  parentSignal.addEventListener("abort", handler, { once: true });
+  child.signal.addEventListener(
+    "abort",
+    () => {
+      const p = weakParentRef.deref();
+      const signal = p instanceof AbortController ? p.signal : p.signal;
+      signal.removeEventListener("abort", handler);
+    },
+    { once: true }
+  );
+  return child;
+}
+
 // src/core/query-engine.ts
 var DEFAULT_CONFIG2 = {
   maxTurns: 50,
@@ -3259,7 +3722,7 @@ var QueryEngine = class {
   executor;
   compactor;
   costTracker;
-  abortController = new AbortController();
+  abortController = createAbortController();
   constructor(config, adapter, tools) {
     this.config = { ...DEFAULT_CONFIG2, ...config };
     this.adapter = adapter;
@@ -3278,6 +3741,7 @@ var QueryEngine = class {
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
     let wasCompacted = false;
+    const runAbortController = this.config.signal ? createChildAbortController({ signal: this.config.signal }) : this.abortController;
     messages.push({
       role: "user",
       content: [{ type: "text", text: prompt }]
@@ -3285,11 +3749,11 @@ var QueryEngine = class {
     const toolDefs = this.tools.getToolDefinitions();
     const toolContext = {
       cwd: process.cwd(),
-      abortSignal: this.abortController.signal,
+      abortSignal: runAbortController.signal,
       checkPermission: this.config.checkPermission ?? (async () => true)
     };
     let turn = 0;
-    while (turn < this.config.maxTurns && !this.abortController.signal.aborted) {
+    while (turn < this.config.maxTurns && !runAbortController.signal.aborted) {
       turn++;
       yield { type: "turn_start", turn };
       try {
@@ -3326,11 +3790,11 @@ ${compactionResult.summary}` }]
           systemPrompt: this.config.systemPrompt,
           maxTokens: Math.max(this.adapter.config.maxTokens, 16384),
           stream: true,
-          signal: this.config.signal
+          signal: runAbortController.signal
         };
         const { assistantContent, stopReason, usage, events } = await parseStreamToBlocks(
           this.adapter.stream(request),
-          this.abortController.signal
+          runAbortController.signal
         );
         for (const evt of events) {
           if (evt.type === "text_delta") {
@@ -3357,11 +3821,12 @@ ${compactionResult.summary}` }]
         if (toolCalls.length > 0) {
           const executorRequests = toolCalls.map((tc) => {
             const tool = this.tools.get(tc.name);
+            const safeFlag = tool?.concurrencySafe ?? false;
             return {
               id: tc.id,
               name: tc.name,
               input: tc.input,
-              concurrencySafe: tool?.concurrencySafe ?? false
+              concurrencySafe: typeof safeFlag === "function" ? safeFlag(tc.input) : safeFlag
             };
           });
           for (const tc of toolCalls) {
@@ -3418,6 +3883,13 @@ function formatContentBlocks(blocks) {
   }).join("\n");
 }
 
+// src/infra/agent-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var agentContextStorage = new AsyncLocalStorage();
+function runWithAgentContext(ctx, fn) {
+  return agentContextStorage.run(ctx, fn);
+}
+
 // src/tools/builtins/agent-tool.ts
 var agentInputSchema = z15.object({
   task: z15.string().describe("Description of the task for the sub-agent"),
@@ -3492,10 +3964,12 @@ var AgentTool = class extends BaseTool {
     let finalText = "";
     let turnsUsed = 0;
     try {
-      for await (const event of engine.run(input.task)) {
-        if (subAgentController.signal.aborted) {
-          break;
-        }
+      const eventStream = runWithAgentContext(
+        { agentId: randomUUID3(), agentType: "subagent", agentName: "agent" },
+        () => engine.run(input.task)
+      );
+      for await (const event of eventStream) {
+        if (subAgentController.signal.aborted) break;
         switch (event.type) {
           case "text_delta":
             finalText += event.text;
@@ -3559,12 +4033,12 @@ import { execFile as execFile2 } from "child_process";
 import { readFile as readFile5, unlink } from "fs/promises";
 import { tmpdir } from "os";
 import { join as join5 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function getPlatform() {
   return process.platform;
 }
 function execCommand(cmd, args) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     execFile2(cmd, args, { timeout: 15e3, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (err) {
         reject(new Error(`Command "${cmd} ${args.join(" ")}" failed: ${err.message}`));
@@ -3574,12 +4048,12 @@ function execCommand(cmd, args) {
         reject(new Error(`Command stderr: ${stderr}`));
         return;
       }
-      resolve9(stdout.trim());
+      resolve10(stdout.trim());
     });
   });
 }
 function execPowerShell(script) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     execFile2(
       "powershell.exe",
       ["-NoProfile", "-NonInteractive", "-Command", script],
@@ -3593,13 +4067,13 @@ function execPowerShell(script) {
           reject(new Error(`PowerShell stderr: ${stderr}`));
           return;
         }
-        resolve9(stdout.trim());
+        resolve10(stdout.trim());
       }
     );
   });
 }
 async function tmpFile(ext) {
-  return join5(tmpdir(), `cliskill-capture-${randomUUID3()}.${ext}`);
+  return join5(tmpdir(), `cliskill-capture-${randomUUID4()}.${ext}`);
 }
 async function readFileAsBase64(path) {
   const buf = await readFile5(path);
@@ -3743,7 +4217,7 @@ function getPlatform2() {
   return process.platform;
 }
 function execPowerShell2(script) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     execFile3(
       "powershell.exe",
       ["-NoProfile", "-NonInteractive", "-Command", script],
@@ -3757,13 +4231,13 @@ function execPowerShell2(script) {
           reject(new Error(`PowerShell stderr: ${stderr}`));
           return;
         }
-        resolve9(stdout.trim());
+        resolve10(stdout.trim());
       }
     );
   });
 }
 function execCommand2(cmd, args) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     execFile3(cmd, args, { timeout: 1e4 }, (err, stdout, stderr) => {
       if (err) {
         reject(new Error(`Command "${cmd} ${args.join(" ")}" failed: ${err.message}`));
@@ -3773,7 +4247,7 @@ function execCommand2(cmd, args) {
         reject(new Error(`Command stderr: ${stderr}`));
         return;
       }
-      resolve9(stdout.trim());
+      resolve10(stdout.trim());
     });
   });
 }
@@ -4327,7 +4801,7 @@ var ComputerUseTool = class extends BaseTool {
 import { z as z17 } from "zod";
 
 // src/remote/session-manager.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { readFile as readFile6 } from "fs/promises";
 var DEFAULT_PORT = 22;
 var CONNECTION_TIMEOUT = 3e4;
@@ -4343,7 +4817,7 @@ var RemoteSessionManager = class {
   }
   async connect(config) {
     const ssh2 = await this.loadSsh2();
-    const id = randomUUID4();
+    const id = randomUUID5();
     const session = {
       id,
       config: { ...config, port: config.port || DEFAULT_PORT },
@@ -4366,7 +4840,7 @@ var RemoteSessionManager = class {
       } else if (config.password) {
         connectConfig.password = config.password;
       }
-      await new Promise((resolve9, reject) => {
+      await new Promise((resolve10, reject) => {
         const timeout = setTimeout(() => {
           reject(new Error(`Connection timeout to ${config.host}:${config.port}`));
         }, CONNECTION_TIMEOUT);
@@ -4375,7 +4849,7 @@ var RemoteSessionManager = class {
           session.status = "connected";
           session.connectedAt = /* @__PURE__ */ new Date();
           log.info(`Remote session ${id} connected to ${config.host}`);
-          resolve9();
+          resolve10();
         });
         client.on("error", (err) => {
           clearTimeout(timeout);
@@ -4406,7 +4880,7 @@ var RemoteSessionManager = class {
         throw new Error(`Session ${sessionId} is not connected (status: ${pooled.session.status})`);
       }
     }
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       pooled.client.exec(command, (err, stream) => {
         if (err) {
           reject(err);
@@ -4419,7 +4893,7 @@ var RemoteSessionManager = class {
         stream.stderr.on("data", (data) => stderrChunks.push(data));
         stream.on("close", (code) => {
           exitCode = code ?? 0;
-          resolve9({
+          resolve10({
             stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
             stderr: Buffer.concat(stderrChunks).toString("utf-8"),
             exitCode
@@ -4431,20 +4905,20 @@ var RemoteSessionManager = class {
   async downloadFile(sessionId, remotePath, localPath) {
     const pooled = this.getSessionOrThrow(sessionId);
     const sftp = await this.getSftp(pooled);
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       sftp.fastGet(remotePath, localPath, (err) => {
         if (err) reject(err);
-        else resolve9();
+        else resolve10();
       });
     });
   }
   async uploadFile(sessionId, localPath, remotePath) {
     const pooled = this.getSessionOrThrow(sessionId);
     const sftp = await this.getSftp(pooled);
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       sftp.fastPut(localPath, remotePath, (err) => {
         if (err) reject(err);
-        else resolve9();
+        else resolve10();
       });
     });
   }
@@ -4479,12 +4953,12 @@ var RemoteSessionManager = class {
   }
   async getSftp(pooled) {
     if (pooled.sftp) return pooled.sftp;
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       pooled.client.sftp((err, sftp) => {
         if (err) reject(err);
         else {
           pooled.sftp = sftp;
-          resolve9(sftp);
+          resolve10(sftp);
         }
       });
     });
@@ -4501,7 +4975,7 @@ var RemoteSessionManager = class {
         return true;
       } catch {
         if (attempt < MAX_RECONNECT_ATTEMPTS) {
-          await new Promise((resolve9) => setTimeout(resolve9, RECONNECT_DELAY_MS * attempt));
+          await new Promise((resolve10) => setTimeout(resolve10, RECONNECT_DELAY_MS * attempt));
         }
       }
     }
@@ -5140,6 +5614,196 @@ var MemoryTool = class extends BaseTool {
   }
 };
 
+// src/tools/builtins/tool-search-tool.ts
+import { z as z20 } from "zod";
+var inputSchema = z20.object({
+  query: z20.string().describe("Search query \u2014 matches against tool name, aliases, description, and searchHint"),
+  limit: z20.number().min(1).max(20).optional().describe("Maximum results to return (default: 10)")
+});
+var ToolSearchTool = class extends BaseTool {
+  name = "tool_search";
+  aliases = ["search-tools", "find-tool"];
+  description = "Search available tools by keyword. Returns matching tools with name, description, and usage hints.";
+  searchHint = "discover find lookup explore tools capabilities";
+  inputSchema = inputSchema;
+  riskLevel = "readonly";
+  concurrencySafe = true;
+  readOnly = true;
+  getRegistry;
+  constructor(registry) {
+    super();
+    this.getRegistry = registry;
+  }
+  async execute(input, _context) {
+    const registry = this.getRegistry();
+    const results = registry.search(input.query);
+    const limit = input.limit ?? 10;
+    const limited = results.slice(0, limit);
+    if (limited.length === 0) {
+      return `No tools found matching "${input.query}". Use 'list' to see all available tools.`;
+    }
+    const lines = limited.map((tool) => {
+      const aliasStr = tool.aliases?.length ? ` (aliases: ${tool.aliases.join(", ")})` : "";
+      const hintStr = tool.searchHint ? ` [${tool.searchHint}]` : "";
+      return `\u2022 ${tool.name}${aliasStr}: ${tool.description}${hintStr}`;
+    });
+    return `Found ${results.length} tool(s) matching "${input.query}":
+${lines.join("\n")}`;
+  }
+};
+
+// src/tools/builtins/background-bash-tool.ts
+import { z as z21 } from "zod";
+var bashSchema = z21.object({
+  command: z21.string().describe("Shell command to run in background"),
+  cwd: z21.string().optional().describe("Working directory")
+});
+var BackgroundBashTool = class extends BaseTool {
+  name = "background_bash";
+  aliases = ["bg-bash", "async-bash"];
+  description = "Run a shell command in the background. Returns a task ID for checking output later.";
+  searchHint = "background async shell command run execute";
+  inputSchema = bashSchema;
+  riskLevel = "destructive";
+  concurrencySafe = true;
+  readOnly = false;
+  getManager;
+  constructor(manager) {
+    super();
+    this.getManager = manager;
+  }
+  async execute(input, _context) {
+    const manager = this.getManager();
+    const task = manager.startTask(input.command, [], input.cwd);
+    return [
+      `Background task started:`,
+      `  Task ID: ${task.id}`,
+      `  Command: ${input.command}`,
+      `  Status: ${task.status}`,
+      "",
+      `Use task_output with task_id "${task.id}" to check progress.`,
+      `Use task_stop with task_id "${task.id}" to cancel.`
+    ].join("\n");
+  }
+};
+
+// src/tools/builtins/task-list-tool.ts
+import { z as z22 } from "zod";
+var listSchema = z22.object({
+  status: z22.enum(["pending", "running", "completed", "failed", "cancelled"]).optional().describe("Filter by task status")
+});
+var TaskListTool = class extends BaseTool {
+  name = "task_list";
+  aliases = ["list-tasks", "tasks"];
+  description = "List background tasks and their statuses.";
+  searchHint = "list background tasks status";
+  inputSchema = listSchema;
+  riskLevel = "readonly";
+  concurrencySafe = true;
+  readOnly = true;
+  getManager;
+  constructor(manager) {
+    super();
+    this.getManager = manager;
+  }
+  async execute(input, _context) {
+    const manager = this.getManager();
+    const tasks = manager.listTasks(input.status);
+    if (tasks.length === 0) {
+      return "No tasks found.";
+    }
+    const lines = tasks.map((t) => {
+      const age = t.completedAt ? `${Math.round((t.completedAt - t.createdAt) / 1e3)}s` : `${Math.round((Date.now() - t.createdAt) / 1e3)}s`;
+      return `\u2022 ${t.id.slice(0, 8)}\u2026 [${t.status}] ${t.command} ${t.args.join(" ")} (${age})`;
+    });
+    return `Tasks (${tasks.length}):
+${lines.join("\n")}`;
+  }
+};
+
+// src/tools/builtins/task-output-tool.ts
+import { z as z23 } from "zod";
+var outputSchema = z23.object({
+  task_id: z23.string().describe("ID of the background task")
+});
+var TaskOutputTool = class extends BaseTool {
+  name = "task_output";
+  aliases = ["get-task-output"];
+  description = "Get the output of a background task. Returns current status and accumulated output.";
+  searchHint = "background task result output status";
+  inputSchema = outputSchema;
+  riskLevel = "readonly";
+  concurrencySafe = true;
+  readOnly = true;
+  getManager;
+  constructor(manager) {
+    super();
+    this.getManager = manager;
+  }
+  async execute(input, _context) {
+    const manager = this.getManager();
+    const task = manager.getTask(input.task_id);
+    if (!task) {
+      return `Task not found: ${input.task_id}. Use task_list to see available tasks.`;
+    }
+    const lines = [
+      `Task: ${task.id}`,
+      `Command: ${task.command} ${task.args.join(" ")}`,
+      `Status: ${task.status}`,
+      `Exit Code: ${task.exitCode ?? "N/A"}`,
+      `Created: ${new Date(task.createdAt).toISOString()}`
+    ];
+    if (task.progress > 0) {
+      lines.push(`Progress: ${task.progress}%`);
+    }
+    if (task.completedAt) {
+      lines.push(`Completed: ${new Date(task.completedAt).toISOString()}`);
+    }
+    if (task.error) {
+      lines.push("", "--- Error ---", task.error);
+    }
+    if (task.result) {
+      lines.push("", "--- Result ---", task.result);
+    }
+    if (task.output) {
+      lines.push("", "--- Output ---", task.output);
+    }
+    if (!task.output && !task.result && !task.error) {
+      lines.push("", "(no output yet)");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/tools/builtins/task-stop-tool.ts
+import { z as z24 } from "zod";
+var stopSchema = z24.object({
+  task_id: z24.string().describe("ID of the background task to stop")
+});
+var TaskStopTool = class extends BaseTool {
+  name = "task_stop";
+  aliases = ["stop-task", "cancel-task"];
+  description = "Stop a running background task. Sends SIGTERM to the process.";
+  searchHint = "stop cancel kill background task";
+  inputSchema = stopSchema;
+  riskLevel = "destructive";
+  concurrencySafe = false;
+  readOnly = false;
+  getManager;
+  constructor(manager) {
+    super();
+    this.getManager = manager;
+  }
+  async execute(input, _context) {
+    const manager = this.getManager();
+    const stopped = manager.stopTask(input.task_id);
+    if (stopped) {
+      return `Task ${input.task_id} stopped successfully.`;
+    }
+    return `Failed to stop task ${input.task_id}. Task may not exist or not be running.`;
+  }
+};
+
 // src/services/auto-mode.ts
 var DEFAULT_READONLY_TOOLS = [
   "file_read",
@@ -5387,7 +6051,7 @@ var ContextWindowManager = class {
 import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
 import { join as join8 } from "path";
 import { tmpdir as tmpdir2 } from "os";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var MAX_RESULT_SIZE_CHARS = 5e4;
 var MAX_RESULTS_PER_MESSAGE_CHARS = 2e5;
 var PREVIEW_LENGTH = 500;
@@ -5395,7 +6059,7 @@ var TOOL_RESULTS_SUBDIR = "cliskill-tool-results";
 var sessionDir = null;
 async function getSessionDir() {
   if (!sessionDir) {
-    sessionDir = join8(tmpdir2(), TOOL_RESULTS_SUBDIR, randomUUID5());
+    sessionDir = join8(tmpdir2(), TOOL_RESULTS_SUBDIR, randomUUID6());
     await mkdir3(sessionDir, { recursive: true });
   }
   return sessionDir;
@@ -5415,7 +6079,7 @@ async function persistLargeResult(content, toolName) {
     return { persisted: false, content };
   }
   const dir = await getSessionDir();
-  const fileName = `${toolName}-${Date.now()}-${randomUUID5().slice(0, 8)}.txt`;
+  const fileName = `${toolName}-${Date.now()}-${randomUUID6().slice(0, 8)}.txt`;
   const filePath = join8(dir, fileName);
   await writeFile4(filePath, content, "utf-8");
   const preview = content.slice(0, PREVIEW_LENGTH);
@@ -5463,6 +6127,249 @@ async function applyResultBudget(results) {
   return output;
 }
 
+// src/tasks/manager.ts
+import { randomUUID as randomUUID7 } from "crypto";
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+var MAX_COMPLETED_TASKS = 50;
+var TaskManager = class extends EventEmitter {
+  tasks = /* @__PURE__ */ new Map();
+  completedOrder = [];
+  /** Create a generic task entry (for agent/shell tasks via executor) */
+  createTask(options) {
+    const id = `task_${randomUUID7()}`;
+    const task = {
+      id,
+      name: options.name,
+      description: options.description,
+      type: options.type,
+      status: "pending",
+      progress: 0,
+      result: null,
+      error: null,
+      output: "",
+      exitCode: null,
+      createdAt: Date.now(),
+      completedAt: null,
+      command: options.name,
+      args: []
+    };
+    this.tasks.set(id, task);
+    return id;
+  }
+  /** Start a shell task with a spawned child process */
+  startTask(command, args = [], cwd2) {
+    const id = `task_${randomUUID7()}`;
+    const task = {
+      id,
+      name: command,
+      description: args.join(" "),
+      type: "shell",
+      status: "running",
+      progress: 0,
+      result: null,
+      error: null,
+      output: "",
+      exitCode: null,
+      createdAt: Date.now(),
+      completedAt: null,
+      command,
+      args
+    };
+    const child = spawn(command, args, {
+      cwd: cwd2 ?? process.cwd(),
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    task.process = child;
+    child.stdout?.on("data", (data) => {
+      task.output += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      task.output += data.toString();
+    });
+    child.on("close", (code) => {
+      task.status = code === 0 ? "completed" : "failed";
+      task.exitCode = code;
+      task.completedAt = Date.now();
+      task.process = void 0;
+      this.completedOrder.push(id);
+      this.evictOldTasks();
+      this.emit("onStatusChange", id, task.status);
+    });
+    child.on("error", (err) => {
+      task.status = "failed";
+      task.output += `
+Error: ${err.message}`;
+      task.exitCode = -1;
+      task.completedAt = Date.now();
+      task.process = void 0;
+      this.emit("onStatusChange", id, "failed");
+    });
+    this.tasks.set(id, task);
+    this.emit("onStatusChange", id, "running");
+    return task;
+  }
+  getTask(id) {
+    return this.tasks.get(id);
+  }
+  stopTask(id) {
+    const task = this.tasks.get(id);
+    if (!task || task.status !== "running" || !task.process) return false;
+    task.process.kill("SIGTERM");
+    task.status = "cancelled";
+    task.completedAt = Date.now();
+    task.process = void 0;
+    this.emit("onStatusChange", id, "cancelled");
+    return true;
+  }
+  /** Update task status (for agent/shell tasks via executor) */
+  updateStatus(id, status) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.status = status;
+    if (status === "completed" || status === "failed" || status === "cancelled") {
+      task.completedAt = Date.now();
+    }
+    this.emit("onStatusChange", id, status);
+  }
+  /** Update task progress percentage (for agent tasks) */
+  updateProgress(id, progress, message) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.progress = Math.max(0, Math.min(100, progress));
+    this.emit("onProgress", id, task.progress, message);
+  }
+  /** Cancel a task (for agent/shell tasks via executor) */
+  cancelTask(id) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    if (task.process) {
+      task.process.kill("SIGTERM");
+      task.process = void 0;
+    }
+    task.status = "cancelled";
+    task.completedAt = Date.now();
+    this.emit("onStatusChange", id, "cancelled");
+  }
+  /** Set error result on a task */
+  setError(id, error) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.error = error;
+    task.status = "failed";
+    task.completedAt = Date.now();
+    this.emit("onStatusChange", id, "failed");
+    this.emit("onError", id, error);
+  }
+  /** Set success result on a task */
+  setResult(id, result) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.result = result;
+    task.status = "completed";
+    task.completedAt = Date.now();
+    this.completedOrder.push(id);
+    this.evictOldTasks();
+    this.emit("onStatusChange", id, "completed");
+    this.emit("onComplete", id, result);
+  }
+  /** Remove a completed/failed/cancelled task */
+  removeTask(id) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    if (task.status === "running") {
+      throw new Error("Cannot remove running task");
+    }
+    this.tasks.delete(id);
+    const idx = this.completedOrder.indexOf(id);
+    if (idx >= 0) this.completedOrder.splice(idx, 1);
+  }
+  /** Clear all completed/failed/cancelled tasks */
+  clearCompleted() {
+    for (const [id, task] of this.tasks) {
+      if (task.status !== "running" && task.status !== "pending") {
+        this.tasks.delete(id);
+      }
+    }
+    this.completedOrder = this.completedOrder.filter((id) => this.tasks.has(id));
+  }
+  /** Count of active (pending + running) tasks */
+  getActiveCount() {
+    let count = 0;
+    for (const task of this.tasks.values()) {
+      if (task.status === "pending" || task.status === "running") count++;
+    }
+    return count;
+  }
+  listTasks(filter) {
+    const all = Array.from(this.tasks.values());
+    const status = typeof filter === "string" ? filter : filter?.status;
+    if (status) return all.filter((t) => t.status === status);
+    return all;
+  }
+  /** Type-safe event listener */
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  evictOldTasks() {
+    while (this.completedOrder.length > MAX_COMPLETED_TASKS) {
+      const oldestId = this.completedOrder.shift();
+      if (oldestId) this.tasks.delete(oldestId);
+    }
+  }
+};
+
+// src/memory/project-scanner.ts
+import { readFile as readFile8, stat as stat3 } from "fs/promises";
+import { join as join9, resolve as resolve8, dirname as dirname2 } from "path";
+import { existsSync as existsSync4 } from "fs";
+var MEMORY_FILENAMES = [".cliskill.md", "CLAUDE.md", ".claude.md"];
+async function scanProjectMemory(cwd2) {
+  const results = [];
+  const visitedDirs = /* @__PURE__ */ new Set();
+  let currentDir = resolve8(cwd2);
+  for (let i = 0; i < 20; i++) {
+    if (visitedDirs.has(currentDir)) break;
+    visitedDirs.add(currentDir);
+    for (const filename of MEMORY_FILENAMES) {
+      const filePath = join9(currentDir, filename);
+      if (existsSync4(filePath)) {
+        try {
+          const content = await readFile8(filePath, "utf-8");
+          const fileStat = await stat3(filePath);
+          results.push({
+            content: content.trim(),
+            filePath,
+            modifiedAt: fileStat.mtimeMs
+          });
+        } catch {
+        }
+      }
+    }
+    const parent = dirname2(currentDir);
+    if (parent === currentDir) break;
+    currentDir = parent;
+  }
+  return results;
+}
+async function loadProjectMemoryPrompt(cwd2) {
+  const memories = await scanProjectMemory(cwd2);
+  if (memories.length === 0) return "";
+  const sections = memories.map((m) => {
+    const relativePath = m.filePath.startsWith(cwd2) ? m.filePath.slice(cwd2.length + 1) : m.filePath;
+    return `### ${relativePath}
+${m.content}`;
+  });
+  return [
+    "<project-memory>",
+    "The following project-level instructions were found in memory files:",
+    "",
+    ...sections,
+    "</project-memory>"
+  ].join("\n");
+}
+
 // src/core/loop.ts
 var MAX_TURNS = 50;
 var MAX_CONSECUTIVE_TOOL_ERRORS = 3;
@@ -5470,11 +6377,11 @@ var MAX_TOOL_OUTPUT_CHARS = 5e4;
 var MIN_OUTPUT_TOKENS = 16384;
 var MAX_OUTPUT_TOKENS_RECOVERY_LIMIT = 3;
 var ESCALATED_MAX_TOKENS = 65536;
-function sanitizeToolOutput(output) {
+function sanitizeToolOutput(output, maxChars = MAX_TOOL_OUTPUT_CHARS) {
   const sanitized = output.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
-  if (sanitized.length <= MAX_TOOL_OUTPUT_CHARS) return sanitized;
-  const truncated = sanitized.slice(0, MAX_TOOL_OUTPUT_CHARS);
-  const omitted = sanitized.length - MAX_TOOL_OUTPUT_CHARS;
+  if (sanitized.length <= maxChars) return sanitized;
+  const truncated = sanitized.slice(0, maxChars);
+  const omitted = sanitized.length - maxChars;
   return `${truncated}
 
 ... [truncated ${omitted} characters]`;
@@ -5524,7 +6431,8 @@ ${result.summary}` }]
     content: [{ type: "text", text: userMessage }]
   });
   const toolDefs = toolRegistry.getToolDefinitions();
-  const effectiveSystemPrompt = systemPrompt + fastMode.getSystemPromptModifier();
+  const projectMemory = await loadProjectMemoryPrompt(cwd2);
+  const effectiveSystemPrompt = systemPrompt + fastMode.getSystemPromptModifier() + (projectMemory ? "\n\n" + projectMemory : "");
   const toolContext = {
     cwd: cwd2,
     abortSignal,
@@ -5540,7 +6448,7 @@ ${result.summary}` }]
     state.turnCount++;
     const delay = fastMode.getInterTurnDelay();
     if (delay > 0) {
-      await new Promise((resolve9) => setTimeout(resolve9, delay));
+      await new Promise((resolve10) => setTimeout(resolve10, delay));
     }
     if (state.messages.length > 10) {
       const compactionInput = state.messages.map((m) => ({
@@ -5683,19 +6591,39 @@ ${result.summary}` }]
         for (const toolCall of toolCalls) {
           executor.addTool(toolCall);
         }
-        for await (const result of executor.getRemainingResults()) {
-          toolResults.push(result.toolResult);
-          yield result.event;
-          if (result.toolResult.isError) hadError = true;
+        for await (const execEvent of executor.getRemainingResults()) {
+          if ("toolResult" in execEvent) {
+            toolResults.push(execEvent.toolResult);
+            yield execEvent.event;
+            if (execEvent.toolResult.isError) hadError = true;
+          } else {
+            const p = execEvent.progress;
+            yield { type: "tool_progress", toolName: p.toolName, toolId: p.toolId, message: p.message };
+          }
         }
       } else {
+        const progressBuffer = [];
+        const singleToolContext = {
+          ...toolContext,
+          onProgress: (message) => {
+            progressBuffer.push({
+              type: "tool_progress",
+              toolName: toolCalls[0].name,
+              toolId: toolCalls[0].id,
+              message
+            });
+          }
+        };
         const result = await executeToolCall(
           toolCalls[0],
           toolRegistry,
-          toolContext,
+          singleToolContext,
           autoMode,
           onPermissionRequest
         );
+        for (const progressEvent of progressBuffer) {
+          yield progressEvent;
+        }
         toolResults.push(result.toolResult);
         yield result.event;
         if (result.toolResult.isError) hadError = true;
@@ -5734,12 +6662,20 @@ ${result.summary}` }]
         }
       }
     } catch (err) {
-      const errMsg = err.message ?? String(err);
-      if (errMsg.includes("529") || errMsg.includes("503") || errMsg.includes("Overloaded")) {
+      const lastAssistantContent = state.messages.length > 0 && state.messages[state.messages.length - 1].role === "assistant" ? state.messages[state.messages.length - 1].content : [];
+      const pendingToolCalls = extractToolCalls(lastAssistantContent);
+      const pendingResults = createMissingToolResults(
+        pendingToolCalls,
+        `Request failed: ${err.message}`
+      );
+      if (pendingResults.length > 0) {
+        state.messages.push({ role: "user", content: pendingResults });
+      }
+      if (isFallbackTriggeredError(err)) {
         yield {
           type: "error",
           error: new Error(
-            "Model is currently overloaded (529/503). The adapter will automatically retry. If this persists, try a different model."
+            "Model is currently overloaded (529/503). Fallback chain will be attempted on next request. If this persists, configure fallbackChain in config or try a different model."
           )
         };
       } else {
@@ -5795,15 +6731,13 @@ function summarizeOldToolResults(messages, keepRecent) {
   }
   return compressed;
 }
-var TOKEN_BUDGET_WARNING_THRESHOLD = 0.8;
-var TOKEN_BUDGET_CRITICAL_THRESHOLD = 0.95;
 function checkTokenBudget(inputTokens, outputTokens, maxContextTokens) {
   const totalTokens = inputTokens + outputTokens;
-  const usagePercent = totalTokens / maxContextTokens;
+  const state = calculateTokenWarningState(totalTokens, maxContextTokens);
   return {
-    usagePercent,
-    shouldNudge: usagePercent > TOKEN_BUDGET_WARNING_THRESHOLD && usagePercent <= TOKEN_BUDGET_CRITICAL_THRESHOLD,
-    shouldBlock: usagePercent > TOKEN_BUDGET_CRITICAL_THRESHOLD
+    usagePercent: state.usagePercent,
+    shouldNudge: state.isWarning || state.isError,
+    shouldBlock: state.shouldAutoCompact
   };
 }
 function runStopHooks(assistantContent, consecutiveErrors, turnCount) {
@@ -5869,7 +6803,8 @@ async function executeToolCall(toolCall, toolRegistry, toolContext, autoMode, on
   try {
     const validatedInput = tool.inputSchema.parse(toolCall.input);
     const rawResult = await tool.execute(validatedInput, toolContext);
-    const result = sanitizeToolOutput(rawResult);
+    const maxChars = tool.maxResultSizeChars ?? MAX_TOOL_OUTPUT_CHARS;
+    const result = sanitizeToolOutput(rawResult, maxChars);
     return {
       toolResult: {
         type: "tool_result",
@@ -5934,6 +6869,12 @@ function createDefaultToolRegistry(modelRouter) {
   registry.register(new RemoteTool());
   registry.register(new WorktreeTool());
   registry.register(new MemoryTool());
+  registry.register(new ToolSearchTool(() => registry));
+  const taskManager = new TaskManager();
+  registry.register(new BackgroundBashTool(() => taskManager));
+  registry.register(new TaskListTool(() => taskManager));
+  registry.register(new TaskOutputTool(() => taskManager));
+  registry.register(new TaskStopTool(() => taskManager));
   if (modelRouter) {
     const agentTool = new AgentTool(
       () => modelRouter,
@@ -5943,12 +6884,20 @@ function createDefaultToolRegistry(modelRouter) {
   }
   return registry;
 }
+function createMissingToolResults(toolCalls, errorMessage) {
+  return toolCalls.map((tc) => ({
+    type: "tool_result",
+    toolUseId: tc.id,
+    content: `Error: ${errorMessage}`,
+    isError: true
+  }));
+}
 
 // src/ui/ink-app.tsx
 import { useState, useEffect, useCallback, useRef, useMemo, memo } from "react";
 import { Box, Text, render, useInput, useApp, useStdout } from "ink";
 import { readdirSync } from "fs";
-import { join as join9, basename as basename2, dirname as dirname2 } from "path";
+import { join as join10, basename as basename2, dirname as dirname3 } from "path";
 import { exec as exec2, execSync as execSync2 } from "child_process";
 import { jsx, jsxs } from "react/jsx-runtime";
 var C = {
@@ -6354,7 +7303,7 @@ var InputBar = memo(function InputBar2({ input, active }) {
     active && /* @__PURE__ */ jsx(Text, { color: C.primary, children: "\u258E" })
   ] });
 });
-function InkApp({ model, toolCount, onSubmit }) {
+function InkApp({ model, toolCount, onSubmit, onCancel }) {
   const { exit } = useApp();
   const { stdout } = useStdout();
   const terminalHeight = stdout?.rows ?? 24;
@@ -6521,16 +7470,16 @@ function InkApp({ model, toolCount, onSubmit }) {
         const selected = currentFiles[selectedIdx];
         if (selected) {
           if (selected.isDir) {
-            setFileCwd(join9(fileCwd, selected.name));
+            setFileCwd(join10(fileCwd, selected.name));
             setSelectedIdx(0);
           } else {
-            openInEditor(join9(fileCwd, selected.name));
+            openInEditor(join10(fileCwd, selected.name));
           }
         }
         return;
       }
       if (key.backspace || key.delete) {
-        const parent = dirname2(fileCwd);
+        const parent = dirname3(fileCwd);
         if (parent !== fileCwd) {
           setFileCwd(parent);
           setSelectedIdx(0);
@@ -6544,6 +7493,10 @@ function InkApp({ model, toolCount, onSubmit }) {
       return;
     }
     if (key.escape) {
+      if (loading && onCancel) {
+        onCancel();
+        return;
+      }
       exit();
       return;
     }
@@ -6665,8 +7618,8 @@ function MessageList({ messages }) {
 
 // src/ui/repl.ts
 import { mkdir as mkdir4, appendFile } from "fs/promises";
-import { join as join10 } from "path";
-import { randomUUID as randomUUID6 } from "crypto";
+import { join as join12 } from "path";
+import { randomUUID as randomUUID8 } from "crypto";
 
 // src/prompts/system-prompt.ts
 import { hostname } from "os";
@@ -6811,15 +7764,424 @@ function buildSystemPrompt() {
   ].join("\n\n");
 }
 
+// src/mcp/client.ts
+import { spawn as spawn2 } from "child_process";
+import { createInterface } from "readline";
+var REQUEST_TIMEOUT = 3e4;
+var MCPClient = class {
+  config;
+  process = null;
+  rl = null;
+  connected = false;
+  nextId = 1;
+  pendingRequests = /* @__PURE__ */ new Map();
+  buffer = "";
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected) return;
+    const env = {
+      ...process.env,
+      ...this.config.env
+    };
+    this.process = spawn2(this.config.command, this.config.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    this.process.on("error", (err) => {
+      this.cleanup();
+      throw err;
+    });
+    this.process.on("exit", () => {
+      this.cleanup();
+    });
+    if (!this.process.stdout) {
+      throw new Error("MCP server stdout is not available");
+    }
+    this.rl = createInterface({ input: this.process.stdout });
+    this.rl.on("line", (line) => {
+      this.handleLine(line);
+    });
+    if (this.process.stderr) {
+      this.process.stderr.on("data", () => {
+      });
+    }
+    await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "cliskill", version: "1.0.0" }
+    });
+    this.sendNotification("notifications/initialized", {});
+    this.connected = true;
+  }
+  async disconnect() {
+    if (!this.process) return;
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Connection closed"));
+    }
+    this.pendingRequests.clear();
+    this.process.kill("SIGTERM");
+    this.cleanup();
+  }
+  async listTools() {
+    const response = await this.sendRequest("tools/list", {});
+    const result = response.result;
+    return result?.tools ?? [];
+  }
+  async callTool(name, args) {
+    const response = await this.sendRequest("tools/call", { name, arguments: args });
+    return response.result;
+  }
+  async listResources() {
+    const response = await this.sendRequest("resources/list", {});
+    const result = response.result;
+    return result?.resources ?? [];
+  }
+  async readResource(uri) {
+    const response = await this.sendRequest("resources/read", { uri });
+    return response.result;
+  }
+  async listPrompts() {
+    const response = await this.sendRequest("prompts/list", {});
+    const result = response.result;
+    return result?.prompts ?? [];
+  }
+  isConnected() {
+    return this.connected;
+  }
+  sendRequest(method, params) {
+    return new Promise((resolve10, reject) => {
+      if (!this.process?.stdin) {
+        reject(new Error("MCP server not connected"));
+        return;
+      }
+      const id = this.nextId++;
+      const request = { jsonrpc: "2.0", id, method, params };
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout: ${method} (id=${id})`));
+      }, REQUEST_TIMEOUT);
+      this.pendingRequests.set(id, { resolve: resolve10, reject, timer });
+      const data = JSON.stringify(request) + "\n";
+      this.process.stdin.write(data, (err) => {
+        if (err) {
+          clearTimeout(timer);
+          this.pendingRequests.delete(id);
+          reject(err);
+        }
+      });
+    });
+  }
+  sendNotification(method, params) {
+    if (!this.process?.stdin) return;
+    const notification = { jsonrpc: "2.0", method, params };
+    const data = JSON.stringify(notification) + "\n";
+    this.process.stdin.write(data);
+  }
+  handleLine(line) {
+    this.buffer += line;
+    let response;
+    try {
+      response = JSON.parse(this.buffer);
+    } catch {
+      return;
+    } finally {
+      this.buffer = "";
+    }
+    if (response.id !== void 0 && response.id !== null) {
+      const pending = this.pendingRequests.get(response.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(response.id);
+        pending.resolve(response);
+      }
+    }
+  }
+  cleanup() {
+    this.connected = false;
+    this.rl?.close();
+    this.rl = null;
+    this.process = null;
+    this.buffer = "";
+  }
+};
+
+// src/mcp/manager.ts
+var MCPConnectionManager = class {
+  clients = /* @__PURE__ */ new Map();
+  async addServer(config) {
+    const client = new MCPClient(config);
+    await client.connect();
+    this.clients.set(config.name, client);
+  }
+  async removeServer(name) {
+    const client = this.clients.get(name);
+    if (client) {
+      await client.disconnect();
+      this.clients.delete(name);
+    }
+  }
+  getConnectedServers() {
+    return Array.from(this.clients.entries()).filter(([, client]) => client.isConnected()).map(([name]) => name);
+  }
+  async getAllTools() {
+    const allTools = [];
+    for (const [, client] of this.clients) {
+      if (!client.isConnected()) continue;
+      try {
+        const tools = await client.listTools();
+        allTools.push(...tools);
+      } catch {
+      }
+    }
+    return allTools;
+  }
+  async callTool(serverName, toolName, args) {
+    const client = this.clients.get(serverName);
+    if (!client) {
+      throw new Error(`MCP server "${serverName}" not found`);
+    }
+    if (!client.isConnected()) {
+      throw new Error(`MCP server "${serverName}" is not connected`);
+    }
+    return client.callTool(toolName, args);
+  }
+  async getToolsForServer(serverName) {
+    const client = this.clients.get(serverName);
+    if (!client || !client.isConnected()) {
+      return [];
+    }
+    return client.listTools();
+  }
+  async disconnectAll() {
+    for (const [, client] of this.clients) {
+      try {
+        await client.disconnect();
+      } catch {
+      }
+    }
+    this.clients.clear();
+  }
+};
+
+// src/mcp/mcp-tool-adapter.ts
+import { z as z25 } from "zod";
+var MCPToolAdapter = class {
+  name;
+  description;
+  inputSchema;
+  riskLevel = "safe";
+  concurrencySafe = true;
+  readOnly = true;
+  serverName;
+  mcpManager;
+  rawInputSchema;
+  constructor(serverName, toolName, description, inputSchema2, mcpManager) {
+    this.name = `mcp_${serverName}_${toolName}`;
+    this.description = description;
+    this.serverName = serverName;
+    this.mcpManager = mcpManager;
+    this.rawInputSchema = inputSchema2;
+    this.inputSchema = this.buildZodSchema(inputSchema2);
+  }
+  async execute(input, context) {
+    const allowed = await context.checkPermission(this.name, JSON.stringify(input));
+    if (!allowed) {
+      return `Error: Permission denied for MCP tool: ${this.name}`;
+    }
+    try {
+      const result = await this.mcpManager.callTool(this.serverName, this.getOriginalName(), input);
+      return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    } catch (err) {
+      return `Error calling MCP tool ${this.name}: ${err.message}`;
+    }
+  }
+  toToolDefinition() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.rawInputSchema
+    };
+  }
+  getOriginalName() {
+    const parts = this.name.split("_");
+    return parts.slice(2).join("_");
+  }
+  getServerName() {
+    return this.serverName;
+  }
+  buildZodSchema(jsonSchema) {
+    const properties = jsonSchema.properties ?? {};
+    const required = new Set(jsonSchema.required ?? []);
+    const shape = {};
+    for (const [key, propSchema] of Object.entries(properties)) {
+      const zodType = this.jsonSchemaPropertyToZod(propSchema);
+      shape[key] = required.has(key) ? zodType : zodType.optional();
+    }
+    return z25.object(shape);
+  }
+  jsonSchemaPropertyToZod(prop) {
+    const type = prop.type;
+    switch (type) {
+      case "string":
+        if (prop.enum) return z25.enum(prop.enum);
+        return z25.string();
+      case "number":
+      case "integer":
+        return z25.number();
+      case "boolean":
+        return z25.boolean();
+      case "array":
+        if (prop.items && typeof prop.items === "object") {
+          return z25.array(this.jsonSchemaPropertyToZod(prop.items));
+        }
+        return z25.array(z25.unknown());
+      case "object":
+        if (prop.properties && typeof prop.properties === "object") {
+          return this.buildZodSchema(prop);
+        }
+        return z25.record(z25.unknown());
+      default:
+        return z25.unknown();
+    }
+  }
+};
+async function registerMCPTools(mcpManager, registerFn) {
+  const registered = [];
+  for (const serverName of mcpManager.getConnectedServers()) {
+    try {
+      const tools = await mcpManager.getToolsForServer(serverName);
+      for (const tool of tools) {
+        const adapter = new MCPToolAdapter(
+          serverName,
+          tool.name,
+          tool.description ?? `MCP tool: ${tool.name}`,
+          tool.inputSchema,
+          mcpManager
+        );
+        registerFn(adapter);
+        registered.push(adapter.name);
+      }
+    } catch {
+    }
+  }
+  return registered;
+}
+
+// src/services/session-recovery.ts
+import { readFile as readFile9, readdir as readdir5 } from "fs/promises";
+import { join as join11 } from "path";
+import { existsSync as existsSync5 } from "fs";
+async function recoverSession(filePath) {
+  const raw = await readFile9(filePath, "utf-8");
+  const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+  const entries = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type && entry.content !== void 0) {
+        entries.push(entry);
+      }
+    } catch {
+    }
+  }
+  const messages = reconstructMessages(entries);
+  const firstEntry = entries[0];
+  const timestamp = firstEntry?.timestamp ?? 0;
+  return {
+    sessionId: filePath,
+    filePath,
+    timestamp,
+    messages,
+    entryCount: entries.length
+  };
+}
+async function listSessions(limit = 20) {
+  const dir = getSessionsDir();
+  if (!existsSync5(dir)) return [];
+  const files = await readdir5(dir);
+  const sessionFiles = files.filter((f) => f.startsWith("session-") && f.endsWith(".jsonl"));
+  const sessions = [];
+  for (const fileName of sessionFiles) {
+    const filePath = join11(dir, fileName);
+    try {
+      const raw = await readFile9(filePath, "utf-8");
+      const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+      let lastActivity = 0;
+      let entryCount = 0;
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.timestamp && entry.timestamp > lastActivity) {
+            lastActivity = entry.timestamp;
+          }
+          entryCount++;
+        } catch {
+        }
+      }
+      const dateStr = fileName.replace("session-", "").replace(".jsonl", "");
+      const fileTimestamp = Date.parse(dateStr) || lastActivity;
+      sessions.push({
+        fileName,
+        filePath,
+        timestamp: fileTimestamp,
+        entryCount,
+        lastActivity
+      });
+    } catch {
+    }
+  }
+  sessions.sort((a, b) => b.lastActivity - a.lastActivity);
+  return sessions.slice(0, limit);
+}
+async function findLatestSession() {
+  const sessions = await listSessions(1);
+  return sessions[0] ?? null;
+}
+function reconstructMessages(entries) {
+  const messages = [];
+  let i = 0;
+  while (i < entries.length) {
+    const entry = entries[i];
+    if (entry.type === "user") {
+      const content = [{ type: "text", text: entry.content }];
+      messages.push({ role: "user", content });
+      i++;
+    } else if (entry.type === "assistant") {
+      const content = [{ type: "text", text: entry.content }];
+      messages.push({ role: "assistant", content });
+      i++;
+    } else if (entry.type === "tool_use") {
+      const lastMsg = messages[messages.length - 1];
+      if (lastMsg && lastMsg.role === "assistant") {
+      }
+      i++;
+    } else if (entry.type === "tool_result") {
+      const content = [{
+        type: "tool_result",
+        toolUseId: `recovered-${i}`,
+        content: entry.content
+      }];
+      messages.push({ role: "user", content });
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return messages;
+}
+
 // src/ui/repl.ts
 var SessionSaver = class {
   filePath;
   sessionId;
   constructor() {
-    this.sessionId = randomUUID6();
+    this.sessionId = randomUUID8();
     const dir = getSessionsDir();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    this.filePath = join10(dir, `session-${timestamp}.jsonl`);
+    this.filePath = join12(dir, `session-${timestamp}.jsonl`);
   }
   async init() {
     const dir = getSessionsDir();
@@ -6857,6 +8219,36 @@ function buildModelRouter(adapterRegistry, config) {
     defaultModel: config.models.defaultModel
   });
 }
+async function connectMcpServers(config, toolRegistry) {
+  if (config.mcpServers.length === 0) return null;
+  const mcpManager = new MCPConnectionManager();
+  let connectedCount = 0;
+  for (const serverConfig of config.mcpServers) {
+    try {
+      await mcpManager.addServer({
+        name: serverConfig.name,
+        command: serverConfig.command,
+        args: serverConfig.args,
+        env: serverConfig.env,
+        transport: serverConfig.transport
+      });
+      connectedCount++;
+    } catch (err) {
+      console.error(`MCP server "${serverConfig.name}" connection failed: ${err.message}`);
+    }
+  }
+  if (connectedCount === 0) return mcpManager;
+  const registeredTools = await registerMCPTools(mcpManager, (tool) => {
+    try {
+      toolRegistry.register(tool);
+    } catch {
+    }
+  });
+  if (registeredTools.length > 0) {
+    console.log(`  MCP: ${connectedCount} server(s) connected, ${registeredTools.length} tool(s) loaded`);
+  }
+  return mcpManager;
+}
 async function runTuiRepl(config) {
   const adapterRegistry = new AdapterRegistry();
   for (const provider of config.providers) {
@@ -6869,12 +8261,15 @@ async function runTuiRepl(config) {
   const adapter = config.defaultProvider ? adapterRegistry.get(config.defaultProvider) : adapterRegistry.getAll()[0];
   const modelRouter = buildModelRouter(adapterRegistry, config);
   const toolRegistry = createDefaultToolRegistry(modelRouter);
+  const mcpManager = await connectMcpServers(config, toolRegistry);
   ensureDataDir();
   const sessionSaver = new SessionSaver();
   await sessionSaver.init();
   let sessionMessages = [];
+  let activeAbortController = new AbortController();
   const onSubmit = async (input, onEvent) => {
     if (!adapter) return;
+    activeAbortController = new AbortController();
     await sessionSaver.append({
       type: "user",
       content: input,
@@ -6887,7 +8282,7 @@ async function runTuiRepl(config) {
       config,
       systemPrompt: config.systemPrompt ?? buildSystemPrompt(),
       cwd: process.cwd(),
-      abortSignal: new AbortController().signal,
+      abortSignal: activeAbortController.signal,
       onPermissionRequest: async () => true,
       sessionHistory: sessionMessages
     })) {
@@ -6931,7 +8326,8 @@ async function runTuiRepl(config) {
   renderInkApp({
     model: adapter?.config.model ?? "N/A",
     toolCount: toolRegistry.getAll().length,
-    onSubmit
+    onSubmit,
+    onCancel: () => activeAbortController.abort()
   });
 }
 async function runBasicRepl(config) {
@@ -6963,13 +8359,14 @@ async function runBasicRepl(config) {
 `);
   }
   const toolRegistry = createDefaultToolRegistry(modelRouter);
+  await connectMcpServers(config, toolRegistry);
   const abortController = new AbortController();
   ensureDataDir();
   const sessionSaver = new SessionSaver();
   await sessionSaver.init();
   let sessionMessages = [];
-  const { createInterface } = await import("readline");
-  const rl = createInterface({
+  const { createInterface: createInterface2 } = await import("readline");
+  const rl = createInterface2({
     input: process.stdin,
     output: process.stdout,
     prompt: "> "
@@ -6991,6 +8388,42 @@ async function runBasicRepl(config) {
       rl.close();
       return;
     }
+    if (input === "/resume") {
+      try {
+        const latest = await findLatestSession();
+        if (!latest) {
+          console.log("  No previous sessions found.");
+          rl.prompt();
+          return;
+        }
+        const recovered = await recoverSession(latest.filePath);
+        sessionMessages = recovered.messages;
+        console.log(`  Resumed session from ${new Date(recovered.timestamp).toISOString()} (${recovered.entryCount} entries, ${recovered.messages.length} messages)`);
+      } catch (err) {
+        console.error(`  Failed to resume session: ${err.message}`);
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/sessions") {
+      try {
+        const sessions = await listSessions(10);
+        if (sessions.length === 0) {
+          console.log("  No sessions found.");
+        } else {
+          console.log("  Recent sessions:");
+          for (const s of sessions) {
+            const date = new Date(s.lastActivity).toLocaleString();
+            console.log(`    ${s.fileName} \u2014 ${s.entryCount} entries, last activity: ${date}`);
+          }
+          console.log("  Use /resume to restore the most recent session.");
+        }
+      } catch (err) {
+        console.error(`  Failed to list sessions: ${err.message}`);
+      }
+      rl.prompt();
+      return;
+    }
     if (!adapter) {
       console.log("[No provider configured]");
       rl.prompt();
@@ -7011,10 +8444,10 @@ async function runBasicRepl(config) {
         cwd: process.cwd(),
         abortSignal: abortController.signal,
         onPermissionRequest: async (operation, details) => {
-          return new Promise((resolve9) => {
+          return new Promise((resolve10) => {
             const detailStr = details ? ` (${details})` : "";
             rl.question(`  Allow ${operation}${detailStr}? [y/N]: `, (answer) => {
-              resolve9(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+              resolve10(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
             });
           });
         },
@@ -7499,9 +8932,9 @@ function colorizeAnsi(text, ansiName) {
 }
 
 // src/services/cron/task-store.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
-import { join as join11, dirname as dirname3 } from "path";
-import { randomUUID as randomUUID7 } from "crypto";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
+import { join as join13, dirname as dirname4 } from "path";
+import { randomUUID as randomUUID9 } from "crypto";
 var DEFAULT_STORE_DIR = getDataDir();
 var DEFAULT_STORE_FILE = "scheduled_tasks.json";
 var TaskStore2 = class {
@@ -7510,10 +8943,10 @@ var TaskStore2 = class {
   loaded = false;
   constructor(storeDir) {
     const dir = storeDir ?? DEFAULT_STORE_DIR;
-    this.filePath = join11(dir, DEFAULT_STORE_FILE);
+    this.filePath = join13(dir, DEFAULT_STORE_FILE);
   }
   load() {
-    if (!existsSync4(this.filePath)) {
+    if (!existsSync6(this.filePath)) {
       this.tasks.clear();
       this.loaded = true;
       return;
@@ -7531,8 +8964,8 @@ var TaskStore2 = class {
     this.loaded = true;
   }
   save() {
-    const dir = dirname3(this.filePath);
-    if (!existsSync4(dir)) {
+    const dir = dirname4(this.filePath);
+    if (!existsSync6(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
     const data = Array.from(this.tasks.values());
@@ -7546,7 +8979,7 @@ var TaskStore2 = class {
   addTask(expression, prompt, type = "recurring", nextRun = null) {
     this.ensureLoaded();
     const task = {
-      id: randomUUID7(),
+      id: randomUUID9(),
       expression,
       prompt,
       type,
@@ -7841,14 +9274,14 @@ var CronScheduler = class {
     }
   }
   delay(ms) {
-    return new Promise((resolve9) => setTimeout(resolve9, ms));
+    return new Promise((resolve10) => setTimeout(resolve10, ms));
   }
 };
 
 // src/services/doctor.ts
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync4, existsSync as existsSync5, statSync as statSync2 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync7, statSync as statSync2 } from "fs";
+import { join as join14 } from "path";
 var TOOLS = [
   { name: "git", command: "git", versionFlag: "--version", optional: false },
   { name: "ripgrep (rg)", command: "rg", versionFlag: "--version", optional: true },
@@ -7875,8 +9308,8 @@ var DoctorDiagnostic = class {
   checkInstallation() {
     const execPath = process.execPath;
     const isNpmGlobal = execPath.includes("npm") || execPath.includes("npx");
-    const isLocal = existsSync5(join12(process.cwd(), "node_modules", "cliskill"));
-    const isPackageManager = existsSync5(join12(process.cwd(), "package.json"));
+    const isLocal = existsSync7(join14(process.cwd(), "node_modules", "cliskill"));
+    const isPackageManager = existsSync7(join14(process.cwd(), "package.json"));
     let installType = "unknown";
     if (isNpmGlobal) installType = "npm-global";
     else if (isLocal) installType = "local";
@@ -7988,7 +9421,7 @@ var DoctorDiagnostic = class {
   checkConfig() {
     const configPaths = getConfigSearchPaths();
     for (const configPath of configPaths) {
-      if (existsSync5(configPath)) {
+      if (existsSync7(configPath)) {
         try {
           const raw = readFileSync4(configPath, "utf-8");
           JSON.parse(raw);
@@ -8019,7 +9452,7 @@ var DoctorDiagnostic = class {
     const configPaths = getConfigSearchPaths();
     let baseUrl = "";
     for (const configPath of configPaths) {
-      if (existsSync5(configPath)) {
+      if (existsSync7(configPath)) {
         try {
           const raw = readFileSync4(configPath, "utf-8");
           const config = JSON.parse(raw);
@@ -8066,7 +9499,7 @@ var DoctorDiagnostic = class {
   checkDiskSpace() {
     const memoryDir = getDataDir();
     const historyFile = getDiskHistoryPath();
-    if (!existsSync5(memoryDir)) {
+    if (!existsSync7(memoryDir)) {
       return {
         name: "Disk Space",
         status: "ok",
@@ -8075,7 +9508,7 @@ var DoctorDiagnostic = class {
       };
     }
     try {
-      const historyStats = existsSync5(historyFile) ? statSync2(historyFile) : null;
+      const historyStats = existsSync7(historyFile) ? statSync2(historyFile) : null;
       const historySize = historyStats ? historyStats.size : 0;
       return {
         name: "Disk Space",
@@ -8143,9 +9576,9 @@ var DoctorDiagnostic = class {
 };
 
 // src/services/conversation-recovery.ts
-import { readFile as readFile8, readdir as readdir5, stat as stat3 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join13, basename as basename3 } from "path";
+import { readFile as readFile10, readdir as readdir6, stat as stat4 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { join as join15, basename as basename3 } from "path";
 var DEFAULT_RECOVERY_OPTIONS = {
   sessionId: "",
   repairMode: false,
@@ -8159,7 +9592,7 @@ var ConversationRecovery = class {
     const opts = { ...DEFAULT_RECOVERY_OPTIONS, ...options };
     const warnings = [];
     const repairs = [];
-    if (!existsSync6(filePath)) {
+    if (!existsSync8(filePath)) {
       return {
         success: false,
         messages: [],
@@ -8174,7 +9607,7 @@ var ConversationRecovery = class {
         }
       };
     }
-    const rawContent = await readFile8(filePath, "utf-8");
+    const rawContent = await readFile10(filePath, "utf-8");
     const rawMessages = this.parseJsonl(rawContent);
     const totalMessages = rawMessages.length;
     const validated = this.validateMessages(rawMessages, opts.repairMode);
@@ -8216,7 +9649,7 @@ var ConversationRecovery = class {
     };
   }
   async findLatestSession(historyDir) {
-    if (!existsSync6(historyDir)) return null;
+    if (!existsSync8(historyDir)) return null;
     const sessions = await this.listSessions(historyDir);
     if (sessions.length === 0) return null;
     sessions.sort(
@@ -8225,7 +9658,7 @@ var ConversationRecovery = class {
     return sessions[0].filePath;
   }
   async findSessionById(historyDir, sessionId) {
-    if (!existsSync6(historyDir)) return null;
+    if (!existsSync8(historyDir)) return null;
     const sessions = await this.listSessions(historyDir);
     const match = sessions.find(
       (s) => s.id === sessionId || s.id.startsWith(sessionId) || basename3(s.filePath).includes(sessionId)
@@ -8235,12 +9668,12 @@ var ConversationRecovery = class {
   async validate(filePath) {
     const errors = [];
     const warnings = [];
-    if (!existsSync6(filePath)) {
+    if (!existsSync8(filePath)) {
       return { valid: false, errors: ["File not found"], warnings: [] };
     }
     let rawContent;
     try {
-      rawContent = await readFile8(filePath, "utf-8");
+      rawContent = await readFile10(filePath, "utf-8");
     } catch {
       return { valid: false, errors: ["Cannot read file"], warnings: [] };
     }
@@ -8275,15 +9708,15 @@ var ConversationRecovery = class {
     };
   }
   async listSessions(historyDir) {
-    if (!existsSync6(historyDir)) return [];
-    const entries = await readdir5(historyDir);
+    if (!existsSync8(historyDir)) return [];
+    const entries = await readdir6(historyDir);
     const sessions = [];
     for (const entry of entries) {
-      const filePath = join13(historyDir, entry);
-      const fileStat = await stat3(filePath);
+      const filePath = join15(historyDir, entry);
+      const fileStat = await stat4(filePath);
       if (fileStat.isDirectory()) {
-        const sessionFile = join13(filePath, "conversation.jsonl");
-        if (existsSync6(sessionFile)) {
+        const sessionFile = join15(filePath, "conversation.jsonl");
+        if (existsSync8(sessionFile)) {
           const info2 = await this.buildSessionInfo(
             sessionFile,
             fileStat.mtimeMs
@@ -8300,7 +9733,7 @@ var ConversationRecovery = class {
   }
   async buildSessionInfo(filePath, mtimeMs) {
     try {
-      const content = await readFile8(filePath, "utf-8");
+      const content = await readFile10(filePath, "utf-8");
       const lines = content.split("\n").filter(Boolean);
       const messages = [];
       for (const line of lines) {
@@ -8494,7 +9927,7 @@ var ConversationRecovery = class {
 // src/services/deep-links.ts
 import { execFile as execFile4 } from "child_process";
 import { platform as platform2 } from "os";
-import { resolve as resolve8, normalize, sep } from "path";
+import { resolve as resolve9, normalize, sep } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile4);
 var ALLOWED_ACTIONS = /* @__PURE__ */ new Set(["open", "run", "config"]);
@@ -8775,10 +10208,10 @@ var DeepLinkHandler = class {
   }
   async checkMacOS() {
     try {
-      const { stat: stat4 } = await import("fs/promises");
+      const { stat: stat5 } = await import("fs/promises");
       const { getPlistPath } = await import("./paths-OODUHG6V.js");
       const plistPath = getPlistPath();
-      await stat4(plistPath);
+      await stat5(plistPath);
       return true;
     } catch {
       return false;
@@ -8795,10 +10228,10 @@ NoDisplay=true
 `;
     const { writeFile: writeFile5, mkdir: mkdir5 } = await import("fs/promises");
     const { homedir } = await import("os");
-    const { join: join14 } = await import("path");
-    const dir = join14(homedir(), ".local", "share", "applications");
+    const { join: join16 } = await import("path");
+    const dir = join16(homedir(), ".local", "share", "applications");
     await mkdir5(dir, { recursive: true });
-    await writeFile5(join14(dir, "cliskill.desktop"), desktopContent, "utf-8");
+    await writeFile5(join16(dir, "cliskill.desktop"), desktopContent, "utf-8");
     try {
       await execFileAsync("update-desktop-database", [dir]);
     } catch {
@@ -8815,8 +10248,8 @@ NoDisplay=true
   async unregisterLinux() {
     const { unlink: unlink4 } = await import("fs/promises");
     const { homedir } = await import("os");
-    const { join: join14 } = await import("path");
-    const desktopPath = join14(
+    const { join: join16 } = await import("path");
+    const desktopPath = join16(
       homedir(),
       ".local",
       "share",
@@ -8830,17 +10263,17 @@ NoDisplay=true
   }
   async checkLinux() {
     try {
-      const { stat: stat4 } = await import("fs/promises");
+      const { stat: stat5 } = await import("fs/promises");
       const { homedir } = await import("os");
-      const { join: join14 } = await import("path");
-      const desktopPath = join14(
+      const { join: join16 } = await import("path");
+      const desktopPath = join16(
         homedir(),
         ".local",
         "share",
         "applications",
         "cliskill.desktop"
       );
-      await stat4(desktopPath);
+      await stat5(desktopPath);
       return true;
     } catch {
       return false;
@@ -9754,18 +11187,18 @@ function WizardLayout() {
 // src/ui/wizard/index.tsx
 import { jsx as jsx16 } from "react/jsx-runtime";
 function renderWizard() {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const { unmount } = render2(
       /* @__PURE__ */ jsx16(
         WizardProvider,
         {
           onComplete: (state) => {
             unmount();
-            resolve9(state);
+            resolve10(state);
           },
           onCancel: () => {
             unmount();
-            resolve9(null);
+            resolve10(null);
           },
           children: /* @__PURE__ */ jsx16(WizardLayout, {})
         }
@@ -10030,6 +11463,7 @@ export {
   QueryEngine,
   AgentTool,
   EnhancedMemoryStore,
+  TaskManager,
   runAgentLoop,
   createDefaultToolRegistry,
   StatusBar,
@@ -10038,6 +11472,8 @@ export {
   renderInkApp,
   formatAnsiMessage,
   MessageList,
+  MCPClient,
+  MCPConnectionManager,
   runCli
 };
-//# sourceMappingURL=chunk-UJMUL64T.js.map
+//# sourceMappingURL=chunk-S4ZZPUPF.js.map