@hasna/coders 0.1.9 → 0.2.0

package/dist/cli.mjs

@@ -7548,7 +7548,7 @@ var init_settings = __esm({
       alwaysThinkingEnabled: external_exports.boolean().optional(),
       // Permissions
       permissions: external_exports.object({
-        defaultMode: external_exports.enum(["default", "plan", "acceptEdits", "dontAsk", "auto"]).optional(),
+        defaultMode: external_exports.enum(["default", "plan", "acceptEdits", "dontAsk", "auto", "bypassPermissions"]).optional(),
         allow: external_exports.array(PermissionRuleSchema).optional(),
         deny: external_exports.array(PermissionRuleSchema).optional()
       }).optional(),
@@ -7598,13 +7598,19 @@ var init_settings = __esm({
       // Teammate mode
       teammateMode: external_exports.enum(["auto", "tmux", "in-process"]).optional(),
       // Remote control
-      remoteControlAtStartup: external_exports.boolean().optional()
+      remoteControlAtStartup: external_exports.boolean().optional(),
+      // Custom status line — run an external command to render the status bar
+      statusLine: external_exports.object({
+        type: external_exports.literal("command"),
+        command: external_exports.string(),
+        padding: external_exports.number().optional()
+      }).optional()
     }).passthrough();
     DEFAULT_SETTINGS = {
       model: null,
       alwaysThinkingEnabled: void 0,
       permissions: {
-        defaultMode: "default",
+        defaultMode: "bypassPermissions",
         allow: [],
         deny: []
       },
@@ -7653,16 +7659,6 @@ function getUserSettingsPath() {
 function getUserConfigPath() {
   return join(getConfigDir(), ".config.json");
 }
-function getTeamsDir() {
-  const dir = join(getConfigDir(), "teams");
-  ensureDir(dir);
-  return dir;
-}
-function getTasksDir() {
-  const dir = join(getConfigDir(), "tasks");
-  ensureDir(dir);
-  return dir;
-}
 function getPluginsDir() {
   const dir = join(getConfigDir(), "plugins");
   ensureDir(dir);
@@ -10168,7 +10164,7 @@ var require_react_development = __commonJS({
           var dispatcher = resolveDispatcher();
           return dispatcher.useReducer(reducer, initialArg, init);
         }
-        function useRef(initialValue) {
+        function useRef2(initialValue) {
           var dispatcher = resolveDispatcher();
           return dispatcher.useRef(initialValue);
         }
@@ -10962,7 +10958,7 @@ var require_react_development = __commonJS({
         exports.useLayoutEffect = useLayoutEffect2;
         exports.useMemo = useMemo3;
         exports.useReducer = useReducer;
-        exports.useRef = useRef;
+        exports.useRef = useRef2;
         exports.useState = useState3;
         exports.useSyncExternalStore = useSyncExternalStore;
         exports.useTransition = useTransition;
@@ -39039,7 +39035,7 @@ var require_backend = __commonJS({
                     return [initialArg, function() {
                     }];
                   },
-                  useRef: function useRef(initialValue) {
+                  useRef: function useRef2(initialValue) {
                     var hook = nextHook();
                     initialValue = null !== hook ? hook.memoizedState : {
                       current: initialValue
@@ -59191,6 +59187,73 @@ var init_models = __esm({
         maxOutput: 32768,
         supportsThinking: true,
         supportsVision: true
+      },
+      // ── xAI Grok models ──────────────────────────────────────────────
+      grok3: {
+        alias: "grok3",
+        variants: {
+          firstParty: "grok-3",
+          bedrock: "grok-3",
+          vertex: "grok-3",
+          xai: "grok-3"
+        },
+        contextWindow: 131072,
+        maxOutput: 16384,
+        supportsThinking: true,
+        supportsVision: false
+      },
+      grok3mini: {
+        alias: "grok3mini",
+        variants: {
+          firstParty: "grok-3-mini",
+          bedrock: "grok-3-mini",
+          vertex: "grok-3-mini",
+          xai: "grok-3-mini"
+        },
+        contextWindow: 131072,
+        maxOutput: 16384,
+        supportsThinking: true,
+        supportsVision: false
+      },
+      grok2: {
+        alias: "grok2",
+        variants: {
+          firstParty: "grok-2",
+          bedrock: "grok-2",
+          vertex: "grok-2",
+          xai: "grok-2"
+        },
+        contextWindow: 131072,
+        maxOutput: 8192,
+        supportsThinking: false,
+        supportsVision: true
+      },
+      // ── Google Gemini models ──────────────────────────────────────────
+      gemini25pro: {
+        alias: "gemini25pro",
+        variants: {
+          firstParty: "gemini-2.5-pro",
+          bedrock: "gemini-2.5-pro",
+          vertex: "gemini-2.5-pro",
+          gemini: "gemini-2.5-pro"
+        },
+        contextWindow: 1e6,
+        maxOutput: 65536,
+        supportsThinking: true,
+        supportsVision: true
+      },
+      gemini25flash: {
+        alias: "gemini25flash",
+        variants: {
+          firstParty: "gemini-2.5-flash",
+          bedrock: "gemini-2.5-flash",
+          vertex: "gemini-2.5-flash",
+          gemini: "gemini-2.5-flash"
+        },
+        contextWindow: 1e6,
+        maxOutput: 65536,
+        supportsThinking: true,
+        supportsVision: true
       }
     };
     USER_ALIASES = {
@@ -59198,7 +59261,18 @@ var init_models = __esm({
       sonnet: "sonnet46",
       opus: "opus46",
       "sonnet[1m]": "sonnet46",
-      "opus[1m]": "opus46"
+      "opus[1m]": "opus46",
+      // xAI Grok aliases
+      grok: "grok3",
+      "grok-3": "grok3",
+      "grok-3-mini": "grok3mini",
+      "grok-2": "grok2",
+      // Gemini aliases
+      gemini: "gemini25pro",
+      "gemini-pro": "gemini25pro",
+      "gemini-flash": "gemini25flash",
+      "gemini-2.5-pro": "gemini25pro",
+      "gemini-2.5-flash": "gemini25flash"
     };
   }
 });
@@ -59893,6 +59967,151 @@ var init_session = __esm({
   }
 });
 
+// src/core/background-tasks.ts
+var background_tasks_exports = {};
+__export(background_tasks_exports, {
+  completeTask: () => completeTask,
+  createTask: () => createTask,
+  failTask: () => failTask,
+  getAllTasks: () => getAllTasks,
+  getOutputPath: () => getOutputPath,
+  getRecentlyCompletedTasks: () => getRecentlyCompletedTasks,
+  getRunningTasks: () => getRunningTasks,
+  getTask: () => getTask,
+  killTask: () => killTask,
+  readTaskOutput: () => readTaskOutput,
+  updateTask: () => updateTask,
+  writeTaskOutput: () => writeTaskOutput
+});
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, appendFileSync, readFileSync as readFileSync7, existsSync as existsSync8 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir2 } from "os";
+function ensureTasksDir() {
+  try {
+    mkdirSync5(TASKS_DIR, { recursive: true });
+  } catch {
+  }
+}
+function createTask(type, description) {
+  const id = type === "bash" ? `bg-${nextBashId++}` : `agent-${nextAgentId++}`;
+  ensureTasksDir();
+  const outputPath = getOutputPath(id);
+  const task = {
+    id,
+    type,
+    description,
+    status: "running",
+    startTime: Date.now(),
+    output: "",
+    outputPath
+  };
+  if (type === "agent") {
+    task.progress = { tokenCount: 0 };
+  }
+  tasks.set(id, task);
+  try {
+    writeFileSync4(outputPath, "", "utf-8");
+  } catch {
+  }
+  return task;
+}
+function updateTask(id, updates) {
+  const task = tasks.get(id);
+  if (!task) return;
+  Object.assign(task, updates);
+}
+function completeTask(id, output, exitCode) {
+  const task = tasks.get(id);
+  if (!task) return;
+  task.status = "completed";
+  task.output = output;
+  task.exitCode = exitCode ?? null;
+  task.endTime = Date.now();
+  if (task.outputPath) {
+    try {
+      writeFileSync4(task.outputPath, output, "utf-8");
+    } catch {
+    }
+  }
+}
+function failTask(id, error2) {
+  const task = tasks.get(id);
+  if (!task) return;
+  task.status = "failed";
+  task.error = error2;
+  task.endTime = Date.now();
+  if (task.outputPath) {
+    try {
+      appendFileSync(task.outputPath, `
+
+--- ERROR ---
+${error2}
+`, "utf-8");
+    } catch {
+    }
+  }
+}
+function killTask(id) {
+  const task = tasks.get(id);
+  if (!task) return;
+  task.status = "killed";
+  task.endTime = Date.now();
+}
+function getTask(id) {
+  return tasks.get(id);
+}
+function getAllTasks() {
+  return [...tasks.values()];
+}
+function getRunningTasks() {
+  return [...tasks.values()].filter((t) => t.status === "running");
+}
+function getRecentlyCompletedTasks(withinMs = 6e4) {
+  const cutoff = Date.now() - withinMs;
+  return [...tasks.values()].filter(
+    (t) => t.status !== "running" && t.endTime != null && t.endTime >= cutoff
+  );
+}
+function getOutputPath(taskId) {
+  return join6(TASKS_DIR, `${taskId}.output`);
+}
+function writeTaskOutput(taskId, chunk) {
+  const task = tasks.get(taskId);
+  if (!task) return;
+  task.output += chunk;
+  if (task.outputPath) {
+    try {
+      appendFileSync(task.outputPath, chunk, "utf-8");
+    } catch {
+    }
+  }
+}
+function readTaskOutput(taskId) {
+  const task = tasks.get(taskId);
+  if (task?.output) {
+    return task.output;
+  }
+  const path = getOutputPath(taskId);
+  if (existsSync8(path)) {
+    try {
+      return readFileSync7(path, "utf-8");
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+var tasks, nextBashId, nextAgentId, TASKS_DIR;
+var init_background_tasks = __esm({
+  "src/core/background-tasks.ts"() {
+    "use strict";
+    tasks = /* @__PURE__ */ new Map();
+    nextBashId = 1;
+    nextAgentId = 1;
+    TASKS_DIR = join6(homedir2(), ".coders", "tasks");
+  }
+});
+
 // src/ui/screen/terminal.ts
 var terminal_exports = {};
 __export(terminal_exports, {
@@ -60018,8 +60237,82 @@ var init_terminal = __esm({
   }
 });
 
+// src/ui/themes.ts
+var themes_exports = {};
+__export(themes_exports, {
+  DARK_THEME: () => DARK_THEME,
+  DEFAULT_THEME: () => DEFAULT_THEME,
+  LIGHT_THEME: () => LIGHT_THEME,
+  getAvailableThemes: () => getAvailableThemes,
+  getTheme: () => getTheme
+});
+function getTheme(name) {
+  return THEMES[name] ?? DEFAULT_THEME;
+}
+function getAvailableThemes() {
+  return Object.keys(THEMES);
+}
+var DEFAULT_THEME, DARK_THEME, LIGHT_THEME, THEMES;
+var init_themes = __esm({
+  "src/ui/themes.ts"() {
+    "use strict";
+    DEFAULT_THEME = {
+      name: "default",
+      colors: {
+        primary: "cyan",
+        secondary: "blue",
+        success: "green",
+        error: "red",
+        warning: "yellow",
+        info: "blue",
+        muted: "gray",
+        plan: "magenta",
+        tool: "yellow",
+        thinking: "gray"
+      }
+    };
+    DARK_THEME = {
+      name: "dark",
+      colors: {
+        primary: "#61afef",
+        secondary: "#c678dd",
+        success: "#98c379",
+        error: "#e06c75",
+        warning: "#e5c07b",
+        info: "#56b6c2",
+        muted: "#5c6370",
+        plan: "#c678dd",
+        tool: "#e5c07b",
+        thinking: "#5c6370"
+      }
+    };
+    LIGHT_THEME = {
+      name: "light",
+      colors: {
+        primary: "#0184bc",
+        secondary: "#a626a4",
+        success: "#50a14f",
+        error: "#e45649",
+        warning: "#c18401",
+        info: "#0184bc",
+        muted: "#a0a1a7",
+        plan: "#a626a4",
+        tool: "#c18401",
+        thinking: "#a0a1a7"
+      }
+    };
+    THEMES = {
+      default: DEFAULT_THEME,
+      dark: DARK_THEME,
+      light: LIGHT_THEME
+    };
+  }
+});
+
 // src/core/slash-commands.ts
-import { writeFileSync as writeFileSync4 } from "fs";
+import { writeFileSync as writeFileSync5, existsSync as existsSync9, readdirSync as readdirSync2 } from "fs";
+import { join as join7 } from "path";
+import { execSync as execSync3 } from "child_process";
 function registerSlashCommand(cmd) {
   commands.set(cmd.name, cmd);
   if (cmd.aliases) {
@@ -60070,8 +60363,12 @@ ${lines.join("\n")}` };
   registerSlashCommand({
     name: "compact",
     category: "core",
-    description: "Compact conversation context",
-    handler: () => ({ action: "compact", output: "Context compacted." })
+    description: "Compact conversation context [instructions]",
+    handler: (args) => ({
+      action: "compact",
+      data: args.trim() || void 0,
+      output: args.trim() ? `Context compacted with instructions: ${args.trim()}` : "Context compacted."
+    })
   });
   registerSlashCommand({
     name: "exit",
@@ -60091,15 +60388,15 @@ ${lines.join("\n")}` };
     category: "mode",
     description: "View or change the current model",
     handler: (args) => {
-      if (args) return { action: "setModel", data: args, output: `Model set to: ${args}` };
+      if (args) return { action: "model", data: args.trim(), output: `Model set to: ${args.trim()}` };
       return { output: "Current model \u2014 use /model <name> to change." };
     }
   });
   registerSlashCommand({
     name: "fast",
     category: "mode",
-    description: "Toggle fast mode",
-    handler: () => ({ output: "Fast mode toggled." })
+    description: "Toggle fast mode (switch between current model and haiku)",
+    handler: () => ({ action: "fast", output: "Fast mode toggled." })
   });
   registerSlashCommand({
     name: "verbose",
@@ -60135,14 +60432,44 @@ ${lines.join("\n")}` };
     name: "tasks",
     aliases: ["todo", "todos"],
     category: "task",
-    description: "Toggle task list view",
-    handler: () => ({ action: "toggleView", data: "tasks", output: "Task list toggled." })
+    description: "List all background tasks with their status",
+    handler: () => {
+      try {
+        const { getAllTasks: getAllTasks2 } = (init_background_tasks(), __toCommonJS(background_tasks_exports));
+        const tasks2 = getAllTasks2();
+        if (tasks2.length === 0) return { output: "No background tasks." };
+        const lines = tasks2.map((t) => {
+          const elapsed = t.endTime ? `${((t.endTime - t.startTime) / 1e3).toFixed(1)}s` : `${((Date.now() - t.startTime) / 1e3).toFixed(1)}s`;
+          const status = t.status === "running" ? "running" : t.status === "completed" ? "done" : t.status;
+          return `  ${t.id.padEnd(12)} ${status.padEnd(10)} ${elapsed.padEnd(8)} ${t.description}`;
+        });
+        return { output: `Background tasks:
+  ${"ID".padEnd(12)} ${"Status".padEnd(10)} ${"Time".padEnd(8)} Description
+${lines.join("\n")}` };
+      } catch {
+        return { output: "No background tasks." };
+      }
+    }
   });
   registerSlashCommand({
     name: "diff",
     category: "git",
-    description: "Show git diff",
-    handler: () => ({ output: "Use Bash tool: git diff" })
+    description: "Show uncommitted git changes",
+    handler: () => {
+      try {
+        const unstaged = execSync3("git diff", { encoding: "utf-8", timeout: 1e4 }).trim();
+        const staged = execSync3("git diff --cached", { encoding: "utf-8", timeout: 1e4 }).trim();
+        const parts = [];
+        if (staged) parts.push(`\u2500\u2500 Staged changes \u2500\u2500
+${staged}`);
+        if (unstaged) parts.push(`\u2500\u2500 Unstaged changes \u2500\u2500
+${unstaged}`);
+        if (parts.length === 0) return { output: "No uncommitted changes." };
+        return { output: parts.join("\n\n") };
+      } catch (e) {
+        return { output: `Failed to get diff: ${e instanceof Error ? e.message : String(e)}` };
+      }
+    }
   });
   registerSlashCommand({
     name: "pr",
@@ -60207,7 +60534,7 @@ ${lines.join("\n")}` };
       if (!isNaN(choice) && choice >= 1 && choice <= checkpoints.length) {
         const cp = checkpoints[choice - 1];
         try {
-          writeFileSync4(cp.file_path, cp.original_content, "utf-8");
+          writeFileSync5(cp.file_path, cp.original_content, "utf-8");
           const op = cp.edit_operation ? JSON.parse(cp.edit_operation) : null;
           const summary = op?.old_string ? `Reverted edit: "${truncate(op.old_string, 40)}" -> "${truncate(op.new_string, 40)}"` : "Restored original content";
           return { output: `Restored checkpoint #${choice}: ${cp.file_path}
@@ -60306,6 +60633,181 @@ Use /restore latest or /restore <number> or /restore <id-prefix>`
       return { output: `No checkpoint found matching "${arg}". Use /restore to list available checkpoints.` };
     }
   });
+  registerSlashCommand({
+    name: "cost",
+    category: "system",
+    description: "Show session cost, token usage, and duration",
+    handler: () => {
+      const sessionId = getCurrentSessionId();
+      if (!sessionId) return { output: "No active session." };
+      try {
+        const row = dbGet(
+          `SELECT created_at,
+                  COALESCE(SUM(tokens_in), 0) AS total_in,
+                  COALESCE(SUM(tokens_out), 0) AS total_out,
+                  COALESCE(SUM(cost_usd), 0) AS total_cost
+           FROM messages WHERE session_id = ?`,
+          [sessionId]
+        );
+        const session = dbGet(`SELECT created_at FROM sessions WHERE id = ?`, [sessionId]);
+        const startTime = session?.created_at ? new Date(session.created_at).getTime() : Date.now();
+        const durationMs = Date.now() - startTime;
+        const durationMin = Math.floor(durationMs / 6e4);
+        const durationSec = Math.floor(durationMs % 6e4 / 1e3);
+        const totalIn = row?.total_in ?? 0;
+        const totalOut = row?.total_out ?? 0;
+        const totalCost = row?.total_cost ?? 0;
+        const lines = [
+          `Session cost:`,
+          `  Duration:       ${durationMin}m ${durationSec}s`,
+          `  Input tokens:   ${totalIn.toLocaleString()}`,
+          `  Output tokens:  ${totalOut.toLocaleString()}`,
+          `  Total tokens:   ${(totalIn + totalOut).toLocaleString()}`,
+          `  Total cost:     $${totalCost.toFixed(4)}`
+        ];
+        return { output: lines.join("\n") };
+      } catch (e) {
+        return { output: `Failed to get cost info: ${e instanceof Error ? e.message : String(e)}` };
+      }
+    }
+  });
+  registerSlashCommand({
+    name: "files",
+    category: "system",
+    description: "List files read/written in this session",
+    handler: () => {
+      const sessionId = getCurrentSessionId();
+      if (!sessionId) return { output: "No active session." };
+      try {
+        const rows = dbAll(
+          `SELECT DISTINCT file_path, edit_operation FROM checkpoints WHERE session_id = ? OR 1=1 ORDER BY created_at DESC LIMIT 50`
+        );
+        const msgRows = dbAll(
+          `SELECT tool_uses FROM messages WHERE session_id = ? AND tool_uses IS NOT NULL`,
+          [sessionId]
+        );
+        const filesRead = /* @__PURE__ */ new Set();
+        const filesWritten = /* @__PURE__ */ new Set();
+        for (const r of msgRows) {
+          try {
+            const uses = JSON.parse(r.tool_uses);
+            if (Array.isArray(uses)) {
+              for (const u of uses) {
+                if (u.name === "Read" && u.input?.file_path) filesRead.add(u.input.file_path);
+                if ((u.name === "Edit" || u.name === "Write") && u.input?.file_path) filesWritten.add(u.input.file_path);
+              }
+            }
+          } catch {
+          }
+        }
+        const parts = [];
+        if (filesRead.size > 0) {
+          parts.push(`Files read (${filesRead.size}):
+${Array.from(filesRead).map((f) => `  ${f}`).join("\n")}`);
+        }
+        if (filesWritten.size > 0) {
+          parts.push(`Files written (${filesWritten.size}):
+${Array.from(filesWritten).map((f) => `  ${f}`).join("\n")}`);
+        }
+        if (parts.length === 0) return { output: "No files tracked in this session." };
+        return { output: parts.join("\n\n") };
+      } catch (e) {
+        return { output: `Failed to list files: ${e instanceof Error ? e.message : String(e)}` };
+      }
+    }
+  });
+  registerSlashCommand({
+    name: "export",
+    category: "core",
+    description: "Export conversation to a file [path]",
+    handler: (args) => {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const path = args.trim() || join7(process.cwd(), `coders-export-${timestamp}.md`);
+      return { action: "export", data: path, output: `Exporting conversation to: ${path}` };
+    }
+  });
+  registerSlashCommand({
+    name: "theme",
+    category: "mode",
+    description: "Change UI theme [name]",
+    handler: (args) => {
+      if (!args.trim()) {
+        try {
+          const { getAvailableThemes: getAvailableThemes2 } = (init_themes(), __toCommonJS(themes_exports));
+          const themes = getAvailableThemes2();
+          return { output: `Available themes: ${themes.join(", ")}
+Use /theme <name> to switch.` };
+        } catch {
+          return { output: "Available themes: default, dark, light\nUse /theme <name> to switch." };
+        }
+      }
+      return { action: "theme", data: args.trim(), output: `Theme set to: ${args.trim()}` };
+    }
+  });
+  registerSlashCommand({
+    name: "effort",
+    category: "mode",
+    description: "Set effort level [low|medium|high]",
+    handler: (args) => {
+      const level = args.trim().toLowerCase();
+      if (!level) return { output: "Usage: /effort <low|medium|high>" };
+      if (!["low", "medium", "high"].includes(level)) {
+        return { output: `Invalid effort level: "${level}". Must be one of: low, medium, high` };
+      }
+      return { action: "effort", data: level, output: `Effort level set to: ${level}` };
+    }
+  });
+  registerSlashCommand({
+    name: "skills",
+    category: "system",
+    description: "List available skills from .coders/skills/ and .claude/skills/",
+    handler: () => {
+      const skillDirs = [
+        join7(process.cwd(), ".coders", "skills"),
+        join7(process.cwd(), ".claude", "skills")
+      ];
+      const skills = [];
+      for (const dir of skillDirs) {
+        if (!existsSync9(dir)) continue;
+        try {
+          const entries = readdirSync2(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              const skillMd = join7(dir, entry.name, "SKILL.md");
+              if (existsSync9(skillMd)) {
+                skills.push(`  ${entry.name} (${dir}/${entry.name}/SKILL.md)`);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      if (skills.length === 0) return { output: "No skills found. Place SKILL.md files in .coders/skills/<name>/ or .claude/skills/<name>/." };
+      return { output: `Available skills (${skills.length}):
+${skills.join("\n")}` };
+    }
+  });
+  registerSlashCommand({
+    name: "rename",
+    category: "core",
+    description: "Rename the current session [name]",
+    handler: (args) => {
+      if (!args.trim()) return { output: "Usage: /rename <name>" };
+      return { action: "rename", data: args.trim(), output: `Session renamed to: ${args.trim()}` };
+    }
+  });
+  registerSlashCommand({
+    name: "resume",
+    category: "navigation",
+    description: "Resume the last session",
+    handler: () => ({ action: "resume", output: "Resuming last session..." })
+  });
+  registerSlashCommand({
+    name: "vim",
+    category: "mode",
+    description: "Toggle vim keybinding mode",
+    handler: () => ({ action: "vim", output: "Vim mode toggled." })
+  });
   registerSlashCommand({
     name: "undo",
     category: "core",
@@ -60318,7 +60820,7 @@ Use /restore latest or /restore <number> or /restore <id-prefix>`
         return { output: "No checkpoints found. Nothing to undo." };
       }
       try {
-        writeFileSync4(cp.file_path, cp.original_content, "utf-8");
+        writeFileSync5(cp.file_path, cp.original_content, "utf-8");
         const op = cp.edit_operation ? JSON.parse(cp.edit_operation) : null;
         const summary = op?.old_string ? `Reverted: "${truncate(op.old_string, 50)}" -> "${truncate(op.new_string, 50)}"` : op?.type === "write_overwrite" ? "Restored file before overwrite" : "Restored original content";
         return { output: `Undo successful: ${cp.file_path}
@@ -63023,8 +63525,8 @@ var init_permissions = __esm({
 });
 
 // src/memory/files.ts
-import { readFileSync as readFileSync7, existsSync as existsSync8 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+import { join as join8 } from "path";
 function getInstructionsContent(projectDir) {
   const cached2 = _cache.get(projectDir);
   if (cached2 !== void 0) return cached2 || null;
@@ -63034,7 +63536,7 @@ function getInstructionsContent(projectDir) {
     return null;
   }
   try {
-    let content = readFileSync7(filePath, "utf-8");
+    let content = readFileSync8(filePath, "utf-8");
     content = stripHtmlComments(content);
     _cache.set(projectDir, content);
     return content;
@@ -63045,11 +63547,11 @@ function getInstructionsContent(projectDir) {
 }
 function getGlobalInstructions() {
   const configDir = getConfigDir();
-  const primary = join6(configDir, "CODERS.md");
-  const path = existsSync8(primary) ? primary : null;
+  const primary = join8(configDir, "CODERS.md");
+  const path = existsSync10(primary) ? primary : null;
   if (!path) return null;
   try {
-    return stripHtmlComments(readFileSync7(path, "utf-8"));
+    return stripHtmlComments(readFileSync8(path, "utf-8"));
   } catch {
     return null;
   }
@@ -63064,13 +63566,13 @@ ${global2}`);
   if (project) parts.push(`# Project Instructions
 
 ${project}`);
-  const rulesDir = join6(projectDir, ".coders", "rules");
-  if (existsSync8(rulesDir)) {
+  const rulesDir = join8(projectDir, ".coders", "rules");
+  if (existsSync10(rulesDir)) {
     try {
-      const { readdirSync: readdirSync2 } = __require("fs");
-      for (const file of readdirSync2(rulesDir)) {
+      const { readdirSync: readdirSync4 } = __require("fs");
+      for (const file of readdirSync4(rulesDir)) {
         if (!file.endsWith(".md")) continue;
-        const content = readFileSync7(join6(rulesDir, file), "utf-8");
+        const content = readFileSync8(join8(rulesDir, file), "utf-8");
         parts.push(`# Rule: ${file}
 
 ${stripHtmlComments(content)}`);
@@ -63092,6 +63594,257 @@ var init_files = __esm({
   }
 });
 
+// src/core/constants.ts
+var BASH_TOOL, READ_TOOL, EDIT_TOOL, WRITE_TOOL, GLOB_TOOL, GREP_TOOL, AGENT_TOOL, WEB_FETCH_TOOL, WEB_SEARCH_TOOL, NOTEBOOK_EDIT_TOOL, LSP_TOOL, TASK_CREATE_TOOL, TASK_GET_TOOL, TASK_LIST_TOOL, TASK_UPDATE_TOOL, TASK_STOP_TOOL, TASK_OUTPUT_TOOL, ENTER_PLAN_MODE_TOOL, EXIT_PLAN_MODE_TOOL, ASK_USER_QUESTION_TOOL, CRON_CREATE_TOOL, CRON_DELETE_TOOL, CRON_LIST_TOOL, ENTER_WORKTREE_TOOL, EXIT_WORKTREE_TOOL, TOOL_SEARCH_TOOL, SEND_MESSAGE_TOOL, CONFIG_TOOL, LIST_MCP_RESOURCES_TOOL, READ_MCP_RESOURCE_TOOL, DEFAULT_BASH_TIMEOUT_MS, MAX_BASH_TIMEOUT_MS, DEFAULT_READ_LINE_LIMIT, DEFAULT_MAX_RESULT_SIZE_CHARS;
+var init_constants = __esm({
+  "src/core/constants.ts"() {
+    "use strict";
+    BASH_TOOL = "Bash";
+    READ_TOOL = "Read";
+    EDIT_TOOL = "Edit";
+    WRITE_TOOL = "Write";
+    GLOB_TOOL = "Glob";
+    GREP_TOOL = "Grep";
+    AGENT_TOOL = "Agent";
+    WEB_FETCH_TOOL = "WebFetch";
+    WEB_SEARCH_TOOL = "WebSearch";
+    NOTEBOOK_EDIT_TOOL = "NotebookEdit";
+    LSP_TOOL = "LSP";
+    TASK_CREATE_TOOL = "TaskCreate";
+    TASK_GET_TOOL = "TaskGet";
+    TASK_LIST_TOOL = "TaskList";
+    TASK_UPDATE_TOOL = "TaskUpdate";
+    TASK_STOP_TOOL = "TaskStop";
+    TASK_OUTPUT_TOOL = "TaskOutput";
+    ENTER_PLAN_MODE_TOOL = "EnterPlanMode";
+    EXIT_PLAN_MODE_TOOL = "ExitPlanMode";
+    ASK_USER_QUESTION_TOOL = "AskUserQuestion";
+    CRON_CREATE_TOOL = "CronCreate";
+    CRON_DELETE_TOOL = "CronDelete";
+    CRON_LIST_TOOL = "CronList";
+    ENTER_WORKTREE_TOOL = "EnterWorktree";
+    EXIT_WORKTREE_TOOL = "ExitWorktree";
+    TOOL_SEARCH_TOOL = "ToolSearch";
+    SEND_MESSAGE_TOOL = "SendMessage";
+    CONFIG_TOOL = "Config";
+    LIST_MCP_RESOURCES_TOOL = "ListMcpResourcesTool";
+    READ_MCP_RESOURCE_TOOL = "ReadMcpResourceTool";
+    DEFAULT_BASH_TIMEOUT_MS = 12e4;
+    MAX_BASH_TIMEOUT_MS = 6e5;
+    DEFAULT_READ_LINE_LIMIT = 2e3;
+    DEFAULT_MAX_RESULT_SIZE_CHARS = 1e5;
+  }
+});
+
+// src/tools/builtin/skill.ts
+import { readFileSync as readFileSync9, readdirSync as readdirSync3, existsSync as existsSync11, statSync } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir3 } from "os";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const rawYaml = match[1];
+  const body = match[2];
+  const frontmatter = {};
+  for (const line of rawYaml.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    let value = trimmed.slice(colonIdx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    frontmatter[key] = value;
+  }
+  return { frontmatter, body };
+}
+function parseSkillFile(filePath, dirName) {
+  try {
+    const content = readFileSync9(filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    return {
+      name: frontmatter.name || dirName,
+      description: frontmatter.description || "",
+      body: body.trim()
+    };
+  } catch {
+    return null;
+  }
+}
+function scanSkillsDir(baseDir, source) {
+  if (!existsSync11(baseDir)) return [];
+  const skills = [];
+  try {
+    const entries = readdirSync3(baseDir);
+    for (const entry of entries) {
+      const entryPath = join9(baseDir, entry);
+      try {
+        if (!statSync(entryPath).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      const skillFile = join9(entryPath, "SKILL.md");
+      if (!existsSync11(skillFile)) continue;
+      const parsed = parseSkillFile(skillFile, entry);
+      if (!parsed) continue;
+      skills.push({
+        name: parsed.name,
+        description: parsed.description,
+        path: skillFile,
+        source
+      });
+    }
+  } catch {
+  }
+  return skills;
+}
+function discoverSkills(cwd2) {
+  const projectDir = cwd2 ?? process.cwd();
+  const home = homedir3();
+  const projectCoders = scanSkillsDir(join9(projectDir, ".coders", "skills"), "project");
+  const projectClaude = scanSkillsDir(join9(projectDir, ".claude", "skills"), "project");
+  const userCoders = scanSkillsDir(join9(home, ".coders", "skills"), "user");
+  const userClaude = scanSkillsDir(join9(home, ".claude", "skills"), "user");
+  const seen = /* @__PURE__ */ new Set();
+  const all = [];
+  for (const list2 of [projectCoders, projectClaude, userCoders, userClaude]) {
+    for (const skill of list2) {
+      const key = skill.name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      all.push(skill);
+    }
+  }
+  return all;
+}
+var SKILL_TOOL, skillInputSchema, skillTool;
+var init_skill = __esm({
+  "src/tools/builtin/skill.ts"() {
+    "use strict";
+    init_zod();
+    init_constants();
+    SKILL_TOOL = "Skill";
+    skillInputSchema = external_exports.strictObject({
+      skill: external_exports.string().describe("The skill name to invoke (e.g. 'commit', 'review-pr', 'test')"),
+      args: external_exports.string().optional().describe("Optional arguments to pass to the skill prompt")
+    });
+    skillTool = {
+      name: SKILL_TOOL,
+      searchHint: "invoke user-defined skill from SKILL.md",
+      maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+      shouldDefer: false,
+      strict: false,
+      async description() {
+        return "Execute a skill within the main conversation. Skills are user-defined prompts in .coders/skills/ or .claude/skills/ directories.";
+      },
+      async prompt() {
+        return `Invoke a user-defined skill from .coders/skills/ or .claude/skills/ directories.
+Skills are directories containing a SKILL.md file with YAML frontmatter (name, description) and a markdown prompt body.
+When invoked, the skill's prompt is returned with {{args}} replaced by the provided args.
+Use this tool when the user references a skill by name or uses a "/<skill-name>" slash command pattern.`;
+      },
+      get inputSchema() {
+        return skillInputSchema;
+      },
+      get outputSchema() {
+        return external_exports.any();
+      },
+      userFacingName() {
+        return SKILL_TOOL;
+      },
+      isEnabled() {
+        return true;
+      },
+      isConcurrencySafe() {
+        return true;
+      },
+      isReadOnly() {
+        return true;
+      },
+      toAutoClassifierInput(input) {
+        return `skill:${input.skill}${input.args ? ` ${input.args}` : ""}`;
+      },
+      getActivityDescription(input) {
+        return `Running skill: ${input.skill}`;
+      },
+      getToolUseSummary(input) {
+        return input.skill;
+      },
+      async checkPermissions(input) {
+        return { behavior: "allow", updatedInput: input };
+      },
+      async validateInput(input) {
+        if (!input.skill || typeof input.skill !== "string") {
+          return { result: false, message: "skill name is required" };
+        }
+        return { result: true };
+      },
+      async call(input) {
+        const skillName = input.skill.trim().toLowerCase();
+        const skills = discoverSkills();
+        const match = skills.find((s) => s.name.toLowerCase() === skillName);
+        if (!match) {
+          const available = skills.map((s) => s.name).join(", ");
+          const errorMsg = available ? `Skill "${input.skill}" not found. Available skills: ${available}` : `Skill "${input.skill}" not found. No skills are installed. Create a skill directory with a SKILL.md file in .coders/skills/ or .claude/skills/.`;
+          return {
+            data: {
+              skill: input.skill,
+              prompt: "",
+              source: "project",
+              error: errorMsg
+            }
+          };
+        }
+        const parsed = parseSkillFile(match.path, match.name);
+        if (!parsed || !parsed.body) {
+          return {
+            data: {
+              skill: input.skill,
+              prompt: "",
+              source: match.source,
+              error: `Skill "${match.name}" has an empty or invalid SKILL.md file at ${match.path}`
+            }
+          };
+        }
+        let prompt = parsed.body;
+        if (input.args) {
+          prompt = prompt.replace(/\{\{args\}\}/g, input.args);
+        } else {
+          prompt = prompt.replace(/\{\{args\}\}/g, "");
+        }
+        return {
+          data: {
+            skill: match.name,
+            prompt: prompt.trim(),
+            source: match.source
+          }
+        };
+      },
+      mapToolResultToToolResultBlockParam(result, toolUseId) {
+        if (result.error) {
+          return {
+            type: "tool_result",
+            tool_use_id: toolUseId,
+            content: result.error,
+            is_error: true
+          };
+        }
+        return {
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          content: `<command-name>${result.skill}</command-name>
+
+${result.prompt}`
+        };
+      }
+    };
+  }
+});
+
 // src/core/system-prompt.ts
 function buildSystemPrompt(ctx) {
   const sections = [];
@@ -63120,6 +63873,28 @@ ${t.prompt}`).join("\n\n");
 ${toolSection}`);
     }
   }
+  if (ctx.deferredTools && ctx.deferredTools.length > 0) {
+    const deferredList = ctx.deferredTools.map((t) => `- **${t.name}**: ${t.description}`).join("\n");
+    sections.push(`
+# Deferred Tools
+
+The following tools are available but not loaded by default. Use the ToolSearch tool to fetch their full schemas before calling them. Once you call ToolSearch for a tool, you can use it normally.
+
+${deferredList}`);
+  }
+  try {
+    const skills = discoverSkills(ctx.projectDir);
+    if (skills.length > 0) {
+      const skillList = skills.map((s) => `- **${s.name}**${s.description ? `: ${s.description}` : ""} _(${s.source})_`).join("\n");
+      sections.push(`
+# Available Skills
+
+The following skills are available via the Skill tool. When a user references a skill by name or uses "/<skill-name>", invoke it with the Skill tool.
+
+${skillList}`);
+    }
+  } catch {
+  }
   const ctxParts = [];
   ctxParts.push(`Working directory: ${ctx.projectDir}`);
   ctxParts.push(`Model: ${ctx.model}`);
@@ -63147,6 +63922,7 @@ var init_system_prompt = __esm({
   "src/core/system-prompt.ts"() {
     "use strict";
     init_files();
+    init_skill();
     CORE_INSTRUCTIONS = `You are Coders, an open-source interactive CLI agent built by Hasna for software engineering.
 You are an interactive agent that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
 
@@ -63190,44 +63966,6 @@ You are an interactive agent that helps users with software engineering tasks. U
   }
 });
 
-// src/core/constants.ts
-var BASH_TOOL, READ_TOOL, EDIT_TOOL, WRITE_TOOL, GLOB_TOOL, GREP_TOOL, AGENT_TOOL, WEB_FETCH_TOOL, WEB_SEARCH_TOOL, NOTEBOOK_EDIT_TOOL, LSP_TOOL, TASK_CREATE_TOOL, TASK_GET_TOOL, TASK_LIST_TOOL, TASK_UPDATE_TOOL, ENTER_PLAN_MODE_TOOL, EXIT_PLAN_MODE_TOOL, ASK_USER_QUESTION_TOOL, CRON_CREATE_TOOL, CRON_DELETE_TOOL, CRON_LIST_TOOL, ENTER_WORKTREE_TOOL, EXIT_WORKTREE_TOOL, TOOL_SEARCH_TOOL, SEND_MESSAGE_TOOL, CONFIG_TOOL, DEFAULT_BASH_TIMEOUT_MS, MAX_BASH_TIMEOUT_MS, DEFAULT_READ_LINE_LIMIT, DEFAULT_MAX_RESULT_SIZE_CHARS;
-var init_constants = __esm({
-  "src/core/constants.ts"() {
-    "use strict";
-    BASH_TOOL = "Bash";
-    READ_TOOL = "Read";
-    EDIT_TOOL = "Edit";
-    WRITE_TOOL = "Write";
-    GLOB_TOOL = "Glob";
-    GREP_TOOL = "Grep";
-    AGENT_TOOL = "Agent";
-    WEB_FETCH_TOOL = "WebFetch";
-    WEB_SEARCH_TOOL = "WebSearch";
-    NOTEBOOK_EDIT_TOOL = "NotebookEdit";
-    LSP_TOOL = "LSP";
-    TASK_CREATE_TOOL = "TaskCreate";
-    TASK_GET_TOOL = "TaskGet";
-    TASK_LIST_TOOL = "TaskList";
-    TASK_UPDATE_TOOL = "TaskUpdate";
-    ENTER_PLAN_MODE_TOOL = "EnterPlanMode";
-    EXIT_PLAN_MODE_TOOL = "ExitPlanMode";
-    ASK_USER_QUESTION_TOOL = "AskUserQuestion";
-    CRON_CREATE_TOOL = "CronCreate";
-    CRON_DELETE_TOOL = "CronDelete";
-    CRON_LIST_TOOL = "CronList";
-    ENTER_WORKTREE_TOOL = "EnterWorktree";
-    EXIT_WORKTREE_TOOL = "ExitWorktree";
-    TOOL_SEARCH_TOOL = "ToolSearch";
-    SEND_MESSAGE_TOOL = "SendMessage";
-    CONFIG_TOOL = "Config";
-    DEFAULT_BASH_TIMEOUT_MS = 12e4;
-    MAX_BASH_TIMEOUT_MS = 6e5;
-    DEFAULT_READ_LINE_LIMIT = 2e3;
-    DEFAULT_MAX_RESULT_SIZE_CHARS = 1e5;
-  }
-});
-
 // src/tools/builtin/bash.ts
 import { spawn } from "child_process";
 function isDangerousCommand(command) {
@@ -63342,13 +64080,14 @@ function truncateOutput(output, maxChars = DEFAULT_MAX_RESULT_SIZE_CHARS) {
 
 ` + output.slice(-half);
 }
-var DANGEROUS_PATTERNS, BashInputSchema, BashOutputSchema, READ_ONLY_COMMANDS, READ_ONLY_KEYWORDS, GIT_READ_ONLY_SUBCOMMANDS, NPM_READ_ONLY_SUBCOMMANDS, DOCKER_READ_ONLY_SUBCOMMANDS, backgroundTasks, nextBgId, bashTool, BASH_PROMPT;
+var DANGEROUS_PATTERNS, BashInputSchema, BashOutputSchema, READ_ONLY_COMMANDS, READ_ONLY_KEYWORDS, GIT_READ_ONLY_SUBCOMMANDS, NPM_READ_ONLY_SUBCOMMANDS, DOCKER_READ_ONLY_SUBCOMMANDS, backgroundTasks, bashTool, BASH_PROMPT;
 var init_bash = __esm({
   "src/tools/builtin/bash.ts"() {
     "use strict";
     init_zod();
     init_constants();
     init_db();
+    init_background_tasks();
     DANGEROUS_PATTERNS = [
       { pattern: /\brm\s+-rf\s+\/\s*$/, reason: "Recursive delete of root filesystem" },
       { pattern: /\brm\s+-rf\s+~\//, reason: "Recursive delete of home directory" },
@@ -63541,7 +64280,6 @@ var init_bash = __esm({
       "version"
     ]);
     backgroundTasks = /* @__PURE__ */ new Map();
-    nextBgId = 1;
     bashTool = {
       name: BASH_TOOL,
       searchHint: "execute shell commands in the terminal",
@@ -63612,7 +64350,8 @@ var init_bash = __esm({
         const timeoutMs = timeout ?? getDefaultTimeout();
         const startTime = performance.now();
         if (run_in_background) {
-          const taskId = `bg-${nextBgId++}`;
+          const bgTask = createTask("bash", command);
+          const taskId = bgTask.id;
           const child = spawn(command, [], {
             shell: getShell(),
             cwd: process.cwd(),
@@ -63621,10 +64360,14 @@ var init_bash = __esm({
           });
           let output = "";
           child.stdout?.on("data", (data) => {
-            output += data.toString();
+            const chunk = data.toString();
+            output += chunk;
+            writeTaskOutput(taskId, chunk);
           });
           child.stderr?.on("data", (data) => {
-            output += data.toString();
+            const chunk = data.toString();
+            output += chunk;
+            writeTaskOutput(taskId, chunk);
           });
           const task = { process: child, output: "", done: false, exitCode: null };
           backgroundTasks.set(taskId, task);
@@ -63632,10 +64375,16 @@ var init_bash = __esm({
             task.output = output;
             task.done = true;
             task.exitCode = code;
+            completeTask(taskId, output, code ?? void 0);
+          });
+          child.on("error", (err) => {
+            task.done = true;
+            task.exitCode = 1;
+            failTask(taskId, err.message);
           });
           return {
             data: {
-              stdout: `Background task started with ID: ${taskId}`,
+              stdout: `Background task started with ID: ${taskId}. Use TaskOutput to check its status.`,
               stderr: "",
               exitCode: null,
               interrupted: false,
@@ -63748,7 +64497,7 @@ Instructions:
 });
 
 // src/tools/builtin/read.ts
-import { readFileSync as readFileSync8, statSync, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync10, statSync as statSync2, existsSync as existsSync12 } from "fs";
 import { extname, isAbsolute, resolve as resolve2 } from "path";
 function hasFileBeenRead(filePath) {
   return readFiles.has(resolve2(filePath));
@@ -63757,7 +64506,7 @@ function markFileAsRead(filePath) {
   readFiles.add(resolve2(filePath));
 }
 function readTextFile(filePath, input) {
-  const rawContent = readFileSync8(filePath, "utf-8");
+  const rawContent = readFileSync10(filePath, "utf-8");
   const allLines = rawContent.split("\n");
   const totalLines = allLines.length;
   const startLine = input.offset ?? 1;
@@ -63780,7 +64529,7 @@ function readTextFile(filePath, input) {
   };
 }
 function readImageFile(filePath, input) {
-  const stat = statSync(filePath);
+  const stat = statSync2(filePath);
   const ext = extname(filePath).toLowerCase();
   const content = `[Image file: ${filePath} (${ext}, ${formatBytes(stat.size)})]`;
   return {
@@ -63794,7 +64543,7 @@ function readImageFile(filePath, input) {
   };
 }
 function readPdfFile(filePath, input) {
-  const stat = statSync(filePath);
+  const stat = statSync2(filePath);
   const pages = input.pages ?? "1-5";
   const content = `[PDF file: ${filePath} (${formatBytes(stat.size)}, requested pages: ${pages}). PDF reading requires pdf-parse library \u2014 install to enable.]`;
   return {
@@ -63809,7 +64558,7 @@ function readPdfFile(filePath, input) {
 }
 function readNotebookFile(filePath, input) {
   try {
-    const rawContent = readFileSync8(filePath, "utf-8");
+    const rawContent = readFileSync10(filePath, "utf-8");
     const notebook = JSON.parse(rawContent);
     if (!notebook.cells || !Array.isArray(notebook.cells)) {
       return {
@@ -63929,11 +64678,11 @@ var init_read = __esm({
           return { result: false, message: "file_path is required", errorCode: 1 };
         }
         const resolved = resolvePath(input.file_path);
-        if (!existsSync9(resolved)) {
+        if (!existsSync12(resolved)) {
           return { result: false, message: `File does not exist: ${input.file_path}`, errorCode: 2 };
         }
         try {
-          const stat = statSync(resolved);
+          const stat = statSync2(resolved);
           if (stat.isDirectory()) {
             return { result: false, message: `Path is a directory, not a file: ${input.file_path}. Use Bash with ls to list directory contents.`, errorCode: 3 };
           }
@@ -63986,7 +64735,7 @@ Usage:
 });
 
 // src/tools/builtin/edit.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync10, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, existsSync as existsSync13, statSync as statSync3 } from "fs";
 import { resolve as resolve3, isAbsolute as isAbsolute2 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function resolvePath2(filePath) {
@@ -64126,7 +64875,7 @@ var init_edit = __esm({
           return { result: false, message: "old_string and new_string must be different", errorCode: 2 };
         }
         const resolved = resolvePath2(input.file_path);
-        if (!existsSync10(resolved)) {
+        if (!existsSync13(resolved)) {
           return { result: false, message: `File does not exist: ${input.file_path}`, errorCode: 3 };
         }
         if (!hasFileBeenRead(resolved)) {
@@ -64136,7 +64885,7 @@ var init_edit = __esm({
             errorCode: 4
           };
         }
-        const content = readFileSync9(resolved, "utf-8");
+        const content = readFileSync11(resolved, "utf-8");
         const count = countOccurrences(content, input.old_string);
         if (count === 0) {
           return {
@@ -64167,7 +64916,7 @@ var init_edit = __esm({
         const resolved = resolvePath2(input.file_path);
         const MAX_FILE_SIZE = 50 * 1024 * 1024;
         try {
-          const fileSize = statSync2(resolved).size;
+          const fileSize = statSync3(resolved).size;
           if (fileSize > MAX_FILE_SIZE) {
             return {
               data: {
@@ -64182,7 +64931,7 @@ var init_edit = __esm({
           }
         } catch {
         }
-        const originalContent = readFileSync9(resolved, "utf-8");
+        const originalContent = readFileSync11(resolved, "utf-8");
         let newContent;
         let replacements;
         if (input.replace_all) {
@@ -64213,7 +64962,7 @@ var init_edit = __esm({
           );
         } catch {
         }
-        writeFileSync5(resolved, newContent, "utf-8");
+        writeFileSync6(resolved, newContent, "utf-8");
         markFileAsRead(resolved);
         const gitDiff = generateUnifiedDiff(originalContent, newContent, input.file_path);
         return {
@@ -64251,7 +65000,7 @@ Usage:
 });
 
 // src/tools/builtin/write.ts
-import { writeFileSync as writeFileSync6, readFileSync as readFileSync10, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "fs";
+import { writeFileSync as writeFileSync7, readFileSync as readFileSync12, existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
 import { dirname as dirname3, resolve as resolve4, isAbsolute as isAbsolute3 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function resolvePath3(filePath) {
@@ -64324,14 +65073,14 @@ var init_write = __esm({
           return { data: { filePath: "", bytesWritten: 0, created: false } };
         }
         const resolved = resolvePath3(input.file_path);
-        const created = !existsSync11(resolved);
+        const created = !existsSync14(resolved);
         const dir = dirname3(resolved);
-        if (!existsSync11(dir)) {
-          mkdirSync5(dir, { recursive: true });
+        if (!existsSync14(dir)) {
+          mkdirSync6(dir, { recursive: true });
         }
         if (!created) {
           try {
-            const originalContent = readFileSync10(resolved, "utf-8");
+            const originalContent = readFileSync12(resolved, "utf-8");
             const cpId = randomUUID3().slice(0, 8);
             dbRun(
               "INSERT INTO checkpoints (id, session_id, file_path, original_content, edit_operation) VALUES (?, ?, ?, ?, ?)",
@@ -64340,7 +65089,7 @@ var init_write = __esm({
           } catch {
           }
         }
-        writeFileSync6(resolved, input.content, "utf-8");
+        writeFileSync7(resolved, input.content, "utf-8");
         markFileAsRead(resolved);
         return {
           data: {
@@ -67805,18 +68554,18 @@ var require_tasks = __commonJS({
       return patterns.map((pattern) => utils.pattern.removeDuplicateSlashes(pattern));
     }
     function convertPatternsToTasks(positive, negative, dynamic) {
-      const tasks = [];
+      const tasks2 = [];
       const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
       const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
       const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
       const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
-      tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
+      tasks2.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
       if ("." in insideCurrentDirectoryGroup) {
-        tasks.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
+        tasks2.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
       } else {
-        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
+        tasks2.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
       }
-      return tasks;
+      return tasks2;
     }
     exports.convertPatternsToTasks = convertPatternsToTasks;
     function getPositivePatterns(patterns) {
@@ -67994,11 +68743,11 @@ var require_out = __commonJS({
       async.read(path, getSettings2(optionsOrSettingsOrCallback), callback);
     }
     exports.stat = stat;
-    function statSync4(path, optionsOrSettings) {
+    function statSync5(path, optionsOrSettings) {
       const settings = getSettings2(optionsOrSettings);
       return sync.read(path, settings);
     }
-    exports.statSync = statSync4;
+    exports.statSync = statSync5;
     function getSettings2(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -68023,14 +68772,14 @@ var require_run_parallel = __commonJS({
   "node_modules/run-parallel/index.js"(exports, module) {
     module.exports = runParallel;
     var queueMicrotask2 = require_queue_microtask();
-    function runParallel(tasks, cb) {
+    function runParallel(tasks2, cb) {
       let results, pending, keys;
       let isSync = true;
-      if (Array.isArray(tasks)) {
+      if (Array.isArray(tasks2)) {
         results = [];
-        pending = tasks.length;
+        pending = tasks2.length;
       } else {
-        keys = Object.keys(tasks);
+        keys = Object.keys(tasks2);
         results = {};
         pending = keys.length;
       }
@@ -68052,12 +68801,12 @@ var require_run_parallel = __commonJS({
         done(null);
       } else if (keys) {
         keys.forEach(function(key) {
-          tasks[key](function(err, result) {
+          tasks2[key](function(err, result) {
             each(key, err, result);
           });
         });
       } else {
-        tasks.forEach(function(task, i) {
+        tasks2.forEach(function(task, i) {
           task(function(err, result) {
             each(i, err, result);
           });
@@ -68174,8 +68923,8 @@ var require_async2 = __commonJS({
           callSuccessCallback(callback, entries);
           return;
         }
-        const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
-        rpl(tasks, (rplError, rplEntries) => {
+        const tasks2 = entries.map((entry) => makeRplTaskEntry(entry, settings));
+        rpl(tasks2, (rplError, rplEntries) => {
           if (rplError !== null) {
             callFailureCallback(callback, rplError);
             return;
@@ -68211,7 +68960,7 @@ var require_async2 = __commonJS({
           callFailureCallback(callback, readdirError);
           return;
         }
-        const tasks = names.map((name) => {
+        const tasks2 = names.map((name) => {
           const path = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
           return (done) => {
             fsStat.stat(path, settings.fsStatSettings, (error2, stats) => {
@@ -68231,7 +68980,7 @@ var require_async2 = __commonJS({
             });
           };
         });
-        rpl(tasks, (rplError, entries) => {
+        rpl(tasks2, (rplError, entries) => {
           if (rplError !== null) {
             callFailureCallback(callback, rplError);
             return;
@@ -68496,12 +69245,12 @@ var require_queue = __commonJS({
       }
       function getQueue() {
         var current = queueHead;
-        var tasks = [];
+        var tasks2 = [];
         while (current) {
-          tasks.push(current.value);
+          tasks2.push(current.value);
           current = current.next;
         }
-        return tasks;
+        return tasks2;
       }
       function resume() {
         if (!self2.paused) return;
@@ -69867,9 +70616,9 @@ var require_out4 = __commonJS({
     function getWorks(source, _Provider, options2) {
       const patterns = [].concat(source);
       const settings = new settings_1.default(options2);
-      const tasks = taskManager.generate(patterns, settings);
+      const tasks2 = taskManager.generate(patterns, settings);
       const provider = new _Provider(settings);
-      return tasks.map(provider.read, provider);
+      return tasks2.map(provider.read, provider);
     }
     function assertPatternsInput(input) {
       const source = [].concat(input);
@@ -69883,7 +70632,7 @@ var require_out4 = __commonJS({
 });
 
 // src/tools/builtin/glob.ts
-import { statSync as statSync3, existsSync as existsSync12 } from "fs";
+import { statSync as statSync4, existsSync as existsSync15 } from "fs";
 import { resolve as resolve5, isAbsolute as isAbsolute4 } from "path";
 function resolvePath4(p) {
   if (isAbsolute4(p)) return p;
@@ -69949,7 +70698,7 @@ var init_glob = __esm({
       },
       async call(input, context) {
         const cwd2 = input.path ? resolvePath4(input.path) : process.cwd();
-        if (input.path && !existsSync12(cwd2)) {
+        if (input.path && !existsSync15(cwd2)) {
           return {
             data: {
               files: [],
@@ -69980,7 +70729,7 @@ var init_glob = __esm({
           });
           const withStats = allFiles.map((f) => {
             try {
-              const stat = statSync3(f);
+              const stat = statSync4(f);
               return { path: f, mtime: stat.mtimeMs };
             } catch {
               return { path: f, mtime: 0 };
@@ -70282,7 +71031,7 @@ function filterToolsForAgentType(tools, typeDef) {
   const excluded = new Set(typeDef.excludedTools ?? []);
   return tools.filter((t) => allowed.has(t.name) && !excluded.has(t.name));
 }
-function buildSubAgentSystemPrompt(agentType, typeDef) {
+function buildSubAgentSystemPrompt(_agentType, typeDef) {
   return `You are a ${typeDef.description}
 
 You are a sub-agent spawned to handle a specific task. Complete the task thoroughly and return your findings/results.
@@ -70301,7 +71050,7 @@ function extractText(message) {
   }
   return "(no text content)";
 }
-function runAgentInBackground(agentId, record2, input, tools, systemPrompt, model, parentContext) {
+function runAgentInBackground(agentId, bgTaskId, record2, input, tools, systemPrompt, model, parentContext) {
   const abortController = new AbortController();
   runAgentLoop(
     [{ role: "user", content: input.prompt }],
@@ -70314,22 +71063,40 @@ function runAgentInBackground(agentId, record2, input, tools, systemPrompt, mode
       signal: abortController.signal,
       permissionContext: parentContext.getAppState().toolPermissionContext,
       agentId,
-      maxTurns: 25
+      maxTurns: 25,
+      onTextDelta: (_text) => {
+        updateTask(bgTaskId, {
+          progress: {
+            lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        });
+      }
     }
   ).then((result) => {
     const lastAssistant = [...result.messages].reverse().find((m) => m.role === "assistant");
+    const resultText = extractText(lastAssistant);
     record2.status = "completed";
-    record2.result = extractText(lastAssistant);
+    record2.result = resultText;
+    const totalTokens = result.usage.totalInputTokens + result.usage.totalOutputTokens;
+    updateTask(bgTaskId, {
+      progress: {
+        tokenCount: totalTokens,
+        lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    completeTask(bgTaskId, resultText);
   }).catch((error2) => {
+    const errorMsg = error2 instanceof Error ? error2.message : String(error2);
     record2.status = "failed";
-    record2.error = error2 instanceof Error ? error2.message : String(error2);
+    record2.error = errorMsg;
+    failTask(bgTaskId, errorMsg);
   });
 }
 function truncate3(str, maxLen) {
   if (str.length <= maxLen) return str;
   return str.slice(0, maxLen - 100) + "\n\n... (truncated)";
 }
-var BUILTIN_AGENT_TYPES, AgentInputSchema, AgentOutputSchema, nextAgentId, runningAgents, agentTool, AGENT_PROMPT;
+var BUILTIN_AGENT_TYPES, AgentInputSchema, AgentOutputSchema, nextAgentId2, runningAgents, agentTool, AGENT_PROMPT;
 var init_agent = __esm({
   "src/tools/builtin/agent.ts"() {
     "use strict";
@@ -70337,6 +71104,7 @@ var init_agent = __esm({
     init_constants();
     init_agent_loop();
     init_client();
+    init_background_tasks();
     BUILTIN_AGENT_TYPES = {
       "general-purpose": {
         name: "general-purpose",
@@ -70379,7 +71147,7 @@ var init_agent = __esm({
       usage: external_exports.object({ inputTokens: external_exports.number(), outputTokens: external_exports.number() }),
       backgrounded: external_exports.boolean().optional()
     });
-    nextAgentId = 1;
+    nextAgentId2 = 1;
     runningAgents = /* @__PURE__ */ new Map();
     agentTool = {
       name: AGENT_TOOL,
@@ -70427,7 +71195,7 @@ var init_agent = __esm({
         return { behavior: "allow", updatedInput: input };
       },
       async call(input, context) {
-        const agentId = `agent-${nextAgentId++}`;
+        const agentId = `agent-${nextAgentId2++}`;
         const agentType = input.subagent_type ?? "general-purpose";
         const typeDef = BUILTIN_AGENT_TYPES[agentType] ?? BUILTIN_AGENT_TYPES["general-purpose"];
         const model = input.model ?? "sonnet";
@@ -70448,17 +71216,18 @@ var init_agent = __esm({
           inputSchema: { type: "object", properties: {} },
           isReadOnly: t.isReadOnly(),
           isConcurrencySafe: t.isConcurrencySafe(),
-          call: async (toolInput, toolCtx) => {
+          call: async (toolInput, _toolCtx) => {
             const result = await t.call(toolInput, context);
             return { data: result.data };
           }
         }));
         const systemPrompt = buildSubAgentSystemPrompt(agentType, typeDef);
         if (input.run_in_background) {
-          runAgentInBackground(agentId, agentRecord, input, toolHandlers, systemPrompt, model, context);
+          const bgTask = createTask("agent", input.prompt.slice(0, 100));
+          runAgentInBackground(agentId, bgTask.id, agentRecord, input, toolHandlers, systemPrompt, model, context);
           return {
             data: {
-              result: `Agent ${agentId} (${agentType}) started in background. You will be notified when it completes.`,
+              result: `Agent ${agentId} (${agentType}) started in background. Task ID: ${bgTask.id}. Use TaskOutput to check its status.`,
               agentId,
               agentType,
               model,
@@ -70494,7 +71263,10 @@ var init_agent = __esm({
               agentType,
               model,
               totalTurns: loopResult.totalTurns,
-              usage: loopResult.usage
+              usage: {
+                inputTokens: loopResult.usage.totalInputTokens,
+                outputTokens: loopResult.usage.totalOutputTokens
+              }
             }
           };
         } catch (error2) {
@@ -70645,11 +71417,11 @@ var init_todos = __esm({
           });
           return result.map(mapFromHasna);
         }
-        let tasks = [...this.fallbackStore.values()];
+        let tasks2 = [...this.fallbackStore.values()];
         if (filter?.status) {
-          tasks = tasks.filter((t) => t.status === filter.status);
+          tasks2 = tasks2.filter((t) => t.status === filter.status);
         }
-        return tasks;
+        return tasks2;
       }
       async updateTask(id, params) {
         if (this.hasnaTodos) {
@@ -70722,23 +71494,23 @@ var init_todos = __esm({
           await this.hasnaTodos.sync({ taskListId: this.taskListId, direction: "push" });
           return;
         }
-        const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync9, existsSync: existsSync17 } = await import("fs");
-        const { join: join10 } = await import("path");
-        if (!existsSync17(dir)) mkdirSync9(dir, { recursive: true });
-        const tasks = await this.listTasks();
-        for (const task of tasks) {
-          const filePath = join10(dir, `${task.id}.json`);
+        const { writeFileSync: writeFileSync10, mkdirSync: mkdirSync9, existsSync: existsSync19 } = await import("fs");
+        const { join: join12 } = await import("path");
+        if (!existsSync19(dir)) mkdirSync9(dir, { recursive: true });
+        const tasks2 = await this.listTasks();
+        for (const task of tasks2) {
+          const filePath = join12(dir, `${task.id}.json`);
           writeFileSync10(filePath, JSON.stringify(task, null, 2), "utf-8");
         }
       }
       // ── Stats ──────────────────────────────────────────────────────
       async getStats() {
-        const tasks = await this.listTasks();
+        const tasks2 = await this.listTasks();
         return {
-          total: tasks.length,
-          pending: tasks.filter((t) => t.status === "pending").length,
-          inProgress: tasks.filter((t) => t.status === "in_progress").length,
-          completed: tasks.filter((t) => t.status === "completed").length
+          total: tasks2.length,
+          pending: tasks2.filter((t) => t.status === "pending").length,
+          inProgress: tasks2.filter((t) => t.status === "in_progress").length,
+          completed: tasks2.filter((t) => t.status === "completed").length
         };
       }
     };
@@ -70922,8 +71694,8 @@ var init_tasks = __esm({
       },
       async call() {
         const todos = getTodosIntegration();
-        const tasks = await todos.listTasks();
-        return { data: { tasks } };
+        const tasks2 = await todos.listTasks();
+        return { data: { tasks: tasks2 } };
       },
       mapToolResultToToolResultBlockParam(result, toolUseId) {
         if (result.tasks.length === 0) {
@@ -71065,6 +71837,251 @@ var init_tasks = __esm({
   }
 });
 
+// src/tools/builtin/task-output.ts
+var MAX_OUTPUT_CHARS, TaskOutputInputSchema, TaskOutputOutputSchema, taskOutputTool, TaskStopInputSchema, TaskStopOutputSchema, taskStopTool, TASK_OUTPUT_PROMPT, TASK_STOP_PROMPT;
+var init_task_output = __esm({
+  "src/tools/builtin/task-output.ts"() {
+    "use strict";
+    init_zod();
+    init_constants();
+    init_background_tasks();
+    MAX_OUTPUT_CHARS = 3e4;
+    TaskOutputInputSchema = external_exports.strictObject({
+      task_id: external_exports.string().describe("The ID of the background task to check (e.g. 'bg-1', 'agent-2')")
+    });
+    TaskOutputOutputSchema = external_exports.object({
+      task_id: external_exports.string(),
+      status: external_exports.string(),
+      output: external_exports.string(),
+      exitCode: external_exports.number().nullable().optional(),
+      durationMs: external_exports.number().optional(),
+      error: external_exports.string().optional(),
+      progress: external_exports.object({
+        tokenCount: external_exports.number().optional(),
+        lastActivity: external_exports.string().optional()
+      }).optional()
+    });
+    taskOutputTool = {
+      name: TASK_OUTPUT_TOOL,
+      searchHint: "check status and output of a background task",
+      maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+      shouldDefer: true,
+      async description() {
+        return "Check the status and output of a background task";
+      },
+      async prompt() {
+        return TASK_OUTPUT_PROMPT;
+      },
+      get inputSchema() {
+        return TaskOutputInputSchema;
+      },
+      get outputSchema() {
+        return TaskOutputOutputSchema;
+      },
+      userFacingName() {
+        return "TaskOutput";
+      },
+      isEnabled() {
+        return true;
+      },
+      isConcurrencySafe() {
+        return true;
+      },
+      isReadOnly() {
+        return true;
+      },
+      toAutoClassifierInput(input) {
+        return input.task_id;
+      },
+      getActivityDescription(input) {
+        return `Checking task ${input.task_id}`;
+      },
+      async validateInput(input) {
+        if (!input.task_id || !input.task_id.trim()) {
+          return { result: false, message: "task_id is required", errorCode: 1 };
+        }
+        return { result: true };
+      },
+      async checkPermissions(input) {
+        return { behavior: "allow", updatedInput: input };
+      },
+      async call(input) {
+        const task = getTask(input.task_id);
+        if (!task) {
+          return {
+            data: {
+              task_id: input.task_id,
+              status: "not_found",
+              output: `No background task found with ID "${input.task_id}". Use TaskList or check the ID returned when you started the background task.`,
+              error: `Task "${input.task_id}" not found`
+            }
+          };
+        }
+        let output = readTaskOutput(task.id);
+        if (!output && task.output) output = task.output;
+        if (output.length > MAX_OUTPUT_CHARS) {
+          const half = Math.floor(MAX_OUTPUT_CHARS / 2);
+          output = output.slice(0, half) + `
+
+... (${output.length - MAX_OUTPUT_CHARS} characters truncated) ...
+
+` + output.slice(-half);
+        }
+        const durationMs = task.endTime ? task.endTime - task.startTime : Date.now() - task.startTime;
+        return {
+          data: {
+            task_id: task.id,
+            status: task.status,
+            output: output || "(no output yet)",
+            exitCode: task.exitCode,
+            durationMs,
+            error: task.error,
+            progress: task.progress
+          }
+        };
+      },
+      mapToolResultToToolResultBlockParam(result, toolUseId) {
+        const parts = [];
+        parts.push(`Task: ${result.task_id}`);
+        parts.push(`Status: ${result.status}`);
+        if (result.durationMs != null) {
+          const sec = (result.durationMs / 1e3).toFixed(1);
+          parts.push(`Duration: ${sec}s`);
+        }
+        if (result.exitCode != null) {
+          parts.push(`Exit code: ${result.exitCode}`);
+        }
+        if (result.progress?.tokenCount) {
+          parts.push(`Tokens: ${result.progress.tokenCount}`);
+        }
+        if (result.progress?.lastActivity) {
+          parts.push(`Last activity: ${result.progress.lastActivity}`);
+        }
+        if (result.error) {
+          parts.push(`Error: ${result.error}`);
+        }
+        parts.push("");
+        parts.push(result.output);
+        return {
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          content: parts.join("\n"),
+          is_error: result.status === "not_found"
+        };
+      }
+    };
+    TaskStopInputSchema = external_exports.strictObject({
+      task_id: external_exports.string().describe("The ID of the background task to stop (e.g. 'bg-1', 'agent-2')")
+    });
+    TaskStopOutputSchema = external_exports.object({
+      task_id: external_exports.string(),
+      status: external_exports.string(),
+      message: external_exports.string()
+    });
+    taskStopTool = {
+      name: TASK_STOP_TOOL,
+      searchHint: "stop kill a running background task",
+      maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+      shouldDefer: true,
+      async description() {
+        return "Stop a running background task";
+      },
+      async prompt() {
+        return TASK_STOP_PROMPT;
+      },
+      get inputSchema() {
+        return TaskStopInputSchema;
+      },
+      get outputSchema() {
+        return TaskStopOutputSchema;
+      },
+      userFacingName() {
+        return "TaskStop";
+      },
+      isEnabled() {
+        return true;
+      },
+      isConcurrencySafe() {
+        return true;
+      },
+      isReadOnly() {
+        return false;
+      },
+      toAutoClassifierInput(input) {
+        return input.task_id;
+      },
+      getActivityDescription(input) {
+        return `Stopping task ${input.task_id}`;
+      },
+      async validateInput(input) {
+        if (!input.task_id || !input.task_id.trim()) {
+          return { result: false, message: "task_id is required", errorCode: 1 };
+        }
+        return { result: true };
+      },
+      async checkPermissions(input) {
+        return { behavior: "allow", updatedInput: input };
+      },
+      async call(input) {
+        const task = getTask(input.task_id);
+        if (!task) {
+          return {
+            data: {
+              task_id: input.task_id,
+              status: "not_found",
+              message: `No background task found with ID "${input.task_id}".`
+            }
+          };
+        }
+        if (task.status !== "running") {
+          return {
+            data: {
+              task_id: task.id,
+              status: task.status,
+              message: `Task ${task.id} is already ${task.status} \u2014 cannot stop.`
+            }
+          };
+        }
+        killTask(task.id);
+        return {
+          data: {
+            task_id: task.id,
+            status: "killed",
+            message: `Task ${task.id} has been killed.`
+          }
+        };
+      },
+      mapToolResultToToolResultBlockParam(result, toolUseId) {
+        return {
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          content: result.message,
+          is_error: result.status === "not_found"
+        };
+      }
+    };
+    TASK_OUTPUT_PROMPT = `Check the status and output of a background task.
+
+Use this tool when you have previously started a bash command or agent with run_in_background:true
+and need to check whether it has completed, and retrieve its output.
+
+The task_id is returned when you start a background task (e.g., "bg-1" for bash, "agent-1" for agents).
+
+The tool returns:
+- status: "running", "completed", "failed", or "killed"
+- output: The stdout/stderr from the task (truncated to 30000 chars)
+- exitCode: The exit code (for bash tasks)
+- durationMs: How long the task has been running or ran
+- progress: For agents, includes tokenCount and lastActivity`;
+    TASK_STOP_PROMPT = `Stop a running background task.
+
+Use this tool to kill a background bash command or agent that is still running.
+The task will be marked as "killed" and its process terminated.
+
+The task_id is returned when you start a background task (e.g., "bg-1" for bash, "agent-1" for agents).`;
+  }
+});
+
 // src/tools/builtin/ask-user.ts
 var OptionSchema, QuestionSchema, AskUserInputSchema, AskUserOutputSchema, askUserQuestionTool, ASK_USER_PROMPT;
 var init_ask_user = __esm({
@@ -71471,17 +72488,17 @@ LSP servers must be configured for the file type.`;
 });
 
 // src/tools/builtin/plan-mode.ts
-import { readFileSync as readFileSync11, existsSync as existsSync13 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync16 } from "fs";
+import { join as join10 } from "path";
 function getPlanFilePath(agentId) {
   const dir = getPlansDir();
   const name = agentId ? `plan-${agentId}.md` : "plan.md";
-  return join7(dir, name);
+  return join10(dir, name);
 }
 function readPlanFile(agentId) {
   const path = getPlanFilePath(agentId);
-  if (!existsSync13(path)) return null;
-  return readFileSync11(path, "utf-8");
+  if (!existsSync16(path)) return null;
+  return readFileSync13(path, "utf-8");
 }
 var _hasExitedPlanMode, EnterPlanInputSchema, EnterPlanOutputSchema, enterPlanModeTool, ExitPlanInputSchema, ExitPlanOutputSchema, exitPlanModeTool, ENTER_PLAN_PROMPT, EXIT_PLAN_PROMPT;
 var init_plan_mode = __esm({
@@ -71709,8 +72726,43 @@ function getEnabledTools() {
   }
   return tools;
 }
-function getDeferredToolInfos() {
-  return [...deferredTools.values()];
+function setDeferredToolSchemas(schemas) {
+  for (const s of schemas) {
+    deferredToolSchemas.set(s.name, s);
+  }
+}
+function getAllDeferredToolSchemas() {
+  return [...deferredToolSchemas.values()];
+}
+function searchDeferredToolSchemas(query, maxResults = 5) {
+  const queryLower = query.toLowerCase();
+  const queryTerms = queryLower.split(/\s+/);
+  if (queryLower.startsWith("select:")) {
+    const names = query.slice(7).split(",").map((n) => n.trim());
+    return names.map((n) => deferredToolSchemas.get(n)).filter((s) => s !== void 0);
+  }
+  const requiredTerms = queryTerms.filter((t) => t.startsWith("+")).map((t) => t.slice(1));
+  const searchTerms = queryTerms.filter((t) => !t.startsWith("+"));
+  const results = [];
+  for (const schema of deferredToolSchemas.values()) {
+    const nameLower = schema.name.toLowerCase();
+    const descLower = schema.description.toLowerCase();
+    if (requiredTerms.length > 0 && !requiredTerms.every((rt) => nameLower.includes(rt))) {
+      continue;
+    }
+    let score = 0;
+    const allTerms = searchTerms.length > 0 ? searchTerms : requiredTerms;
+    for (const term of allTerms) {
+      if (nameLower === term) score += 10;
+      else if (nameLower.includes(term)) score += 5;
+      if (descLower.includes(term)) score += 3;
+    }
+    if (score > 0) {
+      results.push({ schema, score });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, maxResults).map((r) => r.schema);
 }
 function searchTools(query, maxResults = 5) {
   const results = [];
@@ -71748,7 +72800,7 @@ function matchScore(name, hint, queryTerms) {
   }
   return score;
 }
-var registeredTools, deferredTools, disabledTools, mcpTools;
+var registeredTools, deferredTools, disabledTools, mcpTools, deferredToolSchemas;
 var init_registry2 = __esm({
   "src/tools/registry.ts"() {
     "use strict";
@@ -71757,6 +72809,7 @@ var init_registry2 = __esm({
     deferredTools = /* @__PURE__ */ new Map();
     disabledTools = /* @__PURE__ */ new Set();
     mcpTools = /* @__PURE__ */ new Map();
+    deferredToolSchemas = /* @__PURE__ */ new Map();
   }
 });
 
@@ -71804,6 +72857,24 @@ function simpleTool(opts) {
     mapToolResultToToolResultBlockParam: opts.mapResult
   };
 }
+function toNotebookSource(text) {
+  const lines = text.split("\n");
+  return lines.map(
+    (l, i) => i < lines.length - 1 ? l + "\n" : l
+  );
+}
+function createCell(cellType, source) {
+  const base = {
+    cell_type: cellType,
+    metadata: {},
+    source: toNotebookSource(source)
+  };
+  if (cellType === "code") {
+    base.execution_count = null;
+    base.outputs = [];
+  }
+  return base;
+}
 var toolSearchTool, cronCreateTool, cronDeleteTool, cronListTool, enterWorktreeTool, exitWorktreeTool, notebookEditTool, configTool, sendMessageTool;
 var init_misc = __esm({
   "src/tools/builtin/misc.ts"() {
@@ -71813,30 +72884,68 @@ var init_misc = __esm({
     init_constants();
     toolSearchTool = simpleTool({
       name: TOOL_SEARCH_TOOL,
-      hint: "find available tools by keyword",
+      hint: "find available tools by keyword \u2014 fetches full schemas for deferred tools",
       inputSchema: external_exports.strictObject({
-        query: external_exports.string().describe("Query to find tools"),
-        max_results: external_exports.number().default(5).describe("Max results")
+        query: external_exports.string().describe(
+          'Query to find deferred tools. Use "select:Read,Edit,Grep" for exact names, or keywords to search. Use "+slack send" to require "slack" in name.'
+        ),
+        max_results: external_exports.number().default(5).describe("Maximum number of results to return (default: 5)")
       }),
       readOnly: true,
       concurrent: true,
       defer: false,
-      prompt: "Search for available tools by keyword. Use to discover deferred tools.",
+      prompt: `Fetches full schema definitions for deferred tools so they can be called.
+
+Deferred tools appear by name in the "Deferred Tools" section of the system prompt. Until fetched, only the name is known \u2014 there is no parameter schema, so the tool cannot be invoked. This tool takes a query, matches it against the deferred tool list, and returns the matched tools' complete JSONSchema definitions inside a <functions> block. Once a tool's schema appears in that result, it is callable exactly like any tool defined at the top of the prompt.
+
+Result format: each matched tool appears as one <function>{"description": "...", "name": "...", "parameters": {...}}</function> line inside the <functions> block \u2014 the same encoding as the tool list at the top of this prompt.
+
+Query forms:
+- "select:Read,Edit,Grep" \u2014 fetch these exact tools by name
+- "notebook jupyter" \u2014 keyword search, up to max_results best matches
+- "+slack send" \u2014 require "slack" in the name, rank by remaining terms`,
       async call(input) {
-        const results = searchTools(input.query, input.max_results);
-        const deferred = getDeferredToolInfos();
+        const matchedSchemas = searchDeferredToolSchemas(input.query, input.max_results);
+        const registryResults = searchTools(input.query, input.max_results);
+        const allDeferred = getAllDeferredToolSchemas();
         return {
           data: {
-            results,
-            deferredCount: deferred.length
+            matchedSchemas,
+            registryResults,
+            totalDeferredCount: allDeferred.length
           }
         };
       },
       mapResult(result, id) {
-        const lines = result.results.map(
-          (r) => `${r.name}${r.deferred ? " (deferred)" : ""}: ${r.hint}`
-        );
-        return { type: "tool_result", tool_use_id: id, content: lines.join("\n") || "No tools found." };
+        const sections = [];
+        const schemas = result.matchedSchemas;
+        if (schemas && schemas.length > 0) {
+          const functionDefs = schemas.map(
+            (s) => `<function>{"description": ${JSON.stringify(s.description)}, "name": ${JSON.stringify(s.name)}, "parameters": ${JSON.stringify(s.inputSchema)}}</function>`
+          ).join("\n");
+          sections.push(`<functions>
+${functionDefs}
+</functions>`);
+        }
+        const registryResults = result.registryResults;
+        if (registryResults && registryResults.length > 0) {
+          const extraHits = registryResults.filter(
+            (r) => !schemas?.some((s) => s.name === r.name)
+          );
+          if (extraHits.length > 0) {
+            const lines = extraHits.map(
+              (r) => `${r.name}${r.deferred ? " (deferred)" : ""}: ${r.hint}`
+            );
+            sections.push(lines.join("\n"));
+          }
+        }
+        if (sections.length === 0) {
+          return { type: "tool_result", tool_use_id: id, content: "No tools found matching the query." };
+        }
+        const footer = `
+
+${result.totalDeferredCount} deferred tool(s) available. Use ToolSearch to fetch schemas for any listed tool.`;
+        return { type: "tool_result", tool_use_id: id, content: sections.join("\n\n") + footer };
       }
     });
     cronCreateTool = simpleTool({
@@ -71924,34 +73033,134 @@ var init_misc = __esm({
     });
     notebookEditTool = simpleTool({
       name: NOTEBOOK_EDIT_TOOL,
-      hint: "edit Jupyter notebook cells",
+      hint: "edit Jupyter notebook cells \u2014 insert, replace, delete, move, change type",
       inputSchema: external_exports.strictObject({
         notebook_path: external_exports.string().describe("Path to the .ipynb file"),
-        cell_index: external_exports.number().describe("Cell index to edit"),
-        new_source: external_exports.string().describe("New cell source code")
+        command: external_exports.enum(["insert_cell", "replace_cell", "delete_cell", "move_cell", "change_cell_type"]).describe("Operation to perform"),
+        cell_index: external_exports.number().optional().describe("Cell index to operate on (0-based). For insert_cell, position to insert at (omit to append)."),
+        cell_type: external_exports.enum(["code", "markdown", "raw"]).optional().describe("Cell type \u2014 required for insert_cell and change_cell_type"),
+        new_source: external_exports.string().optional().describe("New cell content \u2014 required for insert_cell and replace_cell"),
+        target_index: external_exports.number().optional().describe("Destination index for move_cell")
       }),
       readOnly: false,
       concurrent: false,
-      defer: true,
-      prompt: "Edit a specific cell in a Jupyter notebook (.ipynb file).",
+      defer: false,
+      prompt: `Edit Jupyter notebook (.ipynb) cells. Supports 5 commands:
+
+- insert_cell: Insert a new cell at cell_index (or end if omitted). Requires cell_type and new_source.
+- replace_cell: Replace the source of the cell at cell_index with new_source. Requires cell_index and new_source.
+- delete_cell: Delete the cell at cell_index. Requires cell_index.
+- move_cell: Move cell from cell_index to target_index. Requires cell_index and target_index.
+- change_cell_type: Change the type of cell at cell_index to cell_type. Requires cell_index and cell_type.
+
+All metadata, outputs, and kernel info are preserved. Cell indices are 0-based.`,
       async call(input) {
-        const { readFileSync: readFileSync14, writeFileSync: writeFileSync10 } = await import("fs");
+        const { readFileSync: readFileSync15, writeFileSync: writeFileSync10 } = await import("fs");
+        const { resolve: resolve8 } = await import("path");
+        const notebookPath = resolve8(input.notebook_path);
         try {
-          const content = JSON.parse(readFileSync14(input.notebook_path, "utf-8"));
-          if (content.cells && content.cells[input.cell_index]) {
-            content.cells[input.cell_index].source = input.new_source.split("\n").map(
-              (l, i, a) => i < a.length - 1 ? l + "\n" : l
-            );
-            writeFileSync10(input.notebook_path, JSON.stringify(content, null, 1), "utf-8");
-            return { data: { success: true, cellIndex: input.cell_index } };
+          const raw = readFileSync15(notebookPath, "utf-8");
+          const notebook = JSON.parse(raw);
+          if (!notebook.cells || !Array.isArray(notebook.cells)) {
+            return { data: { success: false, error: "Invalid notebook: no cells array found" } };
+          }
+          const cells = notebook.cells;
+          const totalCells = cells.length;
+          switch (input.command) {
+            case "insert_cell": {
+              if (!input.cell_type) return { data: { success: false, error: "insert_cell requires cell_type" } };
+              const source = input.new_source ?? "";
+              const newCell = createCell(input.cell_type, source);
+              const idx = input.cell_index ?? totalCells;
+              if (idx < 0 || idx > totalCells) {
+                return { data: { success: false, error: `cell_index ${idx} out of range (0-${totalCells})` } };
+              }
+              cells.splice(idx, 0, newCell);
+              notebook.cells = cells;
+              writeFileSync10(notebookPath, JSON.stringify(notebook, null, 1), "utf-8");
+              return { data: { success: true, message: `Inserted ${input.cell_type} cell at index ${idx} (notebook now has ${cells.length} cells)` } };
+            }
+            case "replace_cell": {
+              if (input.cell_index == null) return { data: { success: false, error: "replace_cell requires cell_index" } };
+              if (input.new_source == null) return { data: { success: false, error: "replace_cell requires new_source" } };
+              if (input.cell_index < 0 || input.cell_index >= totalCells) {
+                return { data: { success: false, error: `cell_index ${input.cell_index} out of range (0-${totalCells - 1})` } };
+              }
+              const cell = cells[input.cell_index];
+              cell.source = toNotebookSource(input.new_source);
+              if (cell.cell_type === "code") {
+                cell.outputs = [];
+                cell.execution_count = null;
+              }
+              writeFileSync10(notebookPath, JSON.stringify(notebook, null, 1), "utf-8");
+              return { data: { success: true, message: `Replaced source of cell ${input.cell_index} (${cell.cell_type})` } };
+            }
+            case "delete_cell": {
+              if (input.cell_index == null) return { data: { success: false, error: "delete_cell requires cell_index" } };
+              if (input.cell_index < 0 || input.cell_index >= totalCells) {
+                return { data: { success: false, error: `cell_index ${input.cell_index} out of range (0-${totalCells - 1})` } };
+              }
+              const deletedType = cells[input.cell_index].cell_type;
+              cells.splice(input.cell_index, 1);
+              notebook.cells = cells;
+              writeFileSync10(notebookPath, JSON.stringify(notebook, null, 1), "utf-8");
+              return { data: { success: true, message: `Deleted ${deletedType} cell at index ${input.cell_index} (notebook now has ${cells.length} cells)` } };
+            }
+            case "move_cell": {
+              if (input.cell_index == null) return { data: { success: false, error: "move_cell requires cell_index" } };
+              if (input.target_index == null) return { data: { success: false, error: "move_cell requires target_index" } };
+              if (input.cell_index < 0 || input.cell_index >= totalCells) {
+                return { data: { success: false, error: `cell_index ${input.cell_index} out of range (0-${totalCells - 1})` } };
+              }
+              if (input.target_index < 0 || input.target_index >= totalCells) {
+                return { data: { success: false, error: `target_index ${input.target_index} out of range (0-${totalCells - 1})` } };
+              }
+              if (input.cell_index === input.target_index) {
+                return { data: { success: true, message: `Cell ${input.cell_index} is already at target position` } };
+              }
+              const [movedCell] = cells.splice(input.cell_index, 1);
+              cells.splice(input.target_index, 0, movedCell);
+              notebook.cells = cells;
+              writeFileSync10(notebookPath, JSON.stringify(notebook, null, 1), "utf-8");
+              return { data: { success: true, message: `Moved cell from index ${input.cell_index} to index ${input.target_index}` } };
+            }
+            case "change_cell_type": {
+              if (input.cell_index == null) return { data: { success: false, error: "change_cell_type requires cell_index" } };
+              if (!input.cell_type) return { data: { success: false, error: "change_cell_type requires cell_type" } };
+              if (input.cell_index < 0 || input.cell_index >= totalCells) {
+                return { data: { success: false, error: `cell_index ${input.cell_index} out of range (0-${totalCells - 1})` } };
+              }
+              const cell = cells[input.cell_index];
+              const oldType = cell.cell_type;
+              if (oldType === input.cell_type) {
+                return { data: { success: true, message: `Cell ${input.cell_index} is already type ${input.cell_type}` } };
+              }
+              cell.cell_type = input.cell_type;
+              if (input.cell_type === "code") {
+                if (!("execution_count" in cell)) cell.execution_count = null;
+                if (!("outputs" in cell)) cell.outputs = [];
+              }
+              if (oldType === "code" && input.cell_type !== "code") {
+                delete cell.execution_count;
+                delete cell.outputs;
+              }
+              writeFileSync10(notebookPath, JSON.stringify(notebook, null, 1), "utf-8");
+              return { data: { success: true, message: `Changed cell ${input.cell_index} from ${oldType} to ${input.cell_type}` } };
+            }
+            default:
+              return { data: { success: false, error: `Unknown command: ${input.command}` } };
           }
-          return { data: { success: false, error: "Cell index out of range" } };
         } catch (e) {
           return { data: { success: false, error: String(e) } };
         }
       },
       mapResult(result, id) {
-        return { type: "tool_result", tool_use_id: id, content: result.success ? `Edited cell ${result.cellIndex}` : `Error: ${result.error}` };
+        return {
+          type: "tool_result",
+          tool_use_id: id,
+          content: result.success ? result.message : `Error: ${result.error}`,
+          ...result.success ? {} : { is_error: true }
+        };
       }
     });
     configTool = simpleTool({
@@ -78249,9 +79458,9 @@ var init_protocol = __esm({
           });
           this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
             try {
-              const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
+              const { tasks: tasks2, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
               return {
-                tasks,
+                tasks: tasks2,
                 nextCursor,
                 _meta: {}
               };
@@ -88942,6 +90151,13 @@ async function connectMcpServers(configs, batchSize = DEFAULT_BATCH_SIZE) {
   }
   return results;
 }
+function getServerClient(name) {
+  const server = connectedServers.get(name);
+  return server?.client ?? null;
+}
+function getConnectedServerNames() {
+  return [...connectedServers.keys()];
+}
 function wrapMcpTool(serverName, mcpTool, client) {
   const toolName = `mcp__${serverName}__${mcpTool.name}`;
   return {
@@ -89027,6 +90243,239 @@ var init_client4 = __esm({
   }
 });
 
+// src/tools/builtin/mcp-resources.ts
+var ListMcpResourcesInputSchema, ListMcpResourcesOutputSchema, listMcpResourcesTool, LIST_MCP_RESOURCES_PROMPT, ReadMcpResourceInputSchema, ReadMcpResourceOutputSchema, readMcpResourceTool, READ_MCP_RESOURCE_PROMPT;
+var init_mcp_resources = __esm({
+  "src/tools/builtin/mcp-resources.ts"() {
+    "use strict";
+    init_zod();
+    init_constants();
+    init_client4();
+    ListMcpResourcesInputSchema = external_exports.strictObject({});
+    ListMcpResourcesOutputSchema = external_exports.object({
+      resources: external_exports.array(external_exports.object({
+        server: external_exports.string(),
+        uri: external_exports.string(),
+        name: external_exports.string(),
+        description: external_exports.string().optional(),
+        mimeType: external_exports.string().optional()
+      })),
+      totalCount: external_exports.number()
+    });
+    listMcpResourcesTool = {
+      name: LIST_MCP_RESOURCES_TOOL,
+      searchHint: "list MCP server resources",
+      maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+      shouldDefer: true,
+      async description() {
+        return "List all resources available from connected MCP servers.";
+      },
+      async prompt() {
+        return LIST_MCP_RESOURCES_PROMPT;
+      },
+      get inputSchema() {
+        return ListMcpResourcesInputSchema;
+      },
+      get outputSchema() {
+        return ListMcpResourcesOutputSchema;
+      },
+      userFacingName() {
+        return "List MCP Resources";
+      },
+      isEnabled() {
+        return true;
+      },
+      isConcurrencySafe() {
+        return true;
+      },
+      isReadOnly() {
+        return true;
+      },
+      toAutoClassifierInput() {
+        return "list mcp resources";
+      },
+      async validateInput() {
+        return { result: true };
+      },
+      async checkPermissions() {
+        return { behavior: "allow" };
+      },
+      async call(_input, _context) {
+        const serverNames = getConnectedServerNames();
+        const resources = [];
+        for (const serverName of serverNames) {
+          const client = getServerClient(serverName);
+          if (!client) continue;
+          try {
+            const result = await client.listResources();
+            if (result.resources && Array.isArray(result.resources)) {
+              for (const res of result.resources) {
+                resources.push({
+                  server: serverName,
+                  uri: res.uri,
+                  name: res.name,
+                  description: res.description,
+                  mimeType: res.mimeType
+                });
+              }
+            }
+          } catch {
+          }
+        }
+        return {
+          data: {
+            resources,
+            totalCount: resources.length
+          }
+        };
+      },
+      mapToolResultToToolResultBlockParam(result, toolUseId) {
+        if (result.resources.length === 0) {
+          return {
+            type: "tool_result",
+            tool_use_id: toolUseId,
+            content: "No resources found from any connected MCP server."
+          };
+        }
+        const lines = result.resources.map((r) => {
+          let line = `[${r.server}] ${r.uri} \u2014 ${r.name}`;
+          if (r.description) line += ` (${r.description})`;
+          if (r.mimeType) line += ` [${r.mimeType}]`;
+          return line;
+        });
+        return {
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          content: `Found ${result.totalCount} resource(s):
+
+${lines.join("\n")}`
+        };
+      }
+    };
+    LIST_MCP_RESOURCES_PROMPT = `List all resources available from connected MCP servers.
+- Returns resources with server name, URI, name, description, and MIME type
+- No input required \u2014 queries all connected servers
+- Use ReadMcpResourceTool to read a specific resource by server name and URI`;
+    ReadMcpResourceInputSchema = external_exports.strictObject({
+      server_name: external_exports.string().describe("The name of the MCP server that owns the resource"),
+      uri: external_exports.string().describe("The URI of the resource to read")
+    });
+    ReadMcpResourceOutputSchema = external_exports.object({
+      contents: external_exports.array(external_exports.object({
+        uri: external_exports.string(),
+        mimeType: external_exports.string().optional(),
+        text: external_exports.string().optional(),
+        blob: external_exports.string().optional()
+      }))
+    });
+    readMcpResourceTool = {
+      name: READ_MCP_RESOURCE_TOOL,
+      searchHint: "read MCP server resource by URI",
+      maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+      shouldDefer: true,
+      async description(input) {
+        return input?.uri ? `Read MCP resource: ${input.uri}` : "Read a resource from a connected MCP server.";
+      },
+      async prompt() {
+        return READ_MCP_RESOURCE_PROMPT;
+      },
+      get inputSchema() {
+        return ReadMcpResourceInputSchema;
+      },
+      get outputSchema() {
+        return ReadMcpResourceOutputSchema;
+      },
+      userFacingName() {
+        return "Read MCP Resource";
+      },
+      isEnabled() {
+        return true;
+      },
+      isConcurrencySafe() {
+        return true;
+      },
+      isReadOnly() {
+        return true;
+      },
+      toAutoClassifierInput(input) {
+        return `${input.server_name} ${input.uri}`;
+      },
+      async validateInput(input) {
+        if (!input.server_name?.trim()) {
+          return { result: false, message: "server_name is required", errorCode: 1 };
+        }
+        if (!input.uri?.trim()) {
+          return { result: false, message: "uri is required", errorCode: 2 };
+        }
+        return { result: true };
+      },
+      async checkPermissions() {
+        return { behavior: "allow" };
+      },
+      async call(input, _context) {
+        const client = getServerClient(input.server_name);
+        if (!client) {
+          return {
+            data: {
+              contents: [{
+                uri: input.uri,
+                text: `Error: MCP server "${input.server_name}" is not connected. Use ListMcpResourcesTool to see available servers.`
+              }]
+            }
+          };
+        }
+        try {
+          const result = await client.readResource({ uri: input.uri });
+          const contents = (result.contents ?? []).map((c) => ({
+            uri: c.uri ?? input.uri,
+            mimeType: c.mimeType,
+            text: c.text,
+            blob: c.blob
+          }));
+          return { data: { contents } };
+        } catch (error2) {
+          return {
+            data: {
+              contents: [{
+                uri: input.uri,
+                text: `Error reading resource: ${error2 instanceof Error ? error2.message : String(error2)}`
+              }]
+            }
+          };
+        }
+      },
+      mapToolResultToToolResultBlockParam(result, toolUseId) {
+        if (result.contents.length === 0) {
+          return {
+            type: "tool_result",
+            tool_use_id: toolUseId,
+            content: "Resource returned no content."
+          };
+        }
+        const parts = [];
+        for (const c of result.contents) {
+          if (c.text) {
+            parts.push(c.text);
+          } else if (c.blob) {
+            parts.push(`[base64 blob, ${c.blob.length} chars]${c.mimeType ? ` (${c.mimeType})` : ""}`);
+          } else {
+            parts.push(`[empty content for ${c.uri}]`);
+          }
+        }
+        return {
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          content: parts.join("\n\n")
+        };
+      }
+    };
+    READ_MCP_RESOURCE_PROMPT = `Read a resource from a connected MCP server.
+- Requires server_name (the MCP server name) and uri (the resource URI)
+- Use ListMcpResourcesTool first to discover available resources
+- Returns text content or base64-encoded binary data`;
+  }
+});
+
 // src/mcp/handlers.ts
 function mcpToolsToHandlers() {
   const mcpTools2 = getMcpTools();
@@ -89115,51 +90564,61 @@ var init_init = __esm({
 });
 
 // src/core/team.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync14, mkdirSync as mkdirSync7 } from "fs";
-import { join as join8 } from "path";
 function createTeam(name, description) {
-  const team = {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  dbRun(
+    `INSERT OR IGNORE INTO teams (name, description, task_list_id, created_at) VALUES (?, ?, ?, ?)`,
+    [name, description ?? null, name, now]
+  );
+  return {
     name,
     description,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdAt: now,
     members: [],
     taskListId: name
   };
-  const teamsDir = getTeamsDir();
-  writeFileSync8(join8(teamsDir, `${name}.json`), JSON.stringify(team, null, 2), "utf-8");
-  const taskDir = join8(getTasksDir(), name);
-  if (!existsSync14(taskDir)) mkdirSync7(taskDir, { recursive: true });
-  return team;
 }
 function getTeam(name) {
-  const path = join8(getTeamsDir(), `${name}.json`);
-  if (!existsSync14(path)) return null;
-  try {
-    return JSON.parse(readFileSync12(path, "utf-8"));
-  } catch {
-    return null;
-  }
+  const row = dbGet(`SELECT * FROM teams WHERE name = ?`, [name]);
+  if (!row) return null;
+  const members = dbAll(
+    `SELECT * FROM team_members WHERE team_name = ?`,
+    [name]
+  );
+  return {
+    name: row.name,
+    description: row.description ?? void 0,
+    createdAt: row.created_at ?? "",
+    taskListId: row.task_list_id ?? row.name,
+    members: members.map((m) => ({
+      name: m.agent_name,
+      agentId: m.agent_name,
+      role: m.role ?? void 0,
+      status: m.status ?? "idle",
+      currentTask: m.current_task ?? void 0
+    }))
+  };
 }
 function addTeamMember(teamName, member) {
-  const team = getTeam(teamName);
-  if (!team) return;
-  team.members = team.members.filter((m) => m.name !== member.name);
-  team.members.push(member);
-  writeFileSync8(join8(getTeamsDir(), `${teamName}.json`), JSON.stringify(team, null, 2), "utf-8");
+  dbRun(
+    `DELETE FROM team_members WHERE team_name = ? AND agent_name = ?`,
+    [teamName, member.name]
+  );
+  dbRun(
+    `INSERT INTO team_members (team_name, agent_name, role, status, current_task) VALUES (?, ?, ?, ?, ?)`,
+    [teamName, member.name, member.role ?? null, member.status, member.currentTask ?? null]
+  );
 }
 function updateMemberStatus(teamName, memberName, status) {
-  const team = getTeam(teamName);
-  if (!team) return;
-  const member = team.members.find((m) => m.name === memberName);
-  if (member) {
-    member.status = status;
-    writeFileSync8(join8(getTeamsDir(), `${teamName}.json`), JSON.stringify(team, null, 2), "utf-8");
-  }
+  dbRun(
+    `UPDATE team_members SET status = ? WHERE team_name = ? AND agent_name = ?`,
+    [status, teamName, memberName]
+  );
 }
 var init_team = __esm({
   "src/core/team.ts"() {
     "use strict";
-    init_paths();
+    init_db();
   }
 });
 
@@ -90163,6 +91622,7 @@ __export(app_exports, {
   launchInkApp: () => launchInkApp,
   runHeadless: () => runHeadless
 });
+import { execSync as execSync4 } from "child_process";
 function useSpinner(active) {
   const [i, setI] = (0, import_react22.useState)(0);
   (0, import_react22.useEffect)(() => {
@@ -90185,6 +91645,8 @@ function createToolHandlers(mcpHandlers) {
     taskGetTool,
     taskListTool,
     taskUpdateTool,
+    taskOutputTool,
+    taskStopTool,
     askUserQuestionTool,
     webSearchTool,
     webFetchTool,
@@ -90199,49 +91661,75 @@ function createToolHandlers(mcpHandlers) {
     exitWorktreeTool,
     notebookEditTool,
     configTool,
-    sendMessageTool
+    sendMessageTool,
+    listMcpResourcesTool,
+    readMcpResourceTool,
+    skillTool
   ];
-  const permCtx = createDefaultPermissionContext();
+  const permCtx = createDefaultPermissionContext(getSettings());
   const appState = { toolPermissionContext: permCtx, verbose: false };
-  const builtinHandlers = tools.map((tool) => ({
-    name: tool.name,
-    description: TOOL_DESCRIPTIONS[tool.name] ?? `Tool: ${tool.name}`,
-    inputSchema: TOOL_JSON_SCHEMAS[tool.name] ?? { type: "object", properties: {} },
-    isReadOnly: tool.isReadOnly(),
-    isConcurrencySafe: tool.isConcurrencySafe(),
-    call: async (input, ctx) => {
-      const summary = toolSummary(tool.name, input);
-      const t0 = performance.now();
-      try {
-        const toolCtx = {
-          abortController: new AbortController(),
-          getAppState: () => appState,
-          setAppState: (fn) => Object.assign(appState, fn(appState)),
-          options: { mainLoopModel: "sonnet", thinkingConfig: { type: "disabled" }, isNonInteractiveSession: false, tools: [], agentDefinitions: { activeAgents: [] } }
-        };
-        const result = await tool.call(input, toolCtx);
-        const block2 = tool.mapToolResultToToolResultBlockParam(result.data, ctx.toolUseId ?? "");
-        const dur = performance.now() - t0;
+  const immediate = [];
+  const all = [];
+  const deferredInfo = [];
+  const deferredSchemas = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const handler = {
+      name: tool.name,
+      description: TOOL_DESCRIPTIONS[tool.name] ?? `Tool: ${tool.name}`,
+      inputSchema: TOOL_JSON_SCHEMAS[tool.name] ?? { type: "object", properties: {} },
+      isReadOnly: tool.isReadOnly(),
+      isConcurrencySafe: tool.isConcurrencySafe(),
+      call: async (input, ctx) => {
+        const summary = toolSummary(tool.name, input);
+        const t0 = performance.now();
         try {
-          dbRun("INSERT INTO audit_log (tool_name, input_summary, result_summary, duration_ms, was_allowed) VALUES (?, ?, ?, ?, 1)", [tool.name, summary, block2.content.slice(0, 200), dur]);
-        } catch {
-        }
-        return block2.is_error ? { data: block2.content, error: block2.content, isError: true } : { data: block2.content };
-      } catch (err) {
-        const dur = performance.now() - t0;
-        const errMsg = err instanceof Error ? err.message : String(err);
-        try {
-          dbRun("INSERT INTO audit_log (tool_name, input_summary, result_summary, duration_ms, was_allowed) VALUES (?, ?, ?, ?, 1)", [tool.name, summary, errMsg.slice(0, 200), dur]);
-        } catch {
+          const toolCtx = {
+            abortController: new AbortController(),
+            getAppState: () => appState,
+            setAppState: (fn) => Object.assign(appState, fn(appState)),
+            options: { mainLoopModel: "sonnet", thinkingConfig: { type: "disabled" }, isNonInteractiveSession: false, tools: [], agentDefinitions: { activeAgents: [] } }
+          };
+          const result = await tool.call(input, toolCtx);
+          const block2 = tool.mapToolResultToToolResultBlockParam(result.data, ctx.toolUseId ?? "");
+          const dur = performance.now() - t0;
+          try {
+            dbRun("INSERT INTO audit_log (tool_name, input_summary, result_summary, duration_ms, was_allowed) VALUES (?, ?, ?, ?, 1)", [tool.name, summary, block2.content.slice(0, 200), dur]);
+          } catch {
+          }
+          return block2.is_error ? { data: block2.content, error: block2.content, isError: true } : { data: block2.content };
+        } catch (err) {
+          const dur = performance.now() - t0;
+          const errMsg = err instanceof Error ? err.message : String(err);
+          try {
+            dbRun("INSERT INTO audit_log (tool_name, input_summary, result_summary, duration_ms, was_allowed) VALUES (?, ?, ?, ?, 1)", [tool.name, summary, errMsg.slice(0, 200), dur]);
+          } catch {
+          }
+          return { error: errMsg, isError: true };
         }
-        return { error: errMsg, isError: true };
       }
+    };
+    all.push(handler);
+    if (tool.shouldDefer) {
+      deferredInfo.push({
+        name: tool.name,
+        description: TOOL_DESCRIPTIONS[tool.name] ?? tool.searchHint
+      });
+      deferredSchemas.set(tool.name, {
+        name: tool.name,
+        description: TOOL_DESCRIPTIONS[tool.name] ?? tool.searchHint,
+        inputSchema: TOOL_JSON_SCHEMAS[tool.name] ?? { type: "object", properties: {} }
+      });
+    } else {
+      immediate.push(handler);
     }
-  }));
+  }
   if (mcpHandlers && mcpHandlers.length > 0) {
-    return [...builtinHandlers, ...mcpHandlers];
+    for (const h of mcpHandlers) {
+      immediate.push(h);
+      all.push(h);
+    }
   }
-  return builtinHandlers;
+  return { immediate, all, deferredInfo, deferredSchemas };
 }
 function shortPath(p) {
   if (!p) return "";
@@ -90304,11 +91792,21 @@ function toolSummary(name, input) {
     case "ExitWorktree":
       return String(input.action ?? "");
     case "NotebookEdit":
-      return shortPath(String(input.notebook_path ?? ""));
+      return `${input.command ?? ""} ${shortPath(String(input.notebook_path ?? ""))}`.trim();
     case "Config":
       return String(input.setting ?? "");
     case "SendMessage":
       return `to:${input.to ?? ""}`;
+    case "TaskOutput":
+      return String(input.task_id ?? "");
+    case "TaskStop":
+      return String(input.task_id ?? "");
+    case "ListMcpResourcesTool":
+      return "";
+    case "ReadMcpResourceTool":
+      return `${input.server_name ?? ""}:${input.uri ?? ""}`.slice(0, 60);
+    case "Skill":
+      return String(input.skill ?? "").slice(0, 50);
     default:
       return "";
   }
@@ -90317,6 +91815,83 @@ function SpinnerDot() {
   const f = useSpinner(true);
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: "cyan", children: f });
 }
+function BackgroundTaskItem({ task }) {
+  const spinner = useSpinner(task.status === "running");
+  const icon = task.status === "running" ? spinner : task.status === "completed" ? "\u2713" : "\u2717";
+  const color = task.status === "running" ? "yellow" : task.status === "completed" ? "green" : "red";
+  const now = Date.now();
+  const durationMs = task.endTime ? task.endTime - task.startTime : now - task.startTime;
+  const durSec = Math.round(durationMs / 1e3);
+  const durStr = durSec < 60 ? `${durSec}s` : `${Math.floor(durSec / 60)}m ${durSec % 60}s`;
+  const desc = task.description.length > 40 ? task.description.slice(0, 37) + "..." : task.description;
+  let detail = `${task.status === "running" ? "running" : task.status}`;
+  detail += ` \xB7 ${durStr}`;
+  if (task.exitCode !== void 0 && task.exitCode !== null && task.status !== "running") {
+    detail += ` \xB7 exit ${task.exitCode}`;
+  }
+  if (task.progress?.tokenCount) {
+    detail += ` \xB7 ${fmtTok(task.progress.tokenCount)} tokens`;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box_default, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, { color, children: [
+      icon,
+      " "
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { bold: true, children: task.id }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, { children: [
+      ": ",
+      desc,
+      " "
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, { dimColor: true, children: [
+      "(",
+      detail,
+      ")"
+    ] })
+  ] });
+}
+function BackgroundTaskList({ tasks: tasks2 }) {
+  if (tasks2.length === 0) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box_default, { flexDirection: "column", children: tasks2.map((t) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BackgroundTaskItem, { task: t }, t.id)) });
+}
+function useCustomStatusLine(config2, context) {
+  const [output, setOutput] = (0, import_react22.useState)(null);
+  const lastRunRef = (0, import_react22.useRef)(0);
+  (0, import_react22.useEffect)(() => {
+    if (!config2 || config2.type !== "command") {
+      setOutput(null);
+      return;
+    }
+    const runCommand = () => {
+      try {
+        const stdinData = JSON.stringify({
+          model: context.model,
+          cost: context.cost,
+          tokens: context.tokens,
+          cwd: process.cwd(),
+          version: VERSION
+        });
+        const result = execSync4(config2.command, {
+          timeout: 3e3,
+          input: stdinData,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        const trimmed = result.trim();
+        if (trimmed) {
+          setOutput(config2.padding ? trimmed.padEnd(config2.padding) : trimmed);
+        }
+      } catch {
+        setOutput(null);
+      }
+      lastRunRef.current = Date.now();
+    };
+    runCommand();
+    const interval = setInterval(runCommand, 2e3);
+    return () => clearInterval(interval);
+  }, [config2?.command, config2?.padding, context.model, context.cost, context.tokens]);
+  return output;
+}
 function ToolItem({ tool }) {
   const f = useSpinner(tool.status === "running");
   const icon = tool.status === "running" ? f : "\u25CF";
@@ -90427,19 +92002,24 @@ function MessageView({ msg }) {
     ] }) })
   ] });
 }
-function StatusBar({ model, mode, cost, tokens, agentName, teamName, classification }) {
+function StatusBar({ model, mode, cost, tokens, agentName, teamName, classification, bgTaskCount, customStatusLine }) {
+  if (customStatusLine) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box_default, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { dimColor: true, children: customStatusLine }) });
+  }
   const teamLabel = agentName && teamName ? ` \xB7 ${agentName}@${teamName}` : "";
   const intentLabel = classification && classification.intent !== "general" ? ` \xB7 [${classification.intent}]` : "";
+  const bgLabel = bgTaskCount && bgTaskCount > 0 ? ` \xB7 ${bgTaskCount} background task${bgTaskCount > 1 ? "s" : ""}` : "";
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box_default, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, { dimColor: true, children: [
     model,
-    " \xB7 ",
+    " \\u00B7 ",
     mode,
-    " \xB7 $",
+    " \\u00B7 $",
     cost.toFixed(4),
-    " \xB7 ",
+    " \\u00B7 ",
     fmtTok(tokens),
     teamLabel,
-    intentLabel
+    intentLabel,
+    bgLabel
   ] }) });
 }
 function App2({ model, mode, dangerouslySkipPermissions, initialPrompt, resumedSession, mcpToolHandlers, agentId, agentName, teamName }) {
@@ -90464,7 +92044,21 @@ function App2({ model, mode, dangerouslySkipPermissions, initialPrompt, resumedS
   const _rows = stdout?.rows ?? 24;
   const [slashSelected, setSlashSelected] = (0, import_react22.useState)(0);
   const [lastClassification, setLastClassification] = (0, import_react22.useState)(null);
+  const [bgTasks, setBgTasks] = (0, import_react22.useState)([]);
   const appSettings = getSettings();
+  const statusLineConfig = appSettings.statusLine;
+  const customStatusLine = useCustomStatusLine(statusLineConfig, { model, cost, tokens });
+  (0, import_react22.useEffect)(() => {
+    const poll = () => {
+      const running = getRunningTasks();
+      const recent = getRecentlyCompletedTasks(5e3);
+      const all = [...running, ...recent];
+      setBgTasks(all);
+    };
+    poll();
+    const interval = setInterval(poll, 1e3);
+    return () => clearInterval(interval);
+  }, []);
   const thinkingConfig = (() => {
     if (appSettings.thinking?.enabled) {
       return appSettings.thinking.budgetTokens ? { type: "enabled", budget_tokens: appSettings.thinking.budgetTokens } : { type: "enabled" };
@@ -90581,6 +92175,42 @@ function App2({ model, mode, dangerouslySkipPermissions, initialPrompt, resumedS
         ]);
         return;
       }
+      if (r.action === "compact") {
+        if (history.length === 0) {
+          setMsgs((p) => [...p, { id: `s${Date.now()}`, role: "system", content: "Nothing to compact \u2014 conversation is empty.", timestamp: Date.now() }]);
+          return;
+        }
+        setMsgs((p) => [...p, { id: `s${Date.now()}`, role: "system", content: "Compacting conversation...", timestamp: Date.now() }]);
+        try {
+          const client = getApiClient();
+          const customInstructions = r.data;
+          const summaryPrompt = customInstructions ? `Summarize the conversation so far in 2-3 concise sentences, focusing on: ${customInstructions}. Include key decisions, files changed, and current state.` : "Summarize the conversation so far in 2-3 concise sentences. Include key decisions, files changed, and current state of the work.";
+          const summaryResponse = await client.createMessage({
+            model,
+            messages: [
+              ...history,
+              { role: "user", content: summaryPrompt }
+            ],
+            maxTokens: 1024
+          });
+          const summaryText = summaryResponse.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim() || "Conversation compacted.";
+          const summarySystemMsg = {
+            id: `compact${Date.now()}`,
+            role: "system",
+            content: `[Compacted conversation summary]
+${summaryText}`,
+            timestamp: Date.now()
+          };
+          setMsgs([summarySystemMsg]);
+          setHistory([
+            { role: "user", content: "Here is a summary of our conversation so far:\n" + summaryText },
+            { role: "assistant", content: "Understood. I have the context from our previous conversation. How can I help you continue?" }
+          ]);
+        } catch (e) {
+          setMsgs((p) => [...p, { id: `e${Date.now()}`, role: "system", content: `Failed to compact: ${e instanceof Error ? e.message : String(e)}`, timestamp: Date.now() }]);
+        }
+        return;
+      }
       if (r.output) setMsgs((p) => [...p, { id: `s${Date.now()}`, role: "system", content: r.output, timestamp: Date.now() }]);
       if (r.action === "exit") exit();
       if (r.action === "clear") {
@@ -90610,48 +92240,22 @@ function App2({ model, mode, dangerouslySkipPermissions, initialPrompt, resumedS
     }
     const t0 = performance.now();
     try {
-      const allToolHandlers = createToolHandlers(mcpToolHandlers);
-      const permCtx = createDefaultPermissionContext();
+      const toolSplit = createToolHandlers(mcpToolHandlers);
+      const permCtx = createDefaultPermissionContext(getSettings());
       const toolStartTimes = /* @__PURE__ */ new Map();
+      setDeferredToolSchemas([...toolSplit.deferredSchemas.values()]);
       const classification = classifyPrompt(text);
       setLastClassification(classification);
-      const builtinToolNames = /* @__PURE__ */ new Set([
-        "Bash",
-        "Read",
-        "Edit",
-        "Write",
-        "Glob",
-        "Grep",
-        "Agent",
-        "TaskCreate",
-        "TaskGet",
-        "TaskList",
-        "TaskUpdate",
-        "AskUserQuestion",
-        "WebSearch",
-        "WebFetch",
-        "LSP",
-        "EnterPlanMode",
-        "ExitPlanMode",
-        "ToolSearch",
-        "CronCreate",
-        "CronDelete",
-        "CronList",
-        "EnterWorktree",
-        "ExitWorktree",
-        "NotebookEdit",
-        "Config",
-        "SendMessage"
-      ]);
-      const toolHandlers = filterToolsByClassification(allToolHandlers, classification, builtinToolNames);
+      const allBuiltinToolNames = new Set(toolSplit.all.map((h) => h.name));
+      const toolHandlers = filterToolsByClassification(toolSplit.all, classification, allBuiltinToolNames);
       try {
         dbRun(
           "INSERT INTO audit_log (tool_name, input_summary, result_summary, duration_ms, was_allowed) VALUES (?, ?, ?, ?, 1)",
-          ["__classifier", text.slice(0, 200), `${classification.intent}: ${classification.reason} (${toolHandlers.length}/${allToolHandlers.length} tools)`, 0]
+          ["__classifier", text.slice(0, 200), `${classification.intent}: ${classification.reason} (${toolHandlers.length}/${toolSplit.all.length} tools, ${toolSplit.deferredInfo.length} deferred)`, 0]
         );
       } catch {
       }
-      const builtinTools = [
+      const immediateBuiltinTools = [
         bashTool,
         readTool,
         editTool,
@@ -90659,28 +92263,11 @@ function App2({ model, mode, dangerouslySkipPermissions, initialPrompt, resumedS
         globTool,
         grepTool,
         agentTool,
-        taskCreateTool,
-        taskGetTool,
-        taskListTool,
-        taskUpdateTool,
-        askUserQuestionTool,
-        webSearchTool,
-        webFetchTool,
-        lspTool,
-        enterPlanModeTool,
-        exitPlanModeTool,
         toolSearchTool,
-        cronCreateTool,
-        cronDeleteTool,
-        cronListTool,
-        enterWorktreeTool,
-        exitWorktreeTool,
-        notebookEditTool,
-        configTool,
-        sendMessageTool
-      ];
+        skillTool
+      ].filter((t) => !t.shouldDefer);
       const toolPrompts = await Promise.all(
-        builtinTools.map(async (t) => ({ name: t.name, prompt: await t.prompt() }))
+        immediateBuiltinTools.map(async (t) => ({ name: t.name, prompt: await t.prompt() }))
       );
       const turnAbort = new AbortController();
       abortRef.current = turnAbort;
@@ -90693,7 +92280,8 @@ function App2({ model, mode, dangerouslySkipPermissions, initialPrompt, resumedS
             projectDir: process.cwd(),
             model,
             permissionMode: mode,
-            tools: toolPrompts
+            tools: toolPrompts,
+            deferredTools: toolSplit.deferredInfo
           }),
           tools: toolHandlers,
           model,
@@ -90709,7 +92297,7 @@ function App2({ model, mode, dangerouslySkipPermissions, initialPrompt, resumedS
               }
             } catch {
             }
-            if (dangerouslySkipPermissions) {
+            if (dangerouslySkipPermissions || permCtx.mode === "bypassPermissions") {
               return { behavior: "allow" };
             }
             const ruleResult = checkToolPermission(toolName, toolInput, permCtx);
@@ -90956,6 +92544,7 @@ function App2({ model, mode, dangerouslySkipPermissions, initialPrompt, resumedS
           /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { dimColor: true, children: "]lways" })
         ] })
       ] }),
+      bgTasks.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BackgroundTaskList, { tasks: bgTasks }),
       /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box_default, { flexDirection: "column", children: [
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { dimColor: true, children: sep }),
         /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box_default, { children: [
@@ -90987,7 +92576,7 @@ function App2({ model, mode, dangerouslySkipPermissions, initialPrompt, resumedS
           ] })
         ] }, cmd.name)) }),
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { dimColor: true, children: sep }),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(StatusBar, { model, mode, cost, tokens, agentName: agentName ?? agentId, teamName, classification: lastClassification })
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(StatusBar, { model, mode, cost, tokens, agentName: agentName ?? agentId, teamName, classification: lastClassification, bgTaskCount: bgTasks.filter((t) => t.status === "running").length, customStatusLine })
       ] })
     ] })
   ] });
@@ -91110,6 +92699,7 @@ var init_app = __esm({
     init_agent_loop();
     init_permissions();
     init_db();
+    init_background_tasks();
     init_session();
     init_system_prompt();
     init_bash();
@@ -91120,17 +92710,21 @@ var init_app = __esm({
     init_grep();
     init_agent();
     init_tasks();
+    init_task_output();
     init_ask_user();
     init_web_search();
     init_web_fetch();
     init_lsp();
     init_plan_mode();
     init_misc();
+    init_mcp_resources();
     init_registry();
     init_init();
     init_client4();
     init_team();
     init_classifier();
+    init_skill();
+    init_registry2();
     import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
     CONN = "\u23BF";
     PROMPT = "\u276F";
@@ -91366,10 +92960,13 @@ var init_app = __esm({
         type: "object",
         properties: {
           notebook_path: { type: "string", description: "Path to the .ipynb file" },
-          cell_index: { type: "number", description: "Cell index to edit" },
-          new_source: { type: "string", description: "New cell source code" }
+          command: { type: "string", enum: ["insert_cell", "replace_cell", "delete_cell", "move_cell", "change_cell_type"], description: "Operation to perform on the notebook" },
+          cell_index: { type: "number", description: "Cell index to operate on (0-based). For insert_cell, position to insert at (omit to append)." },
+          cell_type: { type: "string", enum: ["code", "markdown", "raw"], description: "Cell type \u2014 required for insert_cell and change_cell_type" },
+          new_source: { type: "string", description: "New cell content \u2014 required for insert_cell and replace_cell" },
+          target_index: { type: "number", description: "Destination index for move_cell" }
         },
-        required: ["notebook_path", "cell_index", "new_source"]
+        required: ["notebook_path", "command"]
       },
       Config: {
         type: "object",
@@ -91386,6 +92983,40 @@ var init_app = __esm({
           message: { type: "string", description: "Message content" }
         },
         required: ["to", "message"]
+      },
+      TaskOutput: {
+        type: "object",
+        properties: {
+          task_id: { type: "string", description: "The ID of the background task to check (e.g. 'bg-1', 'agent-2')" }
+        },
+        required: ["task_id"]
+      },
+      TaskStop: {
+        type: "object",
+        properties: {
+          task_id: { type: "string", description: "The ID of the background task to stop (e.g. 'bg-1', 'agent-2')" }
+        },
+        required: ["task_id"]
+      },
+      ListMcpResourcesTool: {
+        type: "object",
+        properties: {}
+      },
+      ReadMcpResourceTool: {
+        type: "object",
+        properties: {
+          server_name: { type: "string", description: "The name of the MCP server that owns the resource" },
+          uri: { type: "string", description: "The URI of the resource to read" }
+        },
+        required: ["server_name", "uri"]
+      },
+      Skill: {
+        type: "object",
+        properties: {
+          skill: { type: "string", description: "The skill name to invoke (e.g. 'commit', 'review-pr')" },
+          args: { type: "string", description: "Optional arguments to pass to the skill prompt" }
+        },
+        required: ["skill"]
       }
     };
     TOOL_DESCRIPTIONS = {
@@ -91412,9 +93043,14 @@ var init_app = __esm({
       CronList: "List all active scheduled cron jobs.",
       EnterWorktree: "Create an isolated git worktree and switch into it.",
       ExitWorktree: "Exit a worktree session, keeping or removing the worktree.",
-      NotebookEdit: "Edit a specific cell in a Jupyter notebook (.ipynb file).",
+      NotebookEdit: "Edit Jupyter notebook cells \u2014 insert, replace, delete, move cells, or change cell type. Preserves all metadata and outputs.",
       Config: "Get or set a configuration setting.",
-      SendMessage: "Send a direct message to another agent or to the user."
+      SendMessage: "Send a direct message to another agent or to the user.",
+      TaskOutput: "Check the status and output of a background task (bash or agent).",
+      TaskStop: "Stop a running background task by its ID.",
+      ListMcpResourcesTool: "List all resources available from connected MCP servers.",
+      ReadMcpResourceTool: "Read a resource from a connected MCP server by server name and URI.",
+      Skill: "Execute a skill within the main conversation. Skills are user-defined prompts in .coders/skills/ or .claude/skills/ directories."
     };
   }
 });
@@ -92233,16 +93869,16 @@ __export(marketplace_exports, {
   removeMarketplace: () => removeMarketplace,
   uninstallPlugin: () => uninstallPlugin
 });
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, existsSync as existsSync15, mkdirSync as mkdirSync8, cpSync, rmSync } from "fs";
-import { join as join9, resolve as resolve7 } from "path";
-import { execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, existsSync as existsSync17, mkdirSync as mkdirSync8, cpSync, rmSync } from "fs";
+import { join as join11, resolve as resolve7 } from "path";
+import { execSync as execSync5 } from "child_process";
 import { tmpdir } from "os";
 import { randomBytes } from "crypto";
 function getMarketplaces() {
   const path = getMarketplacesConfigPath();
-  if (!existsSync15(path)) return [];
+  if (!existsSync17(path)) return [];
   try {
-    return JSON.parse(readFileSync13(path, "utf-8"));
+    return JSON.parse(readFileSync14(path, "utf-8"));
   } catch {
     return [];
   }
@@ -92262,8 +93898,8 @@ function removeMarketplace(name) {
 }
 function saveMarketplaces(marketplaces) {
   const path = getMarketplacesConfigPath();
-  const dir = join9(path, "..");
-  if (!existsSync15(dir)) mkdirSync8(dir, { recursive: true });
+  const dir = join11(path, "..");
+  if (!existsSync17(dir)) mkdirSync8(dir, { recursive: true });
   writeFileSync9(path, JSON.stringify(marketplaces, null, 2) + "\n", "utf-8");
 }
 async function installFromMarketplace(pluginName, marketplaceName) {
@@ -92287,7 +93923,7 @@ async function installPluginFromMarketplace(name, marketplace) {
       return installFromGit(gitUrl, pluginsDir);
     }
     case "directory": {
-      const sourcePath = join9(marketplace.source, name);
+      const sourcePath = join11(marketplace.source, name);
       return installFromDirectory(sourcePath, pluginsDir);
     }
     case "url":
@@ -92306,10 +93942,10 @@ function installFromSource(source, pluginsDir) {
 }
 function installFromGit(url2, pluginsDir) {
   const dir = pluginsDir ?? getPluginsDir();
-  const tempDir = join9(tmpdir(), `coders-plugin-${randomBytes(8).toString("hex")}`);
+  const tempDir = join11(tmpdir(), `coders-plugin-${randomBytes(8).toString("hex")}`);
   try {
     try {
-      execSync3(`git clone --depth 1 ${escapeShellArg(url2)} ${escapeShellArg(tempDir)}`, {
+      execSync5(`git clone --depth 1 ${escapeShellArg(url2)} ${escapeShellArg(tempDir)}`, {
         encoding: "utf-8",
         stdio: "pipe",
         timeout: 6e4
@@ -92320,21 +93956,21 @@ function installFromGit(url2, pluginsDir) {
         error: `Failed to clone "${url2}": ${err instanceof Error ? err.message : String(err)}`
       };
     }
-    const manifestPath = join9(tempDir, "manifest.json");
-    if (!existsSync15(manifestPath)) {
+    const manifestPath = join11(tempDir, "manifest.json");
+    if (!existsSync17(manifestPath)) {
       return { success: false, error: `No manifest.json found in cloned repository "${url2}"` };
     }
     const validated = validateManifest(manifestPath);
     if (!validated.success) return validated;
     const pluginName = validated.pluginName;
-    const targetDir = join9(dir, pluginName);
-    if (existsSync15(targetDir)) {
+    const targetDir = join11(dir, pluginName);
+    if (existsSync17(targetDir)) {
       return { success: false, error: `Plugin "${pluginName}" is already installed` };
     }
     mkdirSync8(targetDir, { recursive: true });
     cpSync(tempDir, targetDir, {
       recursive: true,
-      filter: (src) => !src.includes(join9(tempDir, ".git"))
+      filter: (src) => !src.includes(join11(tempDir, ".git"))
     });
     return {
       success: true,
@@ -92352,18 +93988,18 @@ function installFromGit(url2, pluginsDir) {
 function installFromDirectory(sourcePath, pluginsDir) {
   const dir = pluginsDir ?? getPluginsDir();
   const resolvedSource = resolve7(sourcePath);
-  if (!existsSync15(resolvedSource)) {
+  if (!existsSync17(resolvedSource)) {
     return { success: false, error: `Source directory does not exist: "${resolvedSource}"` };
   }
-  const manifestPath = join9(resolvedSource, "manifest.json");
-  if (!existsSync15(manifestPath)) {
+  const manifestPath = join11(resolvedSource, "manifest.json");
+  if (!existsSync17(manifestPath)) {
     return { success: false, error: `No manifest.json found in "${resolvedSource}"` };
   }
   const validated = validateManifest(manifestPath);
   if (!validated.success) return validated;
   const pluginName = validated.pluginName;
-  const targetDir = join9(dir, pluginName);
-  if (existsSync15(targetDir)) {
+  const targetDir = join11(dir, pluginName);
+  if (existsSync17(targetDir)) {
     return { success: false, error: `Plugin "${pluginName}" is already installed` };
   }
   mkdirSync8(targetDir, { recursive: true });
@@ -92377,8 +94013,8 @@ function installFromDirectory(sourcePath, pluginsDir) {
 }
 function uninstallPlugin(name, pluginsDir) {
   const dir = pluginsDir ?? getPluginsDir();
-  const targetDir = join9(dir, name);
-  if (!existsSync15(targetDir)) return false;
+  const targetDir = join11(dir, name);
+  if (!existsSync17(targetDir)) return false;
   rmSync(targetDir, { recursive: true, force: true });
   return true;
 }
@@ -92387,7 +94023,7 @@ function isGitUrl(source) {
 }
 function validateManifest(manifestPath) {
   try {
-    const raw = JSON.parse(readFileSync13(manifestPath, "utf-8"));
+    const raw = JSON.parse(readFileSync14(manifestPath, "utf-8"));
     const result = PluginManifestSchema.safeParse(raw);
     if (!result.success) {
       const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
@@ -92421,8 +94057,8 @@ var main_exports = {};
 __export(main_exports, {
   main: () => main
 });
-import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync16 } from "fs";
+import { execSync as execSync6 } from "child_process";
+import { existsSync as existsSync18 } from "fs";
 function helpConfig() {
   return {
     sortSubcommands: true,
@@ -92856,15 +94492,15 @@ ${installed.length} plugin(s) installed`);
     }
   });
   plugin.command("install <plugin>").alias("i").description("Install a plugin from a marketplace or local path").option("-s, --scope <scope>", "Installation scope", "user").option("-m, --marketplace <name>", "Marketplace to install from").action(async (source, options2) => {
-    const { resolve: resolve8, join: join10 } = await import("path");
+    const { resolve: resolve8, join: join12 } = await import("path");
     const { existsSync: pathExists } = await import("fs");
     const resolvedPath = resolve8(source);
-    const isLocalDir = pathExists(resolvedPath) && pathExists(join10(resolvedPath, "manifest.json"));
+    const isLocalDir = pathExists(resolvedPath) && pathExists(join12(resolvedPath, "manifest.json"));
     if (isLocalDir) {
       try {
-        const { readFileSync: readFileSync14, cpSync: cpSync2, mkdirSync: mkdirSync9 } = await import("fs");
+        const { readFileSync: readFileSync15, cpSync: cpSync2, mkdirSync: mkdirSync9 } = await import("fs");
         const { PluginManifestSchema: PluginManifestSchema2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
-        const manifestRaw = JSON.parse(readFileSync14(join10(resolvedPath, "manifest.json"), "utf-8"));
+        const manifestRaw = JSON.parse(readFileSync15(join12(resolvedPath, "manifest.json"), "utf-8"));
         const result = PluginManifestSchema2.safeParse(manifestRaw);
         if (!result.success) {
           console.error("Error: Invalid plugin manifest:");
@@ -92875,7 +94511,7 @@ ${installed.length} plugin(s) installed`);
         }
         const pluginName = result.data.name;
         const pluginsDir = getPluginsDir();
-        const targetDir = join10(pluginsDir, pluginName);
+        const targetDir = join12(pluginsDir, pluginName);
         if (pathExists(targetDir)) {
           console.error(`Error: Plugin "${pluginName}" is already installed.`);
           console.error("Uninstall it first: coders plugin uninstall " + pluginName);
@@ -92922,13 +94558,13 @@ ${installed.length} plugin(s) installed`);
   });
   plugin.command("validate <path>").description("Validate a plugin manifest").option("--json", "Output validation result as JSON").action(async (manifestPath, options2) => {
     try {
-      const { existsSync: pathExists, readFileSync: readFileSync14 } = await import("fs");
-      const { resolve: resolve8, join: join10 } = await import("path");
+      const { existsSync: pathExists, readFileSync: readFileSync15 } = await import("fs");
+      const { resolve: resolve8, join: join12 } = await import("path");
       const { PluginManifestSchema: PluginManifestSchema2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
       const resolvedPath = resolve8(manifestPath);
       let filePath;
-      if (pathExists(join10(resolvedPath, "manifest.json"))) {
-        filePath = join10(resolvedPath, "manifest.json");
+      if (pathExists(join12(resolvedPath, "manifest.json"))) {
+        filePath = join12(resolvedPath, "manifest.json");
       } else if (pathExists(resolvedPath)) {
         filePath = resolvedPath;
       } else {
@@ -92938,7 +94574,7 @@ ${installed.length} plugin(s) installed`);
       }
       let raw;
       try {
-        raw = JSON.parse(readFileSync14(filePath, "utf-8"));
+        raw = JSON.parse(readFileSync15(filePath, "utf-8"));
       } catch {
         console.error(`Error: Could not parse JSON from ${filePath}`);
         process.exit(1);
@@ -93035,8 +94671,8 @@ ${installed.length} plugin(s) installed`);
     try {
       const userSettingsPath = getUserSettingsPath();
       const projectSettingsPath = getProjectSettingsPath(process.cwd());
-      const userExists = existsSync16(userSettingsPath);
-      const projectExists = existsSync16(projectSettingsPath);
+      const userExists = existsSync18(userSettingsPath);
+      const projectExists = existsSync18(projectSettingsPath);
       const parts = [];
       if (userExists) parts.push("user");
       if (projectExists) parts.push("project");
@@ -93067,7 +94703,7 @@ ${installed.length} plugin(s) installed`);
       issues++;
     }
     try {
-      const gitVersion = execSync4("git --version", { encoding: "utf-8", timeout: 5e3 }).trim();
+      const gitVersion = execSync6("git --version", { encoding: "utf-8", timeout: 5e3 }).trim();
       console.log(`  ${ok} Git: ${gitVersion.replace("git version ", "")}`);
     } catch {
       console.log(`  ${fail} Git: not found in PATH`);
@@ -93075,7 +94711,7 @@ ${installed.length} plugin(s) installed`);
     }
     try {
       const pluginsDir = getPluginsDir();
-      const dirExists = existsSync16(pluginsDir);
+      const dirExists = existsSync18(pluginsDir);
       if (dirExists) {
         const discovered = discoverPlugins();
         if (discovered.length > 0) {
@@ -93094,7 +94730,7 @@ ${installed.length} plugin(s) installed`);
       issues++;
     }
     try {
-      const rgVersion = execSync4("rg --version", { encoding: "utf-8", timeout: 5e3 }).split("\n")[0].trim();
+      const rgVersion = execSync6("rg --version", { encoding: "utf-8", timeout: 5e3 }).split("\n")[0].trim();
       console.log(`  ${ok} Ripgrep: ${rgVersion.replace("ripgrep ", "")}`);
     } catch {
       console.log(`  ${fail} Ripgrep: not found in PATH (needed for Grep tool)`);
@@ -93113,7 +94749,7 @@ ${installed.length} plugin(s) installed`);
     console.log("Checking for updates...\n");
     let latestVersion;
     try {
-      latestVersion = execSync4(`npm view ${PACKAGE_NAME} version`, {
+      latestVersion = execSync6(`npm view ${PACKAGE_NAME} version`, {
         encoding: "utf-8",
         timeout: 15e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -93157,7 +94793,7 @@ ${installed.length} plugin(s) installed`);
     }
     let installCmd;
     try {
-      execSync4("bun --version", { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] });
+      execSync6("bun --version", { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] });
       installCmd = `bun install -g ${PACKAGE_NAME}@latest`;
     } catch {
       installCmd = `npm install -g ${PACKAGE_NAME}@latest`;
@@ -93165,7 +94801,7 @@ ${installed.length} plugin(s) installed`);
     console.log(`Running: ${installCmd}
 `);
     try {
-      execSync4(installCmd, { encoding: "utf-8", timeout: 12e4, stdio: "inherit" });
+      execSync6(installCmd, { encoding: "utf-8", timeout: 12e4, stdio: "inherit" });
       console.log(`
 Successfully updated to v${latestVersion}.`);
     } catch (err) {
@@ -93433,7 +95069,7 @@ var VERSION, BUILD_TIME, PACKAGE_NAME, ISSUES_URL, startupTimestamps, originalCw
 var init_index = __esm({
   "src/cli/index.ts"() {
     VERSION = "0.1.2";
-    BUILD_TIME = "2026-03-20T18:42:45.981Z";
+    BUILD_TIME = "2026-03-21T05:56:28.429Z";
     PACKAGE_NAME = "@hasna/coders";
     ISSUES_URL = "https://github.com/hasnaxyz/open-coders/issues";
     startupTimestamps = {};