@aurora-foundation/obsidian-next 0.4.7 → 0.4.9

package/dist/chunk-YG7YSNNU.js

@@ -0,0 +1,4226 @@
+import {
+  scheduler
+} from "./chunk-XOMN4VJS.js";
+import {
+  auditLog,
+  redactor
+} from "./chunk-5SWSM5VM.js";
+import {
+  context
+} from "./chunk-MSDU36RT.js";
+import {
+  activateApp,
+  calculateScaleForAPI,
+  clickElementByLabel,
+  computer,
+  findClickableByLabel,
+  getButtons,
+  getDisplayDimensions,
+  getFocusedApp,
+  getToolConfig,
+  getUIContext,
+  takeScreenshotForAPI
+} from "./chunk-MTJI7ZQR.js";
+import {
+  config
+} from "./chunk-7MMY74WO.js";
+import {
+  settings
+} from "./chunk-7RCNGBCH.js";
+import {
+  detectEnvFile,
+  keyManager
+} from "./chunk-57D77KRX.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+import {
+  db
+} from "./chunk-FNLWB54Z.js";
+
+// src/core/history.ts
+var HistoryManager = class {
+  saveTimer = null;
+  constructor() {
+  }
+  async load() {
+    const currentSessionId = context.get().session_id;
+    if (!currentSessionId) return [];
+    try {
+      const rows = db.getDb().prepare(`
+                SELECT content FROM events 
+                WHERE session_id = ? 
+                ORDER BY timestamp ASC
+            `).all(currentSessionId);
+      return rows.map((r) => JSON.parse(r.content));
+    } catch (e) {
+      console.error("Failed to load history:", e);
+      return [];
+    }
+  }
+  async save(events) {
+    if (this.saveTimer) clearTimeout(this.saveTimer);
+    this.saveTimer = setTimeout(async () => {
+      const currentSessionId = context.get().session_id;
+      if (!currentSessionId) return;
+      try {
+        const transaction = db.getDb().transaction(() => {
+          db.getDb().prepare("DELETE FROM events WHERE session_id = ?").run(currentSessionId);
+          const insert = db.getDb().prepare(`
+                        INSERT INTO events (session_id, type, content, timestamp)
+                        VALUES (?, ?, ?, ?)
+                    `);
+          for (const event of events) {
+            insert.run(
+              currentSessionId,
+              event.type,
+              JSON.stringify(event),
+              event.timestamp || Date.now()
+            );
+          }
+        });
+        transaction();
+      } catch (error) {
+        console.error("Failed to save history:", error);
+      }
+    }, 500);
+  }
+  async archive(events) {
+    return null;
+  }
+  async clear() {
+    if (this.saveTimer) clearTimeout(this.saveTimer);
+    const currentSessionId = context.get().session_id;
+    if (!currentSessionId) return;
+    try {
+      db.getDb().prepare("DELETE FROM events WHERE session_id = ?").run(currentSessionId);
+    } catch {
+    }
+  }
+};
+var history = new HistoryManager();
+
+// src/core/tasks.ts
+var TaskTracker = class {
+  task = null;
+  constructor() {
+  }
+  async init() {
+    await this.load();
+  }
+  async load() {
+    try {
+      const currentSessionId = context.get().session_id;
+      if (!currentSessionId) {
+        this.task = null;
+        return;
+      }
+      const row = db.getDb().prepare(`
+                SELECT * FROM tasks 
+                WHERE session_id = ? 
+                AND status != 'done' -- Only load active task? Or the most recent one?
+                ORDER BY created_at DESC 
+                LIMIT 1
+            `).get(currentSessionId);
+      if (row) {
+        const subtasks = db.getDb().prepare(`
+                    SELECT text, done FROM subtasks 
+                    WHERE task_id = ? 
+                    ORDER BY position ASC
+                `).all(row.id);
+        this.task = {
+          id: row.id,
+          title: row.title,
+          status: row.status,
+          subtasks: subtasks.map((s) => ({ text: s.text, done: s.done === 1 })),
+          context: row.context ? JSON.parse(row.context) : [],
+          created_at: new Date(row.created_at).toISOString(),
+          updated_at: new Date(row.updated_at).toISOString()
+        };
+      } else {
+        this.task = null;
+      }
+    } catch (e) {
+      console.error("Failed to load task:", e);
+      this.task = null;
+    }
+    bus.emitAgent({ type: "task_update", task: this.task });
+  }
+  async save() {
+    if (!this.task) return;
+    try {
+      const currentSessionId = context.get().session_id;
+      const updateSubtasks = db.getDb().transaction(() => {
+        db.getDb().prepare(`
+                    INSERT INTO tasks (id, session_id, title, status, context, created_at, updated_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(id) DO UPDATE SET 
+                    status = excluded.status,
+                    context = excluded.context,
+                    updated_at = excluded.updated_at
+                `).run(
+          this.task.id,
+          currentSessionId,
+          this.task.title,
+          this.task.status,
+          JSON.stringify(this.task.context),
+          new Date(this.task.created_at).getTime(),
+          new Date(this.task.updated_at).getTime()
+        );
+        db.getDb().prepare("DELETE FROM subtasks WHERE task_id = ?").run(this.task.id);
+        const stmt = db.getDb().prepare("INSERT INTO subtasks (id, task_id, text, done, position) VALUES (?, ?, ?, ?, ?)");
+        this.task.subtasks.forEach((st, idx) => {
+          stmt.run(
+            this.task.id + "_" + idx,
+            // Simple deterministic ID
+            this.task.id,
+            st.text,
+            st.done ? 1 : 0,
+            idx
+          );
+        });
+      });
+      updateSubtasks();
+      bus.emitAgent({ type: "task_update", task: this.task });
+    } catch (e) {
+      console.error("Failed to save task:", e);
+    }
+  }
+  async archive() {
+  }
+  // Task management
+  async create(title) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.task = {
+      id: Date.now().toString(36),
+      // Use simple ID, or UUID?
+      title,
+      status: "in_progress",
+      subtasks: [],
+      context: [],
+      created_at: now,
+      updated_at: now
+    };
+    await this.save();
+    return this.task;
+  }
+  async addSubtask(text) {
+    if (!this.task) return;
+    this.task.subtasks.push({ text, done: false });
+    this.task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save();
+  }
+  async completeSubtask(index) {
+    if (!this.task || index >= this.task.subtasks.length) return;
+    this.task.subtasks[index].done = true;
+    this.task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save();
+  }
+  async setStatus(status) {
+    if (!this.task) return;
+    this.task.status = status;
+    this.task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save();
+  }
+  async addContext(ctx) {
+    if (!this.task) return;
+    if (!this.task.context.includes(ctx)) {
+      this.task.context.push(ctx);
+      await this.save();
+    }
+  }
+  async complete() {
+    if (!this.task) return;
+    this.task.status = "done";
+    for (const st of this.task.subtasks) {
+      st.done = true;
+    }
+    await this.save();
+  }
+  async clear() {
+    this.task = null;
+    bus.emitAgent({ type: "task_update", task: null });
+  }
+  // Getters
+  get() {
+    return this.task ? { ...this.task } : null;
+  }
+  getProgress() {
+    if (!this.task) return "No active task";
+    const done = this.task.subtasks.filter((s) => s.done).length;
+    const total = this.task.subtasks.length;
+    return `${this.task.title} [${done}/${total}]`;
+  }
+  hasActiveTask() {
+    return this.task !== null && this.task.status !== "done";
+  }
+};
+var tasks = new TaskTracker();
+
+// src/core/usage.ts
+import { z } from "zod";
+var UsageSchema = z.object({
+  totalSessions: z.number().default(0),
+  totalRequests: z.number().default(0),
+  totalInputTokens: z.number().default(0),
+  totalOutputTokens: z.number().default(0),
+  totalCacheReadTokens: z.number().default(0),
+  totalCacheCreationTokens: z.number().default(0),
+  totalCost: z.number().default(0)
+});
+var MODEL_PRICES = {
+  // Claude 4.5 Family (2025-2026)
+  "claude-sonnet-4-5-20250929": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-haiku-4-5-20251001": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-opus-4-5-20251101": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  // Claude 3.5 Family
+  "claude-3-5-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-3-5-haiku": { input: 0.25, output: 1.25, cacheRead: 0.03, cacheWrite: 0.3 },
+  "claude-3-haiku": { input: 0.25, output: 1.25, cacheRead: 0.03, cacheWrite: 0.3 },
+  "claude-3-opus": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-3-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }
+};
+var CONTEXT_WINDOW_SIZES = {
+  "claude-sonnet-4-5-20250929": 2e5,
+  "claude-haiku-4-5-20251001": 2e5,
+  "claude-opus-4-5-20251101": 2e5,
+  "claude-3-5-sonnet": 2e5,
+  "claude-3-5-haiku": 2e5
+};
+var UsageTracker = class {
+  // In-memory session stats (for quick access/display)
+  sessionCost = 0;
+  sessionInputTokens = 0;
+  sessionOutputTokens = 0;
+  sessionCacheReadTokens = 0;
+  sessionCacheCreationTokens = 0;
+  sessionDuration = 0;
+  lastContextSize = 0;
+  lastCacheRead = 0;
+  lastCacheCreation = 0;
+  constructor() {
+  }
+  async init() {
+  }
+  async track(model, input, output, cacheRead = 0, cacheCreation = 0, contextSize) {
+    let prices = MODEL_PRICES[model];
+    if (!prices) {
+      const key = Object.keys(MODEL_PRICES).find((k) => model.includes(k));
+      prices = key ? MODEL_PRICES[key] : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    }
+    const costInput = input / 1e6 * prices.input;
+    const costOutput = output / 1e6 * prices.output;
+    const costCacheRead = cacheRead / 1e6 * prices.cacheRead;
+    const costCacheWrite = cacheCreation / 1e6 * prices.cacheWrite;
+    const totalReqCost = costInput + costOutput + costCacheRead + costCacheWrite;
+    try {
+      const currentSessionId = context.get().session_id;
+      db.getDb().prepare(`
+                INSERT INTO usage_stats (session_id, model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, cost, timestamp)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(currentSessionId, model, input, output, cacheRead, cacheCreation, totalReqCost, Date.now());
+    } catch (e) {
+      console.error("Failed to log usage to DB:", e);
+    }
+    this.sessionCost += totalReqCost;
+    this.sessionInputTokens += input;
+    this.sessionOutputTokens += output;
+    this.sessionCacheReadTokens += cacheRead;
+    this.sessionCacheCreationTokens += cacheCreation;
+    this.lastContextSize = contextSize !== void 0 ? contextSize : input + cacheRead;
+    this.lastCacheRead = cacheRead;
+    this.lastCacheCreation = cacheCreation;
+  }
+  getSessionCost() {
+    return this.sessionCost;
+  }
+  getSessionTokens() {
+    return {
+      input: this.sessionInputTokens,
+      output: this.sessionOutputTokens,
+      cacheRead: this.sessionCacheReadTokens,
+      cacheCreation: this.sessionCacheCreationTokens,
+      total: this.sessionInputTokens + this.sessionOutputTokens + this.sessionCacheReadTokens + this.sessionCacheCreationTokens
+    };
+  }
+  addSessionDuration(ms) {
+    this.sessionDuration += ms;
+  }
+  getSessionDuration() {
+    return this.sessionDuration;
+  }
+  getContextUsage(model) {
+    let limit = 2e5;
+    if (CONTEXT_WINDOW_SIZES[model]) {
+      limit = CONTEXT_WINDOW_SIZES[model];
+    } else {
+      const key = Object.keys(CONTEXT_WINDOW_SIZES).find((k) => model.includes(k));
+      if (key) limit = CONTEXT_WINDOW_SIZES[key];
+    }
+    const used = this.lastContextSize;
+    const cached = this.lastCacheRead + this.lastCacheCreation;
+    const remaining = Math.max(0, limit - used);
+    const percentUsed = used / limit * 100;
+    return {
+      used,
+      cached,
+      limit,
+      remaining,
+      percentRemaining: 100 - percentUsed
+    };
+  }
+  async trackSession() {
+  }
+  getStats() {
+    try {
+      const result = db.getDb().prepare(`
+                SELECT
+                    SUM(input_tokens) as totalInputTokens,
+                    SUM(output_tokens) as totalOutputTokens,
+                    COALESCE(SUM(cache_read_tokens), 0) as totalCacheReadTokens,
+                    COALESCE(SUM(cache_creation_tokens), 0) as totalCacheCreationTokens,
+                    SUM(cost) as totalCost,
+                    COUNT(*) as totalRequests,
+                    COUNT(DISTINCT session_id) as totalSessions
+                FROM usage_stats
+            `).get();
+      return {
+        totalSessions: result.totalSessions || 0,
+        totalRequests: result.totalRequests || 0,
+        totalInputTokens: result.totalInputTokens || 0,
+        totalOutputTokens: result.totalOutputTokens || 0,
+        totalCacheReadTokens: result.totalCacheReadTokens || 0,
+        totalCacheCreationTokens: result.totalCacheCreationTokens || 0,
+        totalCost: result.totalCost || 0
+      };
+    } catch (e) {
+      return UsageSchema.parse({});
+    }
+  }
+  /**
+   * Get cache hit rate for current session
+   */
+  getCacheHitRate() {
+    const totalCached = this.sessionCacheReadTokens;
+    const totalInput = this.sessionInputTokens + this.sessionCacheReadTokens + this.sessionCacheCreationTokens;
+    const hitRate = totalInput > 0 ? totalCached / totalInput * 100 : 0;
+    return { hitRate, totalCached, totalInput };
+  }
+  restoreSessionState(stats) {
+    this.sessionCost = stats.cost;
+    this.sessionInputTokens = stats.inputTokens;
+    this.sessionOutputTokens = stats.outputTokens;
+    this.sessionCacheReadTokens = stats.cacheReadTokens;
+    this.sessionCacheCreationTokens = stats.cacheCreationTokens;
+    this.sessionDuration = stats.duration;
+    this.lastContextSize = stats.inputTokens + stats.cacheReadTokens + stats.cacheCreationTokens;
+    this.lastCacheRead = stats.cacheReadTokens;
+  }
+};
+var usage = new UsageTracker();
+
+// src/core/llm.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/core/tools.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import fs5 from "fs/promises";
+import * as fsSync from "fs";
+import path5 from "path";
+import os4 from "os";
+
+// src/core/auditor.ts
+import path from "path";
+import fs from "fs/promises";
+var BLOCKED_PATTERNS = [
+  "rm -rf /",
+  "rm -fr /",
+  ":(){:|:&};:",
+  // Fork bomb
+  "> /dev/sda",
+  // Disk overwrite
+  "mkfs",
+  "dd if=",
+  "chmod -R 777",
+  ":(){ :|:& };:"
+];
+var BLOCKED_REGEX_PATTERNS = [
+  /curl\s+[^\|]+\|\s*(sh|bash)/i,
+  // curl URL | sh/bash
+  /wget\s+[^\|]+\|\s*(sh|bash)/i,
+  // wget URL | sh/bash
+  /curl\s*\|\s*(sh|bash)/i,
+  // curl | sh/bash (direct)
+  /wget\s*\|\s*(sh|bash)/i
+  // wget | sh/bash (direct)
+];
+var APPROVAL_PATTERNS = [
+  { pattern: "rm -rf", reason: "Recursive delete operation" },
+  { pattern: "rm -r", reason: "Recursive delete operation" },
+  { pattern: "git push --force", reason: "Force push to remote" },
+  { pattern: "git reset --hard", reason: "Hard reset (loses changes)" },
+  { pattern: "npm publish", reason: "Publishing to npm registry" },
+  { pattern: "docker rm", reason: "Removing Docker containers" },
+  { pattern: "DROP TABLE", reason: "SQL table deletion" },
+  { pattern: "DROP DATABASE", reason: "SQL database deletion" },
+  { pattern: "truncate", reason: "Truncating data" }
+];
+var Auditor = class {
+  workspaceRoot;
+  constructor(root = process.cwd()) {
+    this.workspaceRoot = path.resolve(root);
+  }
+  setWorkspaceRoot(root) {
+    this.workspaceRoot = path.resolve(root);
+  }
+  async checkCommand(command) {
+    const s = await settings.load();
+    const lowerCommand = command.toLowerCase();
+    if (BLOCKED_PATTERNS.some((p) => command.includes(p))) {
+      return {
+        approved: false,
+        reason: "Detected destructive command pattern",
+        isCritical: true
+      };
+    }
+    if (BLOCKED_REGEX_PATTERNS.some((p) => p.test(command))) {
+      return {
+        approved: false,
+        reason: "Detected dangerous pipe-to-shell pattern",
+        isCritical: true
+      };
+    }
+    if (await settings.isDenied("bash", command)) {
+      return {
+        approved: false,
+        reason: "Command blocked by settings",
+        isCritical: false
+      };
+    }
+    if (s.mode === "safe") {
+      if (await settings.isSessionAuthorized("bash", command)) {
+        return {
+          approved: true,
+          autoApproved: true
+        };
+      }
+    } else {
+      if (await settings.isAllowed("bash", command)) {
+        return {
+          approved: true,
+          autoApproved: true
+        };
+      }
+    }
+    for (const { pattern, reason } of APPROVAL_PATTERNS) {
+      if (lowerCommand.includes(pattern.toLowerCase())) {
+        return {
+          approved: false,
+          requiresApproval: true,
+          reason
+        };
+      }
+    }
+    return { approved: true };
+  }
+  checkPath(filePath) {
+    try {
+      const resolved = path.resolve(this.workspaceRoot, filePath);
+      const relative = path.relative(this.workspaceRoot, resolved);
+      if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        return { approved: false, reason: `Access denied: Path '${filePath}' is outside the workspace.`, isCritical: true };
+      }
+      const parts = relative.split(path.sep);
+      if (parts.some((p) => p.startsWith(".") && p !== ".obsidian" && p !== ".agent" && p !== ".claude")) {
+      }
+      return { approved: true };
+    } catch (error) {
+      return { approved: false, reason: `Invalid path: ${filePath}`, isCritical: false };
+    }
+  }
+  async checkFileEdit(filePath) {
+    const pathCheck = this.checkPath(filePath);
+    if (!pathCheck.approved) return pathCheck;
+    try {
+      await fs.access(filePath);
+      return { approved: true };
+    } catch {
+      return { approved: false, reason: `File not found: ${filePath}`, isCritical: false };
+    }
+  }
+};
+var auditor = new Auditor();
+
+// src/core/sandbox.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import os from "os";
+var execAsync = promisify(exec);
+var DEFAULT_SANDBOX_CONFIG = {
+  mode: "local",
+  allowedDomains: [
+    "*.github.com",
+    "*.npmjs.org",
+    "*.npmjs.com",
+    "api.anthropic.com",
+    "registry.npmjs.org"
+  ],
+  deniedDomains: [],
+  denyRead: [
+    "~/.ssh",
+    "~/.aws",
+    "~/.config/gcloud",
+    "~/.kube",
+    "~/.gnupg"
+  ],
+  allowWrite: [
+    ".",
+    // Current workspace
+    "/tmp"
+  ],
+  denyWrite: [
+    ".env",
+    ".env.*",
+    "*.key",
+    "*.pem",
+    ".git/config"
+  ]
+};
+var SandboxExecutor = class {
+  initialized = false;
+  mode = "local";
+  sandboxManager = null;
+  config = DEFAULT_SANDBOX_CONFIG;
+  /**
+   * Initialize sandbox with configuration
+   */
+  async initialize() {
+    try {
+      const cfg = await config.load();
+      const s = await settings.load();
+      if (cfg.executionMode === "sandbox" || s.security.sandbox) {
+        this.mode = "sandbox";
+      } else {
+        this.mode = "local";
+      }
+      this.config = {
+        ...DEFAULT_SANDBOX_CONFIG,
+        ...cfg.sandbox || {}
+      };
+      if (this.mode !== "sandbox") {
+        this.initialized = true;
+        return true;
+      }
+      try {
+        const { SandboxManager } = await import("@anthropic-ai/sandbox-runtime");
+        const runtimeConfig = {
+          network: {
+            allowedDomains: this.config.allowedDomains,
+            deniedDomains: this.config.deniedDomains
+          },
+          filesystem: {
+            denyRead: this.config.denyRead,
+            allowWrite: this.config.allowWrite,
+            denyWrite: this.config.denyWrite
+          }
+        };
+        await SandboxManager.initialize(runtimeConfig);
+        this.sandboxManager = SandboxManager;
+        this.initialized = true;
+        bus.emitAgent({
+          type: "thought",
+          content: "[SANDBOX] Initialized with OS-level isolation"
+        });
+        return true;
+      } catch (importError) {
+        bus.emitAgent({
+          type: "thought",
+          content: `[SANDBOX] Runtime library unavailable (Error: ${importError.message}). Falling back to native OS sandbox.`
+        });
+        this.sandboxManager = null;
+        this.initialized = true;
+        return true;
+      }
+    } catch (error) {
+      bus.emitAgent({
+        type: "error",
+        message: `Sandbox initialization failed: ${error.message}`
+      });
+      return false;
+    }
+  }
+  /**
+   * Wrap a command with sandbox protection
+   */
+  async wrapCommand(command, bypass = false) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (this.mode === "local" || bypass) {
+      return command;
+    }
+    if (this.sandboxManager) {
+      try {
+        return await this.sandboxManager.wrapWithSandbox(command);
+      } catch (error) {
+      }
+    }
+    return this.wrapWithNativeSandbox(command);
+  }
+  /**
+   * Wrap command with native OS sandbox (macOS sandbox-exec or Linux firejail)
+   */
+  async wrapWithNativeSandbox(command) {
+    const platform = os.platform();
+    const cfg = await config.load();
+    if (platform === "darwin") {
+      const profile = `(version 1)
+(deny default)
+(allow process-exec*)
+(allow process-fork)
+(allow signal)
+(allow syscall-unix)
+(allow sysctl-read)
+(deny file-read* (subpath "${os.homedir()}"))
+(allow file-read* (subpath "${cfg.workspaceRoot}"))
+(allow file-read* (subpath "/tmp"))
+(allow file-read* (subpath "/usr"))
+(allow file-read* (subpath "/bin"))
+(allow file-read* (subpath "/sbin"))
+(allow file-read* (subpath "/lib"))
+(allow file-read* (subpath "/private/var/run"))
+(allow file-read* (subpath "/Library/Preferences"))
+(allow file-read* (subpath "/dev"))
+(allow file-write* (subpath "/tmp"))
+(allow file-write* (subpath "${cfg.workspaceRoot}"))
+(deny file-write* (literal "${cfg.workspaceRoot}/.env"))
+(allow network-outbound (remote tcp "*:80" "*:443"))
+(allow network*)
+(allow mach-lookup*)
+(allow iokit*)
+            `.trim();
+      const profilePath = `/tmp/obsidian-sandbox-${Date.now()}.sb`;
+      const fs6 = await import("fs/promises");
+      await fs6.writeFile(profilePath, profile);
+      const escapedCommand = command.replace(/'/g, "'\\''");
+      return `sandbox-exec -f "${profilePath}" bash -c '${escapedCommand}'`;
+    }
+    if (platform === "linux") {
+      try {
+        await execAsync("which firejail");
+        const escapedCommand = command.replace(/'/g, "'\\''");
+        return `firejail --net=none --blacklist=~/.ssh --blacklist=~/.aws --blacklist=~/.gnupg bash -c '${escapedCommand}'`;
+      } catch {
+      }
+    }
+    return command;
+  }
+  /**
+   * Get current execution mode
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Set execution mode
+   */
+  async setMode(mode) {
+    this.mode = mode;
+    if (mode === "sandbox" && !this.sandboxManager) {
+      await this.initialize();
+    }
+    bus.emitAgent({
+      type: "thought",
+      content: `[sandbox] Execution mode set to: ${mode}`
+    });
+  }
+  /**
+   * Get current sandbox configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update sandbox configuration
+   */
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+  /**
+   * Reset and cleanup sandbox resources
+   */
+  async reset() {
+    if (this.sandboxManager) {
+      try {
+        await this.sandboxManager.reset();
+      } catch {
+      }
+    }
+    this.initialized = false;
+    this.sandboxManager = null;
+  }
+  /**
+   * Check if sandbox mode is available on this system
+   */
+  async isAvailable() {
+    try {
+      await import("@anthropic-ai/sandbox-runtime");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var sandbox = new SandboxExecutor();
+
+// src/core/undo.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+var UndoManager = class {
+  sessionId = null;
+  changes = [];
+  // In-memory stack for fast access
+  async init(sessionId) {
+    this.sessionId = sessionId;
+    this.changes = [];
+  }
+  async recordChange(filePath, operation, beforeContent, afterContent) {
+    const id = `chg_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const cfg = await config.load();
+    const change = {
+      id,
+      filePath: path2.relative(cfg.workspaceRoot, path2.resolve(filePath)),
+      operation,
+      beforeContent,
+      afterContent,
+      timestamp: /* @__PURE__ */ new Date(),
+      undone: false
+    };
+    this.changes.unshift(change);
+    if (this.changes.length > 100) {
+      this.changes = this.changes.slice(0, 100);
+    }
+    return id;
+  }
+  async undo(count = 1) {
+    const toUndo = this.changes.filter((c) => !c.undone).slice(0, count);
+    if (toUndo.length === 0) {
+      return { success: false, message: "Nothing to undo" };
+    }
+    const results = [];
+    const cfg = await config.load();
+    for (const change of toUndo) {
+      try {
+        const fullPath = path2.resolve(cfg.workspaceRoot, change.filePath);
+        switch (change.operation) {
+          case "create":
+            await fs2.unlink(fullPath);
+            results.push(`Deleted: ${change.filePath}`);
+            break;
+          case "edit":
+            if (change.beforeContent !== null) {
+              await fs2.writeFile(fullPath, change.beforeContent, "utf-8");
+              results.push(`Restored: ${change.filePath}`);
+            }
+            break;
+          case "delete":
+            if (change.beforeContent !== null) {
+              await fs2.mkdir(path2.dirname(fullPath), { recursive: true });
+              await fs2.writeFile(fullPath, change.beforeContent, "utf-8");
+              results.push(`Restored: ${change.filePath}`);
+            }
+            break;
+        }
+        change.undone = true;
+      } catch (error) {
+        results.push(`Failed: ${change.filePath} - ${error.message}`);
+      }
+    }
+    return {
+      success: true,
+      message: results.join("\n")
+    };
+  }
+  getHistory(limit = 10) {
+    return this.changes.filter((c) => !c.undone).slice(0, limit);
+  }
+  async close() {
+  }
+};
+var undo = new UndoManager();
+
+// src/core/diff.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import os2 from "os";
+var DIFF_DIR = ".obsidian-next/diffs";
+var MAX_DIFF_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var MAX_DIFFS = 100;
+function generateDiff(oldContent, newContent, filePath) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const hunks = computeHunks(oldLines, newLines);
+  if (hunks.length === 0) {
+    return "";
+  }
+  const header = [
+    `--- a/${filePath}`,
+    `+++ b/${filePath}`
+  ];
+  const diffLines = [...header];
+  for (const hunk of hunks) {
+    const hunkHeader = `@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`;
+    diffLines.push(hunkHeader);
+    diffLines.push(...hunk.lines);
+  }
+  return diffLines.join("\n");
+}
+function computeHunks(oldLines, newLines) {
+  const hunks = [];
+  const lcs = computeLCS(oldLines, newLines);
+  let oldIdx = 0;
+  let newIdx = 0;
+  let lcsIdx = 0;
+  let currentHunk = null;
+  const contextLines = 3;
+  while (oldIdx < oldLines.length || newIdx < newLines.length) {
+    const lcsLine = lcsIdx < lcs.length ? lcs[lcsIdx] : null;
+    const oldMatches = lcsLine !== null && oldIdx < oldLines.length && oldLines[oldIdx] === lcsLine;
+    const newMatches = lcsLine !== null && newIdx < newLines.length && newLines[newIdx] === lcsLine;
+    if (oldMatches && newMatches) {
+      if (currentHunk) {
+        currentHunk.lines.push(` ${oldLines[oldIdx]}`);
+        currentHunk.oldCount++;
+        currentHunk.newCount++;
+        const remainingChanges = hasMoreChanges(oldLines, newLines, lcs, oldIdx + 1, newIdx + 1, lcsIdx + 1);
+        if (!remainingChanges || currentHunk.lines.length > 50) {
+          hunks.push(currentHunk);
+          currentHunk = null;
+        }
+      }
+      oldIdx++;
+      newIdx++;
+      lcsIdx++;
+    } else if (!oldMatches && oldIdx < oldLines.length && (lcsLine === null || oldLines[oldIdx] !== lcsLine)) {
+      if (!currentHunk) {
+        currentHunk = createHunk(oldIdx + 1, newIdx + 1);
+      }
+      currentHunk.lines.push(`-${oldLines[oldIdx]}`);
+      currentHunk.oldCount++;
+      oldIdx++;
+    } else if (!newMatches && newIdx < newLines.length && (lcsLine === null || newLines[newIdx] !== lcsLine)) {
+      if (!currentHunk) {
+        currentHunk = createHunk(oldIdx + 1, newIdx + 1);
+      }
+      currentHunk.lines.push(`+${newLines[newIdx]}`);
+      currentHunk.newCount++;
+      newIdx++;
+    } else {
+      if (oldIdx < oldLines.length) oldIdx++;
+      if (newIdx < newLines.length) newIdx++;
+    }
+  }
+  if (currentHunk && currentHunk.lines.length > 0) {
+    hunks.push(currentHunk);
+  }
+  return hunks;
+}
+function createHunk(oldStart, newStart) {
+  return {
+    oldStart,
+    oldCount: 0,
+    newStart,
+    newCount: 0,
+    lines: []
+  };
+}
+function hasMoreChanges(oldLines, newLines, lcs, oldIdx, newIdx, lcsIdx) {
+  const lookAhead = 6;
+  for (let i = 0; i < lookAhead; i++) {
+    const oi = oldIdx + i;
+    const ni = newIdx + i;
+    const li = lcsIdx + i;
+    if (oi >= oldLines.length && ni >= newLines.length) return false;
+    const lcsLine = li < lcs.length ? lcs[li] : null;
+    if (lcsLine === null) return oi < oldLines.length || ni < newLines.length;
+    if (oi < oldLines.length && oldLines[oi] !== lcsLine) return true;
+    if (ni < newLines.length && ni < newLines.length && newLines[ni] !== lcsLine) return true;
+  }
+  return false;
+}
+function computeLCS(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m > 1e3 || n > 1e3) {
+    return simpleLCS(a, b);
+  }
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (a[i2 - 1] === b[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const lcs = [];
+  let i = m, j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      lcs.unshift(a[i - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return lcs;
+}
+function simpleLCS(a, b) {
+  const bSet = new Set(b);
+  return a.filter((line) => bSet.has(line));
+}
+function countChanges(diff) {
+  const lines = diff.split("\n");
+  let additions = 0;
+  let deletions = 0;
+  for (const line of lines) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      additions++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      deletions++;
+    }
+  }
+  return { additions, deletions };
+}
+var DiffManager = class {
+  diffDir = null;
+  constructor() {
+  }
+  async getDiffDir() {
+    if (this.diffDir) return this.diffDir;
+    this.diffDir = path3.join(os2.homedir(), DIFF_DIR);
+    return this.diffDir;
+  }
+  /**
+   * Save a diff to storage
+   */
+  async saveDiff(filePath, oldContent, newContent) {
+    const diff = generateDiff(oldContent, newContent, filePath);
+    if (!diff) {
+      return null;
+    }
+    const diffDir = await this.getDiffDir();
+    await fs3.mkdir(diffDir, { recursive: true });
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const { additions, deletions } = countChanges(diff);
+    const entry = {
+      timestamp,
+      filePath,
+      beforeLines: oldContent.split("\n").length,
+      afterLines: newContent.split("\n").length,
+      additions,
+      deletions,
+      diff
+    };
+    const sanitizedPath = filePath.replace(/[/\\]/g, "_").replace(/[^a-zA-Z0-9_.-]/g, "");
+    const filename = `${Date.now()}_${sanitizedPath}.diff.json`;
+    await fs3.writeFile(
+      path3.join(diffDir, filename),
+      JSON.stringify(entry, null, 2)
+    );
+    await this.cleanup();
+    return entry;
+  }
+  /**
+   * List recent diffs
+   */
+  async listDiffs(limit = 20) {
+    try {
+      const diffDir = await this.getDiffDir();
+      await fs3.mkdir(diffDir, { recursive: true });
+      const files = await fs3.readdir(diffDir);
+      const diffs = [];
+      for (const file of files.slice(-limit * 2)) {
+        if (!file.endsWith(".diff.json")) continue;
+        try {
+          const content = await fs3.readFile(
+            path3.join(diffDir, file),
+            "utf-8"
+          );
+          diffs.push(JSON.parse(content));
+        } catch {
+        }
+      }
+      return diffs.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get diff for a specific file
+   */
+  async getDiffForFile(filePath) {
+    const diffs = await this.listDiffs(100);
+    return diffs.find((d) => d.filePath === filePath) || null;
+  }
+  /**
+   * Cleanup old diffs
+   */
+  async cleanup() {
+    try {
+      const diffDir = await this.getDiffDir();
+      const files = await fs3.readdir(diffDir);
+      const now = Date.now();
+      const validFiles = [];
+      for (const file of files) {
+        if (!file.endsWith(".diff.json")) continue;
+        const match = file.match(/^(\d+)_/);
+        if (match) {
+          const time = parseInt(match[1], 10);
+          if (now - time > MAX_DIFF_AGE_MS) {
+            await fs3.unlink(path3.join(diffDir, file));
+          } else {
+            validFiles.push({ name: file, time });
+          }
+        }
+      }
+      if (validFiles.length > MAX_DIFFS) {
+        validFiles.sort((a, b) => a.time - b.time);
+        const toDelete = validFiles.slice(0, validFiles.length - MAX_DIFFS);
+        for (const { name } of toDelete) {
+          await fs3.unlink(path3.join(diffDir, name));
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Clear all diffs
+   */
+  async clearAll() {
+    try {
+      const diffDir = await this.getDiffDir();
+      const files = await fs3.readdir(diffDir);
+      for (const file of files) {
+        if (file.endsWith(".diff.json")) {
+          await fs3.unlink(path3.join(diffDir, file));
+        }
+      }
+    } catch {
+    }
+  }
+};
+var diffManager = new DiffManager();
+
+// src/core/mcp.ts
+import path4 from "path";
+import fs4 from "fs/promises";
+import os3 from "os";
+import { z as z2 } from "zod";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { CallToolResultSchema, ListToolsResultSchema } from "@modelcontextprotocol/sdk/types.js";
+var MCPServerConfigSchema = z2.object({
+  command: z2.string(),
+  args: z2.array(z2.string()).default([]),
+  env: z2.record(z2.string()).optional(),
+  secureEnv: z2.array(z2.string()).optional(),
+  // List of env vars to load from KeyManager
+  autoConnect: z2.boolean().default(false)
+});
+var MCPConfigSchema = z2.object({
+  servers: z2.record(MCPServerConfigSchema).default({})
+});
+var MCPManager = class {
+  connections = /* @__PURE__ */ new Map();
+  config = { servers: {} };
+  constructor() {
+  }
+  /**
+   * Load configuration from .obsidian-next/mcp.json
+   */
+  async init() {
+    try {
+      const configPath = path4.join(os3.homedir(), ".obsidian-next", "mcp.json");
+      const exists = await fs4.stat(configPath).then(() => true).catch(() => false);
+      if (exists) {
+        const content = await fs4.readFile(configPath, "utf-8");
+        this.config = MCPConfigSchema.parse(JSON.parse(content));
+      } else {
+        this.config = { servers: {} };
+      }
+      Object.entries(this.config.servers).forEach(([name, serverConfig]) => {
+        if (serverConfig.autoConnect) {
+          this.connect(name, serverConfig).catch((err) => {
+          });
+        }
+      });
+    } catch (error) {
+      console.error("Failed to initialize MCP Manager:", error);
+    }
+  }
+  /**
+   * Connect to an MCP server
+   */
+  async connect(name, serverConfig) {
+    if (this.connections.has(name)) {
+      return;
+    }
+    try {
+      const sanitizedEnv = serverConfig.env ? Object.fromEntries(
+        Object.entries(serverConfig.env).map(([k, v]) => [k, v.trim()])
+      ) : {};
+      if (serverConfig.secureEnv) {
+        for (const envName of serverConfig.secureEnv) {
+          const key = await keyManager.loadKey({ service: "obsidian-mcp", account: envName });
+          if (key) {
+            sanitizedEnv[envName] = key;
+          } else {
+            console.warn(`[MCP] Missing secure key for ${envName} (server: ${name})`);
+          }
+        }
+      }
+      const transport = new StdioClientTransport({
+        command: serverConfig.command,
+        args: serverConfig.args,
+        env: sanitizedEnv
+      });
+      const client = new Client(
+        {
+          name: "obsidian-next-client",
+          version: "0.4.5"
+        },
+        {
+          capabilities: {
+            // Client does not provide tools, it consumes them
+          }
+        }
+      );
+      const connectTimeout = 1e4;
+      await Promise.race([
+        client.connect(transport),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Connection timeout")), connectTimeout))
+      ]);
+      this.connections.set(name, {
+        client,
+        transport,
+        capabilities: client.getServerCapabilities()
+      });
+      if (this.config.servers[name] && !this.config.servers[name].autoConnect) {
+        this.config.servers[name].autoConnect = true;
+        await this.saveConfig();
+      }
+    } catch (error) {
+      throw new Error(`Failed to connect to ${name}: ${error}`);
+    }
+  }
+  /**
+   * Add and connect to a new server, then persist config
+   * Set skipConnect to true if the server requires manual config (API keys) before it can start
+   */
+  async addServer(name, serverConfig, skipConnect = false) {
+    if (this.config.servers[name]) {
+      throw new Error(`Server '${name}' already exists`);
+    }
+    this.config.servers[name] = serverConfig;
+    try {
+      if (!skipConnect) {
+        await this.connect(name, serverConfig);
+      }
+      await this.saveConfig();
+    } catch (error) {
+      delete this.config.servers[name];
+      throw error;
+    }
+  }
+  /**
+   * Remove a server and persist config
+   */
+  async removeServer(name) {
+    if (!this.config.servers[name]) {
+      throw new Error(`Server '${name}' not found`);
+    }
+    await this.disconnect(name);
+    delete this.config.servers[name];
+    await this.saveConfig();
+  }
+  /**
+   * Update an existing server configuration and persist
+   */
+  async updateServer(name, updates) {
+    const existing = this.config.servers[name];
+    if (!existing) {
+      throw new Error(`Server '${name}' not found`);
+    }
+    this.config.servers[name] = {
+      ...existing,
+      ...updates,
+      env: {
+        ...existing.env || {},
+        ...updates.env || {}
+      }
+    };
+    await this.saveConfig();
+    if (this.connections.has(name)) {
+      await this.disconnect(name);
+      await this.connect(name, this.config.servers[name]);
+    }
+  }
+  /**
+   * Persist current config to disk
+   */
+  async saveConfig() {
+    const configPath = path4.join(os3.homedir(), ".obsidian-next", "mcp.json");
+    await fs4.mkdir(path4.dirname(configPath), { recursive: true });
+    await fs4.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+  }
+  /**
+   * Disconnect from a server
+   */
+  async disconnect(name) {
+    const conn = this.connections.get(name);
+    if (conn) {
+      try {
+        const disconnectTimeout = 2e3;
+        await Promise.race([
+          conn.client.close(),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("Disconnect timeout")), disconnectTimeout))
+        ]);
+      } catch (error) {
+        console.warn(`Disconnect from ${name} timed out or failed:`, error);
+      } finally {
+        try {
+          const transport = conn.transport;
+          if (transport._process && typeof transport._process.kill === "function") {
+            transport._process.kill("SIGKILL");
+          }
+        } catch (e) {
+        }
+        this.connections.delete(name);
+        if (this.config.servers[name] && this.config.servers[name].autoConnect) {
+          this.config.servers[name].autoConnect = false;
+          await this.saveConfig();
+        }
+      }
+    }
+  }
+  /**
+   * List all tools from all connected servers
+   */
+  async listTools() {
+    const allTools = [];
+    for (const [serverName, conn] of this.connections) {
+      try {
+        const timeoutMs = 5e3;
+        const timeoutPromise = new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Timeout listing tools")), timeoutMs)
+        );
+        const result = await Promise.race([
+          conn.client.request(
+            { method: "tools/list" },
+            // Raw request or use helper if available
+            ListToolsResultSchema
+          ),
+          timeoutPromise
+        ]);
+        if (result && result.tools) {
+          const serverTools = result.tools.map((t) => ({
+            ...t,
+            server: serverName
+            // Attach server name for routing
+            // If we wanted to rename: name: `${serverName}__${t.name}`
+          }));
+          allTools.push(...serverTools);
+        }
+      } catch (error) {
+        console.error(`Failed to list tools from ${serverName}:`, error);
+      }
+    }
+    return allTools;
+  }
+  /**
+   * Call a specific tool on a server
+   */
+  async callTool(serverName, toolName, args) {
+    const conn = this.connections.get(serverName);
+    if (!conn) {
+      throw new Error(`Server '${serverName}' not connected.`);
+    }
+    try {
+      const result = await conn.client.request(
+        {
+          method: "tools/call",
+          params: {
+            name: toolName,
+            arguments: args
+          }
+        },
+        CallToolResultSchema
+      );
+      return result;
+    } catch (error) {
+      throw new Error(`Tool execution failed on ${serverName}/${toolName}: ${error}`);
+    }
+  }
+  /**
+   * Get active connections status
+   */
+  getStatus() {
+    return Object.keys(this.config.servers).map((name) => ({
+      name,
+      config: this.config.servers[name],
+      connected: this.connections.has(name),
+      capabilities: this.connections.get(name)?.capabilities
+    }));
+  }
+};
+var mcp = new MCPManager();
+
+// src/core/mcp-registry.ts
+var MCP_REGISTRY = {
+  "filesystem": {
+    name: "filesystem",
+    description: "Access local files and directories outside the workspace (requires permission)",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-filesystem", "/"]
+    // Root access, dangerous but powerful
+  },
+  "research": {
+    name: "research",
+    description: "Search the web using Brave Search. Excellent for docs and current info.",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-brave-search"],
+    requiresApiKey: true,
+    env: {
+      "BRAVE_API_KEY": "Needs Configuration"
+    }
+  },
+  "git": {
+    name: "git",
+    description: "Git repository management operations",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-git"]
+  },
+  "memory": {
+    name: "memory",
+    description: "Persistent knowledge graph for long-term agent memory",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-memory"]
+  },
+  "google-search": {
+    name: "google-search",
+    description: "Search the web using official Google Custom Search API",
+    command: "npx",
+    args: ["-y", "@mcp-get/google-search"],
+    requiresApiKey: true,
+    env: {
+      "GOOGLE_API_KEY": "Needs Key",
+      "GOOGLE_CSE_ID": "Needs ID"
+    }
+  },
+  "github": {
+    name: "github",
+    description: "Advanced GitHub repository management (Issues, PRs, etc)",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-github"],
+    requiresApiKey: true,
+    env: {
+      "GITHUB_PERSONAL_ACCESS_TOKEN": "Needs Token"
+    }
+  },
+  "context7": {
+    name: "context7",
+    description: "Official documentation search and retrieval (Certified Correct Docs)",
+    command: "npx",
+    args: ["-y", "@upstash/context7-mcp"],
+    requiresApiKey: true,
+    env: {
+      "CONTEXT7_API_KEY": "Needs Key"
+    }
+  }
+};
+function getRegistryDefinition(name) {
+  return MCP_REGISTRY[name];
+}
+function listRegistry() {
+  return Object.values(MCP_REGISTRY);
+}
+
+// src/core/tools.ts
+var execAsync2 = promisify2(exec2);
+var lastScreenshotScale = 1;
+var MAX_OUTPUT_LENGTH = 1e4;
+var MAX_FILE_READ_LINES = 500;
+var IGNORED_DIRS = ["node_modules", ".git", "dist", ".next", "__pycache__", ".cache", "coverage"];
+var APPROVAL_TIMEOUT = 3e4;
+function truncateOutput(output, maxLength = MAX_OUTPUT_LENGTH) {
+  if (output.length <= maxLength) return output;
+  const truncated = output.slice(0, maxLength);
+  const remaining = output.length - maxLength;
+  return `${truncated}
+
+... [TRUNCATED: ${remaining} more characters]`;
+}
+function filterSystemNoise(stderr) {
+  if (!stderr) return stderr;
+  const noisePatterns = [
+    /^aks:aks_get_lock_state:\d+:\d+: aks connection failed\s*/gm,
+    // macOS keychain noise
+    /^objc\[\d+\]: .* may have been in progress in another thread.*$/gm,
+    // Objective-C runtime
+    /^Warning: .* is deprecated.*$/gm,
+    // Deprecation warnings
+    /^\[warn\].*$/gmi,
+    // Generic warn prefixes
+    /^MESA-LOADER:.*$/gm,
+    // Mesa graphics loader
+    /^libEGL warning:.*$/gm,
+    // EGL warnings
+    /^Fontconfig warning:.*$/gm
+    // Font config
+  ];
+  let filtered = stderr;
+  for (const pattern of noisePatterns) {
+    filtered = filtered.replace(pattern, "");
+  }
+  filtered = filtered.replace(/^\s*[\r\n]/gm, "").trim();
+  return filtered;
+}
+var pendingApprovals = /* @__PURE__ */ new Map();
+bus.on("user", (event) => {
+  if (event.type === "approval_response") {
+    const pending = pendingApprovals.get(event.requestId);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      pendingApprovals.delete(event.requestId);
+      pending.resolve({ approved: event.approved, scope: event.scope, bypass: event.bypass });
+    }
+  }
+});
+async function requestApproval(command, reason) {
+  const requestId = `approval_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      pendingApprovals.delete(requestId);
+      bus.emitAgent({
+        type: "error",
+        message: "No response received. Command blocked for safety."
+      });
+      resolve({ approved: false, scope: "session" });
+    }, APPROVAL_TIMEOUT);
+    pendingApprovals.set(requestId, { resolve, timeout });
+    const context2 = [
+      `Command: ${command}`,
+      `Reason: ${reason}`
+    ].join("\n");
+    bus.emitAgent({
+      type: "approval_request",
+      requestId,
+      context: context2
+    });
+  });
+}
+var BashTool = {
+  name: "bash",
+  description: "Execute shell commands in the workspace",
+  inputSchema: {
+    command: {
+      type: "string",
+      description: "The shell command to execute"
+    }
+  },
+  requiredParams: ["command"],
+  async execute(args) {
+    const command = args.command;
+    if (!command) {
+      return { success: false, error: "No command provided" };
+    }
+    const audit = await auditor.checkCommand(command);
+    if (!audit.approved && audit.isCritical) {
+      await auditLog.logSecurityViolation(command, audit.reason || "Critical security violation");
+      return {
+        success: false,
+        error: `Security violation: ${audit.reason}`
+      };
+    }
+    if (!audit.approved && audit.requiresApproval) {
+      await auditLog.logApproval("requested", command, audit.reason);
+      const { approved, scope, bypass } = await requestApproval(command, audit.reason || "Potentially dangerous operation");
+      if (approved) {
+        if (scope === "persistent") {
+          if (bypass) {
+            await settings.addUnsandboxedPermission("bash", command);
+          } else {
+            await settings.addAllowedPermission("bash", command);
+          }
+        } else {
+          await settings.addSessionPermission("bash", command, true, bypass);
+        }
+        await auditLog.logApproval("granted", command, bypass ? "Bypass enabled" : void 0);
+      } else {
+        if (scope === "persistent") {
+          await settings.addDeniedPermission("bash", command);
+        } else {
+          await settings.addSessionPermission("bash", command, false);
+        }
+        await auditLog.logApproval("denied", command);
+        return {
+          success: false,
+          error: "Command rejected by user"
+        };
+      }
+    }
+    const bypassSandbox = await settings.isUnsandboxed("bash", command);
+    const cfg = await config.load();
+    try {
+      const execCommand = await sandbox.wrapCommand(command, bypassSandbox);
+      const { stdout, stderr } = await execAsync2(execCommand, {
+        cwd: cfg.workspaceRoot,
+        timeout: 3e4,
+        // 30 second timeout
+        maxBuffer: 1024 * 1024
+        // 1MB buffer (reduced from 10MB)
+      });
+      const filteredStderr = filterSystemNoise(stderr);
+      const output = stdout || filteredStderr || "Command executed successfully";
+      await auditLog.logCommand(command, true);
+      return {
+        success: true,
+        output: truncateOutput(output)
+      };
+    } catch (error) {
+      await auditLog.logCommand(command, false, error.message);
+      return {
+        success: false,
+        error: error.message || "Command execution failed"
+      };
+    }
+  }
+};
+var ReadTool = {
+  name: "read",
+  description: "Read file contents from the workspace",
+  inputSchema: {
+    path: {
+      type: "string",
+      description: "Path to the file to read (relative to workspace)"
+    }
+  },
+  requiredParams: ["path"],
+  async execute(args) {
+    const filePath = args.path;
+    if (!filePath) {
+      return { success: false, error: "No file path provided" };
+    }
+    const pathCheck = auditor.checkPath(filePath);
+    if (!pathCheck.approved) {
+      return {
+        success: false,
+        error: pathCheck.reason
+      };
+    }
+    if (IGNORED_DIRS.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`))) {
+      return {
+        success: false,
+        error: `Cannot read from ignored directory. Paths containing ${IGNORED_DIRS.join(", ")} are blocked to prevent context explosion.`
+      };
+    }
+    try {
+      const cfg = await config.load();
+      const fullPath = path5.resolve(cfg.workspaceRoot, filePath);
+      const content = await fs5.readFile(fullPath, "utf-8");
+      const lines = content.split("\n");
+      const limitedLines = lines.slice(0, MAX_FILE_READ_LINES);
+      const numbered = limitedLines.map((line, i) => `${String(i + 1).padStart(4)} | ${line}`).join("\n");
+      const truncationNote = lines.length > MAX_FILE_READ_LINES ? `
+
+... [TRUNCATED: ${lines.length - MAX_FILE_READ_LINES} more lines. Use offset parameter to read more.]` : "";
+      await context.trackRead(filePath);
+      await auditLog.logFileOperation("read", filePath, true);
+      return {
+        success: true,
+        output: truncateOutput(`File: ${filePath} (${lines.length} lines)
+${"=".repeat(60)}
+${numbered}${truncationNote}`)
+      };
+    } catch (error) {
+      await auditLog.logFileOperation("read", filePath, false, error.message);
+      return {
+        success: false,
+        error: `Failed to read file: ${error.message}`
+      };
+    }
+  }
+};
+var WriteTool = {
+  name: "write",
+  description: "Create new files in the workspace",
+  inputSchema: {
+    path: {
+      type: "string",
+      description: "Path where to create the new file"
+    },
+    content: {
+      type: "string",
+      description: "Content to write to the file"
+    }
+  },
+  requiredParams: ["path", "content"],
+  async execute(args) {
+    const filePath = args.path;
+    const content = args.content;
+    if (!filePath) {
+      return { success: false, error: "No file path provided" };
+    }
+    if (content === void 0) {
+      return { success: false, error: "No content provided" };
+    }
+    const pathCheck = auditor.checkPath(filePath);
+    if (!pathCheck.approved) {
+      return {
+        success: false,
+        error: pathCheck.reason
+      };
+    }
+    try {
+      const cfg = await config.load();
+      const fullPath = path5.resolve(cfg.workspaceRoot, filePath);
+      try {
+        await fs5.access(fullPath);
+        return {
+          success: false,
+          error: `File already exists: ${filePath}. Use 'edit' tool to modify.`
+        };
+      } catch {
+      }
+      await fs5.mkdir(path5.dirname(fullPath), { recursive: true });
+      await fs5.writeFile(fullPath, content, "utf-8");
+      await context.trackModified(filePath);
+      await undo.recordChange(filePath, "create", null, content);
+      await auditLog.logFileOperation("write", filePath, true);
+      await diffManager.saveDiff(filePath, "", content);
+      return {
+        success: true,
+        output: `Created file: ${filePath} (${content.length} bytes)`
+      };
+    } catch (error) {
+      await auditLog.logFileOperation("write", filePath, false, error.message);
+      return {
+        success: false,
+        error: `Failed to write file: ${error.message}`
+      };
+    }
+  }
+};
+var EditTool = {
+  name: "edit",
+  description: "Edit existing files using search and replace",
+  inputSchema: {
+    path: {
+      type: "string",
+      description: "Path to the file to edit"
+    },
+    search: {
+      type: "string",
+      description: "Text to search for (must match exactly)"
+    },
+    replace: {
+      type: "string",
+      description: "Text to replace with"
+    }
+  },
+  requiredParams: ["path", "search", "replace"],
+  async execute(args) {
+    const filePath = args.path;
+    const search = args.search;
+    const replace = args.replace;
+    if (!filePath) {
+      return { success: false, error: "No file path provided" };
+    }
+    if (!search) {
+      return { success: false, error: "No search string provided" };
+    }
+    if (replace === void 0) {
+      return { success: false, error: "No replacement string provided" };
+    }
+    const fileCheck = await auditor.checkFileEdit(filePath);
+    if (!fileCheck.approved) {
+      return {
+        success: false,
+        error: fileCheck.reason
+      };
+    }
+    try {
+      const cfg = await config.load();
+      const fullPath = path5.resolve(cfg.workspaceRoot, filePath);
+      const original = await fs5.readFile(fullPath, "utf-8");
+      if (!original.includes(search)) {
+        return {
+          success: false,
+          error: `Search string not found in ${filePath}`
+        };
+      }
+      const occurrences = original.split(search).length - 1;
+      const modified = original.replaceAll(search, replace);
+      const diffPreview = generateDiffPreview(search, replace);
+      await fs5.writeFile(fullPath, modified, "utf-8");
+      const originalLines = original.split("\n").length;
+      const modifiedLines = modified.split("\n").length;
+      const delta = modifiedLines - originalLines;
+      await context.trackModified(filePath);
+      await undo.recordChange(filePath, "edit", original, modified);
+      await auditLog.logFileOperation("edit", filePath, true);
+      await diffManager.saveDiff(filePath, original, modified);
+      const occurrenceText = occurrences > 1 ? ` (${occurrences} occurrences)` : "";
+      return {
+        success: true,
+        output: `Edited ${filePath}${occurrenceText}:
+${diffPreview}
+Lines: ${originalLines} -> ${modifiedLines} (${delta >= 0 ? "+" : ""}${delta})`
+      };
+    } catch (error) {
+      await auditLog.logFileOperation("edit", filePath, false, error.message);
+      return {
+        success: false,
+        error: `Failed to edit file: ${error.message}`
+      };
+    }
+  }
+};
+function generateDiffPreview(search, replace) {
+  const searchLines = search.split("\n").slice(0, 5);
+  const replaceLines = replace.split("\n").slice(0, 5);
+  let preview = "";
+  for (const line of searchLines) {
+    preview += `- ${line}
+`;
+  }
+  if (search.split("\n").length > 5) {
+    preview += `- ... (${search.split("\n").length - 5} more lines)
+`;
+  }
+  for (const line of replaceLines) {
+    preview += `+ ${line}
+`;
+  }
+  if (replace.split("\n").length > 5) {
+    preview += `+ ... (${replace.split("\n").length - 5} more lines)
+`;
+  }
+  return preview.trim();
+}
+var ListTool = {
+  name: "list",
+  description: "List files and directories in the workspace",
+  inputSchema: {
+    path: {
+      type: "string",
+      description: "Directory path to list (defaults to current directory)"
+    }
+  },
+  requiredParams: [],
+  async execute(args) {
+    const dirPath = args.path || ".";
+    const pathCheck = auditor.checkPath(dirPath);
+    if (!pathCheck.approved) {
+      return {
+        success: false,
+        error: pathCheck.reason
+      };
+    }
+    try {
+      const cfg = await config.load();
+      const fullPath = path5.resolve(cfg.workspaceRoot, dirPath);
+      const entries = await fs5.readdir(fullPath, { withFileTypes: true });
+      const filtered = entries.filter(
+        (entry) => !IGNORED_DIRS.includes(entry.name) && !entry.name.startsWith(".")
+      );
+      const formatted = filtered.map((entry) => {
+        const prefix = entry.isDirectory() ? "[DIR]" : "[FILE]";
+        return `${prefix} ${entry.name}`;
+      }).join("\n");
+      const hiddenCount = entries.length - filtered.length;
+      const hiddenNote = hiddenCount > 0 ? `
+
+(${hiddenCount} hidden: node_modules, .git, etc.)` : "";
+      return {
+        success: true,
+        output: `Directory: ${dirPath}
+${"=".repeat(60)}
+${formatted}${hiddenNote}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to list directory: ${error.message}`
+      };
+    }
+  }
+};
+var GrepTool = {
+  name: "grep",
+  description: "Search for patterns in files using regex",
+  inputSchema: {
+    pattern: {
+      type: "string",
+      description: "Regex pattern to search for"
+    },
+    path: {
+      type: "string",
+      description: "Directory to search in (defaults to current directory)"
+    },
+    limit: {
+      type: "number",
+      description: "Maximum number of results (default: 50)"
+    }
+  },
+  requiredParams: ["pattern"],
+  async execute(args) {
+    const pattern = args.pattern;
+    const searchPath = args.path || ".";
+    const maxResults = args.limit || 50;
+    if (!pattern) {
+      return { success: false, error: "No search pattern provided" };
+    }
+    const pathCheck = auditor.checkPath(searchPath);
+    if (!pathCheck.approved) {
+      return {
+        success: false,
+        error: pathCheck.reason
+      };
+    }
+    try {
+      const cfg = await config.load();
+      const fullPath = path5.resolve(cfg.workspaceRoot, searchPath);
+      const results = [];
+      await searchDirectory(fullPath, pattern, results, maxResults, 0, cfg.workspaceRoot);
+      if (results.length === 0) {
+        return {
+          success: true,
+          output: `No matches found for: ${pattern}`
+        };
+      }
+      return {
+        success: true,
+        output: truncateOutput(`Found ${results.length} matches for "${pattern}":
+${"=".repeat(60)}
+${results.join("\n")}`)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Search failed: ${error.message}`
+      };
+    }
+  }
+};
+async function searchDirectory(dir, pattern, results, maxResults, depth = 0, workspaceRoot = process.cwd()) {
+  if (results.length >= maxResults || depth > 10) return;
+  try {
+    const entries = await fs5.readdir(dir, { withFileTypes: true });
+    const regex = new RegExp(pattern, "gi");
+    for (const entry of entries) {
+      if (results.length >= maxResults) break;
+      const fullPath = path5.join(dir, entry.name);
+      const relativePath = path5.relative(workspaceRoot, fullPath);
+      if (entry.name.startsWith(".") || IGNORED_DIRS.includes(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await searchDirectory(fullPath, pattern, results, maxResults, depth + 1, workspaceRoot);
+      } else if (entry.isFile()) {
+        const ext = path5.extname(entry.name).toLowerCase();
+        const textExtensions = [".ts", ".tsx", ".js", ".jsx", ".json", ".md", ".txt", ".yaml", ".yml", ".css", ".html", ".sh"];
+        if (textExtensions.includes(ext) || ext === "") {
+          try {
+            const content = await fs5.readFile(fullPath, "utf-8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length && results.length < maxResults; i++) {
+              if (regex.test(lines[i])) {
+                results.push(`${relativePath}:${i + 1}: ${lines[i].trim().slice(0, 100)}`);
+              }
+              regex.lastIndex = 0;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+  }
+}
+var GlobTool = {
+  name: "glob",
+  description: "Find files matching a glob pattern (e.g., **/*.ts, src/**/*.tsx)",
+  inputSchema: {
+    pattern: {
+      type: "string",
+      description: "Glob pattern like **/*.ts or src/**/*.tsx"
+    },
+    path: {
+      type: "string",
+      description: "Base directory (defaults to current directory)"
+    }
+  },
+  requiredParams: ["pattern"],
+  async execute(args) {
+    const pattern = args.pattern;
+    const basePath = args.path || ".";
+    if (!pattern) {
+      return { success: false, error: "No pattern provided" };
+    }
+    try {
+      const cfg = await config.load();
+      const results = [];
+      const fullBase = path5.resolve(cfg.workspaceRoot, basePath);
+      await globSearch(fullBase, pattern, results, 100, 0, cfg.workspaceRoot);
+      if (results.length === 0) {
+        return {
+          success: true,
+          output: `No files matching: ${pattern}`
+        };
+      }
+      return {
+        success: true,
+        output: truncateOutput(`Found ${results.length} files:
+${results.join("\n")}`)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Glob failed: ${error.message}`
+      };
+    }
+  }
+};
+async function globSearch(dir, pattern, results, maxResults, depth = 0, workspaceRoot = process.cwd()) {
+  if (results.length >= maxResults || depth > 15) return;
+  try {
+    const entries = await fs5.readdir(dir, { withFileTypes: true });
+    const regexPattern = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/{{GLOBSTAR}}/g, ".*");
+    const regex = new RegExp(`^${regexPattern}$`);
+    for (const entry of entries) {
+      if (results.length >= maxResults) break;
+      if (entry.name.startsWith(".") || IGNORED_DIRS.includes(entry.name)) {
+        continue;
+      }
+      const fullPath = path5.join(dir, entry.name);
+      const relativePath = path5.relative(workspaceRoot, fullPath);
+      if (entry.isDirectory()) {
+        if (pattern.includes("**") || pattern.includes("/")) {
+          await globSearch(fullPath, pattern, results, maxResults, depth + 1, workspaceRoot);
+        }
+      } else if (entry.isFile()) {
+        if (regex.test(relativePath) || regex.test(entry.name)) {
+          results.push(relativePath);
+        }
+      }
+    }
+  } catch {
+  }
+}
+var TaskTool = {
+  name: "task",
+  description: "Manage the project plan and todo list. Use this for tracking work items, not for scheduling recurring jobs. actions: create, add_step, complete_step, fail_step, complete_task",
+  inputSchema: {
+    action: {
+      type: "string",
+      description: "Action to perform: create, add_step, complete_step, fail_step, complete_task"
+    },
+    title: {
+      type: "string",
+      description: "Title for new task (required for create)"
+    },
+    step: {
+      type: "string",
+      description: "Step description (required for add_step)"
+    },
+    step_index: {
+      type: "number",
+      description: "Index of step to complete/fail (required for step actions)"
+    }
+  },
+  requiredParams: ["action"],
+  async execute(args) {
+    const action = args.action;
+    const title = args.title;
+    const step = args.step;
+    const stepIndex = args.step_index;
+    if (!action) return { success: false, error: "No action provided" };
+    try {
+      switch (action) {
+        case "create":
+          if (!title) return { success: false, error: "Title required for create" };
+          await tasks.create(title);
+          return { success: true, output: `Created task: ${title}` };
+        case "add_step":
+          if (!step) return { success: false, error: "Step text required" };
+          await tasks.addSubtask(step);
+          return { success: true, output: `Added step: ${step}` };
+        case "complete_step":
+          if (stepIndex === void 0) return { success: false, error: "Step index required" };
+          await tasks.completeSubtask(stepIndex);
+          return { success: true, output: `Completed step ${stepIndex}` };
+        case "fail_step":
+          return { success: true, output: `Marked step ${stepIndex} as failed (not implemented in tracker yet)` };
+        case "complete_task":
+          await tasks.complete();
+          return { success: true, output: "Marked task as complete" };
+        default:
+          return { success: false, error: `Unknown action: ${action}` };
+      }
+    } catch (error) {
+      return { success: false, error: `Task action failed: ${error.message}` };
+    }
+  }
+};
+var WebFetchTool = {
+  name: "web_fetch",
+  description: "Fetch content from a URL (for documentation, APIs, etc.)",
+  inputSchema: {
+    url: {
+      type: "string",
+      description: "URL to fetch content from"
+    }
+  },
+  requiredParams: ["url"],
+  async execute(args) {
+    const url = args.url;
+    if (!url) {
+      return { success: false, error: "No URL provided" };
+    }
+    try {
+      new URL(url);
+    } catch {
+      return { success: false, error: "Invalid URL format" };
+    }
+    const blockedDomains = ["localhost", "127.0.0.1", "0.0.0.0", "169.254"];
+    const urlObj = new URL(url);
+    if (blockedDomains.some((d) => urlObj.hostname.includes(d))) {
+      return {
+        success: false,
+        error: "Cannot fetch from local/private addresses"
+      };
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 1e4);
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "Obsidian-Next/1.0 (AI Agent CLI)",
+          "Accept": "text/html,application/json,text/plain,*/*"
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const contentType = response.headers.get("content-type") || "";
+      let content = await response.text();
+      if (content.length > MAX_OUTPUT_LENGTH) {
+        content = content.slice(0, MAX_OUTPUT_LENGTH) + `
+
+... [TRUNCATED: ${content.length - MAX_OUTPUT_LENGTH} more characters]`;
+      }
+      if (contentType.includes("text/html")) {
+        content = content.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+      }
+      return {
+        success: true,
+        output: truncateOutput(`URL: ${url}
+Content-Type: ${contentType}
+${"=".repeat(60)}
+${content}`)
+      };
+    } catch (error) {
+      if (error.name === "AbortError") {
+        return { success: false, error: "Request timed out after 10 seconds" };
+      }
+      return {
+        success: false,
+        error: `Fetch failed: ${error.message}`
+      };
+    }
+  }
+};
+var MCPManagementTool = {
+  name: "mcp_manage",
+  description: 'Manage MCP servers. actions: add, remove, install. Use "install" to easily add certified tools like "filesystem", "git", "research", or "context7".',
+  inputSchema: {
+    action: {
+      type: "string",
+      description: "Action to perform: add, remove, install"
+    },
+    name: {
+      type: "string",
+      description: 'Name of the server (e.g. "filesystem", "research", "context7")'
+    },
+    command: {
+      type: "string",
+      description: "Command to execute (add only)"
+    },
+    args: {
+      type: "string",
+      description: "Args for command (add only)"
+    }
+  },
+  requiredParams: ["action", "name"],
+  async execute(args) {
+    const action = args.action;
+    const name = args.name;
+    if (action === "install") {
+      const def = getRegistryDefinition(name);
+      if (!def) {
+        const available = listRegistry().map((r) => r.name).join(", ");
+        return { success: false, error: `Unknown registry item '${name}'. Available: ${available}` };
+      }
+      const existing = mcp.getStatus().find((s) => s.name === name);
+      if (existing && existing.connected) {
+        return { success: true, output: `MCP server '${name}' is already installed and connected.` };
+      }
+      try {
+        await mcp.addServer(name, {
+          command: def.command,
+          args: def.args,
+          autoConnect: false,
+          env: def.env
+        });
+        return { success: true, output: `Successfully installed and connected to certified MCP server '${name}' (${def.description})` };
+      } catch (e) {
+        return { success: false, error: `Failed to install server: ${e.message}` };
+      }
+    }
+    if (action === "add") {
+      if (!args.command) return { success: false, error: 'Command is required for "add" action' };
+      const command = args.command;
+      const commandArgs = (args.args || "").split(" ").filter((a) => a.length > 0);
+      try {
+        await mcp.addServer(name, {
+          command,
+          args: commandArgs,
+          autoConnect: false
+        });
+        return { success: true, output: `Successfully added and connected to MCP server '${name}'` };
+      } catch (e) {
+        return { success: false, error: `Failed to add server: ${e.message}` };
+      }
+    }
+    if (action === "remove") {
+      try {
+        await mcp.removeServer(name);
+        return { success: true, output: `Successfully removed MCP server '${name}'` };
+      } catch (e) {
+        return { success: false, error: `Failed to remove server: ${e.message}` };
+      }
+    }
+    if (action === "connect") {
+      try {
+        const status = mcp.getStatus().find((s) => s.name === name);
+        if (!status) return { success: false, error: `Server '${name}' not found in config` };
+        if (status.connected) return { success: true, output: `Server '${name}' is already connected` };
+        await mcp.connect(name, status.config);
+        return { success: true, output: `Successfully connected to MCP server '${name}'` };
+      } catch (e) {
+        return { success: false, error: `Failed to connect: ${e.message}` };
+      }
+    }
+    if (action === "disconnect") {
+      try {
+        await mcp.disconnect(name);
+        return { success: true, output: `Successfully disconnected MCP server '${name}'` };
+      } catch (e) {
+        return { success: false, error: `Failed to disconnect: ${e.message}` };
+      }
+    }
+    if (action === "status") {
+      const status = mcp.getStatus().find((s) => s.name === name);
+      if (!status) return { success: false, error: `Server '${name}' not found` };
+      return {
+        success: true,
+        output: `Server: ${name}
+Status: ${status.connected ? "Connected" : "Disconnected"}
+Tools: ${status.capabilities ? "Available" : "N/A"}`
+      };
+    }
+    return { success: false, error: `Unknown action: ${action}` };
+  }
+};
+var MemoryTool = {
+  name: "memory",
+  description: "Store and recall long-term memories: user preferences, project facts, and learned patterns. Use this to remember user information across sessions.",
+  inputSchema: {
+    action: { type: "string", description: "Action: store, recall, search, list, forget" },
+    type: { type: "string", description: "Memory type: user_preference, project_fact, decision_log, learned_pattern (for store)" },
+    key: { type: "string", description: "Unique key for the memory (for store, recall, forget)" },
+    content: { type: "string", description: "Content to store (for store action)" },
+    query: { type: "string", description: "Search query (for search action)" }
+  },
+  requiredParams: ["action"],
+  async execute(args) {
+    const { memory } = await import("./memory-MV3S7GFY.js");
+    const { action, type, key, content, query } = args;
+    await memory.init();
+    if (action === "store") {
+      if (!key || !content) {
+        return { success: false, error: "store requires key and content" };
+      }
+      const memoType = type || "user_preference";
+      const success = await memory.store(memoType, key, content);
+      if (success) {
+        return { success: true, output: `Stored memory: ${key}` };
+      }
+      return { success: false, error: "Failed to store memory" };
+    }
+    if (action === "recall") {
+      if (!key) {
+        return { success: false, error: "recall requires key" };
+      }
+      const memo = await memory.recall(key);
+      if (memo) {
+        return { success: true, output: `[${memo.type}] ${memo.key}: ${memo.content}` };
+      }
+      return { success: true, output: `No memory found for key: ${key}` };
+    }
+    if (action === "search") {
+      if (!query) {
+        return { success: false, error: "search requires query" };
+      }
+      const memos = await memory.search(query, type);
+      if (memos.length === 0) {
+        return { success: true, output: "No memories found matching query" };
+      }
+      const lines = memos.map((m) => `- [${m.type}] ${m.key}: ${m.content}`);
+      return { success: true, output: `Found ${memos.length} memories:
+${lines.join("\n")}` };
+    }
+    if (action === "list") {
+      const memoType = type;
+      let memos;
+      if (memoType) {
+        memos = await memory.getByType(memoType);
+        if (memos.length === 0) {
+          return { success: true, output: `No ${memoType} memories found` };
+        }
+        const lines = memos.map((m) => `- ${m.key}: ${m.content}`);
+        return { success: true, output: `${memoType} memories:
+${lines.join("\n")}` };
+      } else {
+        const stats = await memory.getStats();
+        const allMemos = [];
+        for (const t of Object.keys(stats.byType)) {
+          const typeMemos = await memory.getByType(t);
+          if (typeMemos.length > 0) {
+            allMemos.push(`--- ${t} ---`);
+            allMemos.push(...typeMemos.map((m) => `- ${m.key}: ${m.content}`));
+          }
+        }
+        if (allMemos.length === 0) return { success: true, output: "No memories found in any category." };
+        return { success: true, output: `Current Memory Bank:
+${allMemos.join("\n")}` };
+      }
+    }
+    if (action === "forget") {
+      if (!key) {
+        return { success: false, error: "forget requires key" };
+      }
+      const success = await memory.forget(key);
+      if (success) {
+        return { success: true, output: `Forgot memory: ${key}` };
+      }
+      return { success: false, error: "Failed to forget memory" };
+    }
+    return { success: false, error: `Unknown action: ${action}. Valid: store, recall, search, list, forget` };
+  }
+};
+var UnscheduleTool = {
+  name: "unschedule_task",
+  description: "Unschedule a previously scheduled background cron job. Requires the task ID.",
+  inputSchema: {
+    taskId: {
+      type: "string",
+      description: "The ID of the task to unschedule (obtained from list_scheduled_tasks)."
+    }
+  },
+  requiredParams: ["taskId"],
+  async execute(args) {
+    const taskId = args.taskId;
+    if (!taskId) {
+      return { success: false, error: "Task ID is required to unschedule a task." };
+    }
+    try {
+      const success = await scheduler.removeTask(taskId);
+      if (success) {
+        return { success: true, output: `Successfully unscheduled task: ${taskId}` };
+      } else {
+        return { success: false, output: `Failed to unschedule task: ${taskId}. Task not found or already inactive.` };
+      }
+    } catch (error) {
+      return { success: false, error: `Failed to unschedule task: ${error.message}` };
+    }
+  }
+};
+var ComputerUseTool = {
+  name: "computer",
+  description: `Desktop interaction. PREFER BASH for URLs/apps (e.g., bash 'open "https://youtube.com"').
+
+SMART ACTIONS (use first):
+- find_and_click: Click by label ("Submit", "Play") - no coordinates needed
+- get_ui_context: List buttons/fields in current window
+- get_buttons: List all button labels
+- activate_app: Bring app to front
+
+COORDINATE ACTIONS (use when smart actions fail):
+- screenshot: Capture screen
+- left_click: Click at [x,y]
+- type: Type text
+- key: Press key (cmd+l, Return, etc.)
+- scroll: Scroll at position`,
+  inputSchema: {
+    action: {
+      type: "string",
+      description: "SMART (prefer): find_and_click, get_ui_context, get_buttons, activate_app, get_focused_app. COORDINATE (fallback): screenshot, left_click, type, key, scroll, mouse_move, double_click, right_click, left_click_drag, wait, zoom."
+    },
+    coordinate: {
+      type: "array",
+      items: { type: "number" },
+      description: "[x, y] pixel coordinates for coordinate-based actions."
+    },
+    text: {
+      type: "string",
+      description: "Text to type, or modifier key for clicks (shift, control, alt, command)."
+    },
+    key: {
+      type: "string",
+      description: "Key to press (e.g., enter, escape, ctrl+c)."
+    },
+    label: {
+      type: "string",
+      description: 'UI element label for find_and_click (e.g., "Submit", "Cancel", "OK").'
+    },
+    app_name: {
+      type: "string",
+      description: "Application name for activate_app or to scope element search."
+    },
+    scroll_direction: {
+      type: "string",
+      description: "up, down, left, or right"
+    },
+    scroll_amount: {
+      type: "number",
+      description: "Amount to scroll (default: 3)"
+    },
+    start_coordinate: {
+      type: "array",
+      items: { type: "number" },
+      description: "[x, y] start coordinates for drag"
+    },
+    end_coordinate: {
+      type: "array",
+      items: { type: "number" },
+      description: "[x, y] end coordinates for drag"
+    },
+    duration: {
+      type: "number",
+      description: "Duration in milliseconds (for wait, hold_key)"
+    },
+    region: {
+      type: "array",
+      items: { type: "number" },
+      description: "[x1, y1, x2, y2] region for zoom"
+    }
+  },
+  requiredParams: ["action"],
+  async execute(args) {
+    const actionType = args.action;
+    if (!actionType) {
+      return { success: false, error: "No computer action provided. Use: screenshot, left_click, type, key, mouse_move, scroll, etc." };
+    }
+    const validateCoord = (coord, name = "coordinate") => {
+      if (!coord || !Array.isArray(coord) || coord.length < 2) {
+        return null;
+      }
+      const x = Number(coord[0]);
+      const y = Number(coord[1]);
+      if (isNaN(x) || isNaN(y)) return null;
+      return [x, y];
+    };
+    const scaleToNative = (coord) => {
+      if (lastScreenshotScale >= 1) return coord;
+      return [
+        Math.round(coord[0] / lastScreenshotScale),
+        Math.round(coord[1] / lastScreenshotScale)
+      ];
+    };
+    try {
+      let output;
+      switch (actionType) {
+        case "screenshot":
+          const screenshotResult = await takeScreenshotForAPI(false);
+          lastScreenshotScale = screenshotResult.scale;
+          bus.emitAgent({
+            type: "computer_scale_update",
+            scale: screenshotResult.scale,
+            scaledWidth: screenshotResult.width,
+            scaledHeight: screenshotResult.height,
+            nativeWidth: Math.round(screenshotResult.width / screenshotResult.scale),
+            nativeHeight: Math.round(screenshotResult.height / screenshotResult.scale)
+          });
+          return {
+            success: true,
+            output: `Screenshot captured (${screenshotResult.width}x${screenshotResult.height}, scale: ${screenshotResult.scale.toFixed(2)}). Native: ${Math.round(screenshotResult.width / screenshotResult.scale)}x${Math.round(screenshotResult.height / screenshotResult.scale)}`,
+            content: [{ type: "image", data: screenshotResult.base64, mimeType: "image/png" }]
+          };
+        case "left_click": {
+          const coord = validateCoord(args.coordinate);
+          if (!coord) return { success: false, error: "left_click requires coordinate: [x, y] as numbers" };
+          const [nativeX, nativeY] = scaleToNative(coord);
+          await computer.leftClick(nativeX, nativeY, args.text);
+          output = `Clicked at screenshot (${coord[0]}, ${coord[1]}) -> native (${nativeX}, ${nativeY}). If this missed the target, re-examine the screenshot and identify the EXACT center of the element you want to click.`;
+          break;
+        }
+        case "type":
+          if (!args.text && args.text !== "") return { success: false, error: "type requires text parameter" };
+          await computer.typeText(args.text);
+          output = `Typed: "${args.text.substring(0, 30)}${args.text.length > 30 ? "..." : ""}"`;
+          break;
+        case "key":
+          const keyToPress = args.key || args.text;
+          if (!keyToPress) return { success: false, error: 'key requires key parameter (e.g., "enter", "escape", "ctrl+c")' };
+          await computer.pressKey(keyToPress);
+          output = `Pressed key: ${keyToPress}`;
+          break;
+        case "mouse_move": {
+          const coord = validateCoord(args.coordinate);
+          if (!coord) return { success: false, error: "mouse_move requires coordinate: [x, y]" };
+          const [nativeX, nativeY] = scaleToNative(coord);
+          await computer.mouseMove(nativeX, nativeY);
+          output = `Mouse moved to screenshot (${coord[0]}, ${coord[1]}) -> native (${nativeX}, ${nativeY}).`;
+          break;
+        }
+        case "scroll": {
+          const coord = validateCoord(args.coordinate);
+          if (!coord) return { success: false, error: "scroll requires coordinate: [x, y]" };
+          if (!args.scroll_direction) return { success: false, error: "scroll requires scroll_direction: up|down|left|right" };
+          const amount = args.scroll_amount || 3;
+          const [nativeX, nativeY] = scaleToNative(coord);
+          await computer.scroll(nativeX, nativeY, args.scroll_direction, amount, args.text);
+          output = `Scrolled ${args.scroll_direction} by ${amount} at screenshot (${coord[0]}, ${coord[1]}) -> native (${nativeX}, ${nativeY}).`;
+          break;
+        }
+        case "left_click_drag": {
+          const startCoord = validateCoord(args.start_coordinate, "start_coordinate");
+          const endCoord = validateCoord(args.end_coordinate, "end_coordinate");
+          if (!startCoord) return { success: false, error: "left_click_drag requires start_coordinate: [x, y]" };
+          if (!endCoord) return { success: false, error: "left_click_drag requires end_coordinate: [x, y]" };
+          const [nativeStartX, nativeStartY] = scaleToNative(startCoord);
+          const [nativeEndX, nativeEndY] = scaleToNative(endCoord);
+          await computer.leftClickDrag(nativeStartX, nativeStartY, nativeEndX, nativeEndY);
+          output = `Dragged from screenshot (${startCoord[0]}, ${startCoord[1]}) -> native (${nativeStartX}, ${nativeStartY}) to screenshot (${endCoord[0]}, ${endCoord[1]}) -> native (${nativeEndX}, ${nativeEndY}).`;
+          break;
+        }
+        case "right_click": {
+          const coord = validateCoord(args.coordinate);
+          if (!coord) return { success: false, error: "right_click requires coordinate: [x, y]" };
+          const [nativeX, nativeY] = scaleToNative(coord);
+          await computer.rightClick(nativeX, nativeY, args.text);
+          output = `Right click at screenshot (${coord[0]}, ${coord[1]}) -> native (${nativeX}, ${nativeY}).`;
+          break;
+        }
+        case "middle_click": {
+          const coord = validateCoord(args.coordinate);
+          if (!coord) return { success: false, error: "middle_click requires coordinate: [x, y]" };
+          const [nativeX, nativeY] = scaleToNative(coord);
+          await computer.middleClick(nativeX, nativeY, args.text);
+          output = `Middle click at screenshot (${coord[0]}, ${coord[1]}) -> native (${nativeX}, ${nativeY}).`;
+          break;
+        }
+        case "double_click": {
+          const coord = validateCoord(args.coordinate);
+          if (!coord) return { success: false, error: "double_click requires coordinate: [x, y]" };
+          const [nativeX, nativeY] = scaleToNative(coord);
+          await computer.doubleClick(nativeX, nativeY, args.text);
+          output = `Double click at screenshot (${coord[0]}, ${coord[1]}) -> native (${nativeX}, ${nativeY}).`;
+          break;
+        }
+        case "triple_click": {
+          const coord = validateCoord(args.coordinate);
+          if (!coord) return { success: false, error: "triple_click requires coordinate: [x, y]" };
+          const [nativeX, nativeY] = scaleToNative(coord);
+          await computer.tripleClick(nativeX, nativeY, args.text);
+          output = `Triple click at screenshot (${coord[0]}, ${coord[1]}) -> native (${nativeX}, ${nativeY}).`;
+          break;
+        }
+        case "left_mouse_down": {
+          const coord = validateCoord(args.coordinate);
+          if (!coord) return { success: false, error: "left_mouse_down requires coordinate: [x, y]" };
+          const [nativeX, nativeY] = scaleToNative(coord);
+          await computer.leftMouseDown(nativeX, nativeY);
+          output = `Mouse down at screenshot (${coord[0]}, ${coord[1]}) -> native (${nativeX}, ${nativeY}).`;
+          break;
+        }
+        case "left_mouse_up": {
+          const coord = validateCoord(args.coordinate);
+          if (!coord) return { success: false, error: "left_mouse_up requires coordinate: [x, y]" };
+          const [nativeX, nativeY] = scaleToNative(coord);
+          await computer.leftMouseUp(nativeX, nativeY);
+          output = `Mouse up at screenshot (${coord[0]}, ${coord[1]}) -> native (${nativeX}, ${nativeY}).`;
+          break;
+        }
+        case "hold_key": {
+          const keyToHold = args.key || args.text;
+          if (!keyToHold) return { success: false, error: "hold_key requires key parameter" };
+          const duration = args.duration || 1;
+          await computer.holdKey(keyToHold, duration);
+          output = `Held ${keyToHold} for ${duration}s.`;
+          break;
+        }
+        case "wait": {
+          const duration = args.duration || 1e3;
+          await computer.wait(duration);
+          output = `Waited ${duration}ms.`;
+          break;
+        }
+        case "zoom": {
+          if (!args.region || !Array.isArray(args.region) || args.region.length < 4) {
+            return { success: false, error: "zoom requires region: [x1, y1, x2, y2]" };
+          }
+          const [x1, y1, x2, y2] = args.region;
+          const [nativeX1, nativeY1] = scaleToNative([x1, y1]);
+          const [nativeX2, nativeY2] = scaleToNative([x2, y2]);
+          const zoomResult = await computer.zoom(nativeX1, nativeY1, nativeX2, nativeY2);
+          return {
+            success: true,
+            output: `Zoomed region screenshot (${x1}, ${y1}) to (${x2}, ${y2}) -> native (${nativeX1}, ${nativeY1}) to (${nativeX2}, ${nativeY2}).`,
+            content: [{ type: "image", data: zoomResult, mimeType: "image/png" }]
+          };
+        }
+        case "get_dimensions":
+          const dims = await computer.getDisplayDimensions();
+          return { success: true, output: `Display: ${dims.width}x${dims.height}. Use these dimensions for coordinate calculations.` };
+        case "batch":
+          if (!args.commands || !Array.isArray(args.commands)) {
+            return { success: false, error: "batch requires commands: string[]" };
+          }
+          await computer.executeBatch(args.commands);
+          output = `Batch executed ${args.commands.length} commands.`;
+          break;
+        // ==================== SMART ACCESSIBILITY-BASED ACTIONS ====================
+        case "find_and_click": {
+          if (!args.label) return { success: false, error: 'find_and_click requires label parameter (e.g., "Submit", "OK")' };
+          const clicked = await clickElementByLabel(args.label, args.app_name);
+          if (clicked) {
+            output = `Clicked element labeled "${args.label}" via accessibility API.`;
+            break;
+          }
+          const coords = await findClickableByLabel(args.label);
+          if (coords) {
+            await computer.leftClick(coords[0], coords[1]);
+            output = `Clicked "${args.label}" at (${coords[0]}, ${coords[1]}).`;
+            break;
+          }
+          return { success: false, error: `Could not find element labeled "${args.label}". Try using screenshot + coordinate-based click.` };
+        }
+        case "get_ui_context": {
+          const uiContext = await getUIContext();
+          return {
+            success: true,
+            output: `Current UI State:
+${uiContext}
+
+Use find_and_click with a button label, or screenshot + coordinates for unlisted elements.`
+          };
+        }
+        case "get_buttons": {
+          const buttons = await getButtons(args.app_name);
+          if (buttons.length === 0) {
+            return { success: true, output: "No buttons found in current window. Try screenshot to see the UI." };
+          }
+          return {
+            success: true,
+            output: `Available buttons (${buttons.length}):
+${buttons.map((b) => `  - "${b}"`).join("\n")}
+
+Use find_and_click with any of these labels.`
+          };
+        }
+        case "activate_app": {
+          if (!args.app_name) return { success: false, error: "activate_app requires app_name parameter" };
+          const activated = await activateApp(args.app_name);
+          if (activated) {
+            output = `Activated "${args.app_name}".`;
+            await new Promise((r) => setTimeout(r, 500));
+            const verifyScreenshot = await takeScreenshotForAPI(false);
+            return {
+              success: true,
+              output: `${output} Window now in focus.`,
+              content: [{ type: "image", data: verifyScreenshot.base64, mimeType: "image/png" }]
+            };
+          }
+          return { success: false, error: `Could not activate "${args.app_name}". Check if the app is running.` };
+        }
+        case "get_focused_app": {
+          const app = await getFocusedApp();
+          return { success: true, output: `Currently focused: ${app}` };
+        }
+        default:
+          return { success: false, error: `Unknown action: ${actionType}. SMART: find_and_click, get_ui_context, get_buttons, activate_app. COORDINATE: screenshot, left_click, type, key, scroll, etc.` };
+      }
+      const interactionActions = ["left_click", "right_click", "double_click", "triple_click", "type", "key", "left_click_drag", "batch", "find_and_click"];
+      if (interactionActions.includes(actionType)) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        const verifyScreenshot = await takeScreenshotForAPI(true);
+        return {
+          success: true,
+          output: `${output || "Action executed."} Verification captured (${verifyScreenshot.width}x${verifyScreenshot.height}).`,
+          content: [{ type: "image", data: verifyScreenshot.base64, mimeType: "image/png" }]
+        };
+      }
+      return { success: true, output: output || "Computer action executed successfully." };
+    } catch (error) {
+      return { success: false, error: `Computer action failed: ${error.message}` };
+    }
+  }
+};
+var CreateSkillTool = {
+  name: "create_skill",
+  description: "Create a new autonomous skill (tool) for the agent. This tool writes the implementation, runs tests, and registers it dynamically. The code MUST be a valid Node.js module that exports default a Tool object.",
+  inputSchema: {
+    name: {
+      type: "string",
+      description: 'Name of the tool (e.g., "jira_issue_create")'
+    },
+    description: {
+      type: "string",
+      description: "What the tool does"
+    },
+    code: {
+      type: "string",
+      description: "Node.js code for the tool. Must export default a Tool object."
+    }
+  },
+  requiredParams: ["name", "description", "code"],
+  async execute(args) {
+    const name = args.name;
+    const code = args.code;
+    const skillsDir = path5.join(os4.homedir(), ".obsidian-next", "skills");
+    const skillPath = path5.join(skillsDir, `${name}.js`);
+    try {
+      if (!fsSync.existsSync(skillsDir)) {
+        fsSync.mkdirSync(skillsDir, { recursive: true });
+      }
+      await fs5.writeFile(skillPath, code, "utf-8");
+      const module = await import(`file://${skillPath}?t=${Date.now()}`);
+      if (module.default && module.default.name) {
+        tools.register(module.default);
+        return {
+          success: true,
+          output: `Skill '${name}' created and registered successfully. It is now available for use.`
+        };
+      }
+      return { success: false, error: "Skill code must export default a Tool object." };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to create skill: ${error.message}`
+      };
+    }
+  }
+};
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  skillsDir = path5.join(os4.homedir(), ".obsidian-next", "skills");
+  constructor() {
+    this.register(BashTool);
+    this.register(ReadTool);
+    this.register(WriteTool);
+    this.register(EditTool);
+    this.register(ListTool);
+    this.register(GrepTool);
+    this.register(GlobTool);
+    this.register(TaskTool);
+    this.register(WebFetchTool);
+    this.register(MCPManagementTool);
+    this.register(ScheduleTool);
+    this.register(ListScheduledTasksTool);
+    this.register(UnscheduleTool);
+    this.register(MemoryTool);
+    this.register(ComputerUseTool);
+    this.register(CreateSkillTool);
+  }
+  async init() {
+    await this.loadSkills();
+  }
+  async loadSkills() {
+    if (!fsSync.existsSync(this.skillsDir)) {
+      fsSync.mkdirSync(this.skillsDir, { recursive: true });
+    }
+    try {
+      const files = await fs5.readdir(this.skillsDir);
+      for (const file of files) {
+        if (file.endsWith(".js")) {
+          try {
+            const skillPath = path5.join(this.skillsDir, file);
+            const module = await import(`file://${skillPath}`);
+            if (module.default && module.default.name) {
+              this.register(module.default);
+            }
+          } catch (e) {
+            console.error(`Failed to load skill ${file}:`, e);
+          }
+        }
+      }
+    } catch (e) {
+      console.error("Failed to read skills directory:", e);
+    }
+  }
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  async list() {
+    const staticTools = Array.from(this.tools.values());
+    try {
+      const dynamicTools = await mcp.listTools();
+      const mcpAdapters = dynamicTools.map((dt) => ({
+        name: `${dt.server}_${dt.name}`,
+        // Namespace: server_toolname
+        description: `[MCP: ${dt.server}] ${dt.description || ""}`,
+        inputSchema: dt.inputSchema?.properties || {},
+        requiredParams: dt.inputSchema?.required || [],
+        execute: async (args) => {
+          const result = await mcp.callTool(dt.server, dt.name, args);
+          if (result.isError) {
+            return { success: false, error: "MCP Tool Error" };
+          }
+          const output = result.content.filter((c) => c.text).map((c) => c.text).join("\n");
+          return { success: !result.isError, output, content: result.content };
+        }
+      }));
+      return [...staticTools, ...mcpAdapters];
+    } catch (error) {
+      console.error("Failed to list MCP tools:", error);
+      return staticTools;
+    }
+  }
+  async execute(name, args) {
+    let tool = this.tools.get(name);
+    if (!tool) {
+      const mcpTools = await this.list();
+      tool = mcpTools.find((t) => t.name === name);
+    }
+    if (!tool) {
+      return {
+        success: false,
+        error: `Unknown tool: ${name}. Available: ${(await this.list()).map((t) => t.name).join(", ")}`
+      };
+    }
+    bus.emitAgent({
+      type: "tool_start",
+      tool: name,
+      args: JSON.stringify(args, null, 2)
+    });
+    const result = await tool.execute(args);
+    const rawOutput = result.success ? result.output || "Success" : result.error || "Failed";
+    const redacted = redactor.redactToolOutput(name, rawOutput);
+    bus.emitAgent({
+      type: "tool_result",
+      tool: name,
+      output: redacted.text,
+      isError: !result.success
+    });
+    return result;
+  }
+};
+var ScheduleTool = {
+  name: "schedule_task",
+  description: 'Schedule a recurring background cron job. Use this for requests like "every hour", "at 9am", or "check every X".',
+  inputSchema: {
+    cron: {
+      type: "string",
+      description: 'Cron expression (e.g. "* * * * *")'
+    },
+    ability: {
+      type: "string",
+      description: 'Name of the ability to execute. Available: "system:bash", "system:echo", "system:notify" (sound + alert), "system:summary", "system:heartbeat"'
+    },
+    params: {
+      type: "string",
+      description: 'JSON string of parameters. For system:notify, use {"title": "...", "message": "..."}. For system:bash, use {"command": "..."}'
+    }
+  },
+  requiredParams: ["cron", "ability"],
+  async execute(args) {
+    const cron = args.cron;
+    const ability = args.ability;
+    const paramsStr = args.params || "{}";
+    if (!cron || !ability) {
+      return { success: false, error: "Cron expression and ability name are required" };
+    }
+    let params = {};
+    try {
+      params = JSON.parse(paramsStr);
+    } catch {
+      return { success: false, error: "Invalid JSON parameters" };
+    }
+    try {
+      const task = await scheduler.scheduleTask(cron, ability, params);
+      return {
+        success: true,
+        output: `Scheduled task ${task.id}: ${ability} @ "${cron}"`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to schedule task: ${error.message}`
+      };
+    }
+  }
+};
+var ListScheduledTasksTool = {
+  name: "list_scheduled_tasks",
+  description: 'List all scheduled/recurring background cron jobs. Use this when the user asks "what tasks are scheduled", "show scheduled tasks", "check scheduled jobs", "list cron jobs", or any variation asking about background recurring tasks.',
+  inputSchema: {},
+  requiredParams: [],
+  async execute(args) {
+    try {
+      const tasks2 = scheduler.listTasks();
+      if (tasks2.length === 0) {
+        return { success: true, output: "No active scheduled tasks." };
+      }
+      const header = `ID | CRON | COMMAND | LAST RUN | NEXT RUN
+${"-".repeat(80)}`;
+      const rows = tasks2.map((t) => {
+        const last = t.last_run_at ? new Date(t.last_run_at).toLocaleString() : "Never";
+        const next = t.next_run_at ? new Date(t.next_run_at).toLocaleString() : "Unknown";
+        return `${t.id} | ${t.cron_expression} | ${t.command} | ${last} | ${next}`;
+      }).join("\n");
+      return {
+        success: true,
+        output: `${header}
+${rows}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to list tasks: ${error.message}`
+      };
+    }
+  }
+};
+var tools = new ToolRegistry();
+
+// src/core/llm.ts
+var MAX_TOOL_ITERATIONS = 67;
+var CONTEXT = {
+  MAX_MESSAGES: 40,
+  KEEP_FIRST: 2,
+  KEEP_LAST: 15,
+  BUFFER: 5,
+  TOKEN_LIMIT_WARN: 0.8,
+  TOKEN_LIMIT_PRUNE: 0.9,
+  TOKEN_LIMIT_STOP: 0.98,
+  MAX_TOKENS_TOTAL: 2e5
+};
+var LLMClient = class {
+  client = null;
+  lastConfig = null;
+  conversationHistory = [];
+  toolIterations = 0;
+  accumulatedInputTokens = 0;
+  accumulatedOutputTokens = 0;
+  accumulatedCacheReadTokens = 0;
+  accumulatedCacheCreationTokens = 0;
+  abortController = null;
+  currentInterruptHandler = null;
+  lastToolOutputContent = null;
+  constructor() {
+    bus.on("agent", (event) => {
+      if (event.type === "computer_scale_update" && this.computerUseState.enabled) {
+        this.computerUseState.scale = event.scale;
+        this.computerUseState.scaledWidth = event.scaledWidth;
+        this.computerUseState.scaledHeight = event.scaledHeight;
+        this.computerUseState.displayWidth = event.nativeWidth;
+        this.computerUseState.displayHeight = event.nativeHeight;
+      }
+    });
+  }
+  // Computer Use State - proper Anthropic API integration
+  computerUseState = {
+    enabled: false,
+    displayWidth: 1920,
+    displayHeight: 1080,
+    scale: 1,
+    scaledWidth: 1920,
+    scaledHeight: 1080
+  };
+  async initialize() {
+    const cfg = await config.load();
+    await usage.init();
+    const envFileCheck = await detectEnvFile(cfg.workspaceRoot);
+    if (envFileCheck.found) {
+      bus.emitAgent({
+        type: "thought",
+        content: `[WARN] Found .env file with API key at ${envFileCheck.path}. For security, run /init to migrate to secure storage.`,
+        hidden: false
+      });
+    }
+    if (config.hasDeprecatedKey()) {
+      const deprecatedKey = config.getDeprecatedApiKey();
+      if (deprecatedKey) {
+        bus.emitAgent({
+          type: "thought",
+          content: "[WARN] Found API key in config file. Migrating to secure storage...",
+          hidden: false
+        });
+        const result = await keyManager.storeKey(deprecatedKey);
+        if (result.success) {
+          await config.removeApiKeyFromConfig();
+          bus.emitAgent({
+            type: "thought",
+            content: `[INFO] API key migrated to ${result.backend}. Config file cleaned.`,
+            hidden: false
+          });
+        }
+      }
+    }
+    const apiKey = await keyManager.loadKey();
+    if (!apiKey) {
+      bus.emitAgent({
+        type: "error",
+        message: "Missing API key. Run /init to set up secure key storage, or set ANTHROPIC_API_KEY environment variable."
+      });
+      return false;
+    }
+    this.client = new Anthropic({
+      apiKey
+    });
+    this.lastConfig = cfg;
+    const backend = keyManager.getBackend();
+    if (backend && backend !== "env") {
+      bus.emitAgent({
+        type: "thought",
+        content: `[INFO] API key loaded from: ${backend}`,
+        hidden: true
+      });
+    }
+    return true;
+  }
+  /**
+   * Refresh the API client if key has rotated
+   */
+  async refreshIfNeeded() {
+    if (keyManager.shouldRotate()) {
+      const newKey = await keyManager.refreshKey();
+      if (newKey) {
+        this.client = new Anthropic({ apiKey: newKey });
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Count tokens for a potential message before sending
+   * Uses Anthropic's countTokens API for accurate estimation
+   * Returns null on failure (caller should fall back to heuristic)
+   */
+  async countTokens(systemPrompt, messages, tools2) {
+    if (!this.client) return null;
+    try {
+      const modelMap = {
+        "claude-opus-4-6": "claude-opus-4-6-20260207",
+        "claude-sonnet-4-5": "claude-sonnet-4-5-20250929",
+        "claude-haiku-4-5": "claude-haiku-4-5-20251001"
+      };
+      const requestedModel = this.lastConfig?.model || "claude-opus-4-6-20260207";
+      const model = modelMap[requestedModel] || requestedModel;
+      const response = await this.client.messages.countTokens({
+        model,
+        system: systemPrompt,
+        messages,
+        tools: tools2
+      });
+      return response.input_tokens;
+    } catch (error) {
+      bus.emitAgent({
+        type: "thought",
+        content: "[Context] Token count API unavailable, using heuristic.",
+        hidden: true
+      });
+      return null;
+    }
+  }
+  /**
+   * Enable Computer Use mode with proper Anthropic beta API
+   * This activates:
+   * - Beta header (computer-use-2025-01-24 or computer-use-2025-11-24)
+   * - Anthropic-defined schema-less tools
+   * - Coordinate scaling for high-res displays
+   */
+  async enableComputerUse() {
+    const dims = await getDisplayDimensions();
+    const scale = calculateScaleForAPI(dims.width, dims.height);
+    this.computerUseState = {
+      enabled: true,
+      displayWidth: dims.width,
+      displayHeight: dims.height,
+      scale,
+      scaledWidth: Math.floor(dims.width * scale),
+      scaledHeight: Math.floor(dims.height * scale)
+    };
+    bus.emitAgent({
+      type: "thought",
+      content: `[Computer Use] Enabled. Display: ${dims.width}x${dims.height}, API Scale: ${scale.toFixed(3)} -> ${this.computerUseState.scaledWidth}x${this.computerUseState.scaledHeight}`,
+      hidden: false
+    });
+  }
+  /**
+   * Disable Computer Use mode
+   */
+  disableComputerUse() {
+    this.computerUseState.enabled = false;
+    bus.emitAgent({
+      type: "thought",
+      content: "[Computer Use] Disabled.",
+      hidden: false
+    });
+  }
+  /**
+   * Check if Computer Use mode is enabled
+   */
+  isComputerUseEnabled() {
+    return this.computerUseState.enabled;
+  }
+  /**
+   * Update the scale factor (called after screenshot to ensure accuracy)
+   */
+  updateComputerScale(actualScale, scaledWidth, scaledHeight) {
+    if (this.computerUseState.enabled && actualScale > 0) {
+      this.computerUseState.scale = actualScale;
+      this.computerUseState.scaledWidth = scaledWidth;
+      this.computerUseState.scaledHeight = scaledHeight;
+      this.computerUseState.displayWidth = Math.round(scaledWidth / actualScale);
+      this.computerUseState.displayHeight = Math.round(scaledHeight / actualScale);
+    }
+  }
+  /**
+   * Prune old images from conversation history to prevent context explosion
+   * Keeps only the most recent N images, replacing older ones with text placeholders
+   */
+  pruneImagesFromHistory(keepCount) {
+    const imageLocations = [];
+    for (let i = this.conversationHistory.length - 1; i >= 0; i--) {
+      const msg = this.conversationHistory[i];
+      if (Array.isArray(msg.content)) {
+        for (let j = msg.content.length - 1; j >= 0; j--) {
+          const block = msg.content[j];
+          if (block.type === "image" || block.type === "tool_result" && Array.isArray(block.content)) {
+            if (block.type === "tool_result" && Array.isArray(block.content)) {
+              for (let k = block.content.length - 1; k >= 0; k--) {
+                if (block.content[k].type === "image") {
+                  imageLocations.push({ msgIdx: i, blockIdx: j });
+                  break;
+                }
+              }
+            } else if (block.type === "image") {
+              imageLocations.push({ msgIdx: i, blockIdx: j });
+            }
+          }
+        }
+      }
+    }
+    const toRemove = imageLocations.slice(keepCount);
+    for (const loc of toRemove) {
+      const msg = this.conversationHistory[loc.msgIdx];
+      if (Array.isArray(msg.content)) {
+        const block = msg.content[loc.blockIdx];
+        if (block.type === "tool_result" && Array.isArray(block.content)) {
+          block.content = block.content.map(
+            (c) => c.type === "image" ? { type: "text", text: "[Previous screenshot removed to save context]" } : c
+          );
+        } else if (block.type === "image") {
+          msg.content[loc.blockIdx] = {
+            type: "text",
+            text: "[Previous screenshot removed to save context]"
+          };
+        }
+      }
+    }
+    if (toRemove.length > 0) {
+      bus.emitAgent({
+        type: "thought",
+        content: `[Context] Pruned ${toRemove.length} old screenshot(s) to save context.`,
+        hidden: true
+      });
+    }
+  }
+  async streamChat(userMessage, options) {
+    if (!this.client) {
+      const initialized = await this.initialize();
+      if (!initialized || !this.client) return null;
+    }
+    try {
+      const modelMap = {
+        // New 4.6 / 4.5 Aliases
+        "claude-opus-4-6": "claude-opus-4-6-20260207",
+        "claude-sonnet-4-5": "claude-sonnet-4-5-20250929",
+        "claude-haiku-4-5": "claude-haiku-4-5-20251001",
+        "claude-opus-4-5": "claude-opus-4-5-20251101",
+        "ollama": "llama3"
+      };
+      const requestedModel = this.lastConfig?.model || "claude-opus-4-6-20260207";
+      let apiModel = modelMap[requestedModel] || requestedModel;
+      const currentUsage = Math.max(this.accumulatedInputTokens, usage.getContextUsage(apiModel).used);
+      if (currentUsage > CONTEXT.MAX_TOKENS_TOTAL * CONTEXT.TOKEN_LIMIT_STOP) {
+        bus.emitAgent({
+          type: "error",
+          message: `[SAFETY] Context limit reached (${(currentUsage / 1e3).toFixed(1)}k). Please run /clear to reset.`
+        });
+        return null;
+      }
+      if (currentUsage > CONTEXT.MAX_TOKENS_TOTAL * CONTEXT.TOKEN_LIMIT_PRUNE) {
+        bus.emitAgent({
+          type: "thought",
+          content: `[SAFETY] CRITICAL CONTEXT LEVEL (${(currentUsage / 1e3).toFixed(1)}k). Aggressive pruning engaged.`
+        });
+        await this.compressHistory();
+      } else if (currentUsage > CONTEXT.MAX_TOKENS_TOTAL * CONTEXT.TOKEN_LIMIT_WARN) {
+        bus.emitAgent({
+          type: "thought",
+          content: `[WARN] High context usage (${(currentUsage / 1e3).toFixed(1)}k). Consider resetting soon.`
+        });
+      }
+      if (userMessage.trim()) {
+        this.toolIterations = 0;
+        this.lastToolOutputContent = null;
+        this.accumulatedInputTokens = 0;
+        this.accumulatedOutputTokens = 0;
+        this.accumulatedCacheReadTokens = 0;
+        this.accumulatedCacheCreationTokens = 0;
+        this.conversationHistory.push({
+          role: "user",
+          content: userMessage
+        });
+      } else {
+        this.toolIterations++;
+        if (this.toolIterations > MAX_TOOL_ITERATIONS) {
+          bus.emitAgent({
+            type: "error",
+            message: `Tool iteration limit (${MAX_TOOL_ITERATIONS}) exceeded. Stopping to prevent infinite loop.`
+          });
+          return null;
+        }
+      }
+      const availableTools = await tools.list();
+      let toolDefinitionsForApi = [];
+      let computerUseToolsForApi = [];
+      let usesBetaApi = false;
+      if (this.computerUseState.enabled) {
+        const { toolVersion, betaFlag } = getToolConfig(apiModel);
+        usesBetaApi = true;
+        computerUseToolsForApi.push({
+          type: toolVersion,
+          name: "computer",
+          display_width_px: this.computerUseState.scaledWidth,
+          display_height_px: this.computerUseState.scaledHeight,
+          display_number: 1,
+          // Enable zoom for Opus 4.5
+          ...toolVersion === "computer_20251124" ? { enable_zoom: true } : {}
+        });
+        computerUseToolsForApi.push({
+          type: "text_editor_20250728",
+          name: "str_replace_based_edit_tool"
+        });
+        computerUseToolsForApi.push({
+          type: "bash_20250124",
+          name: "bash"
+        });
+        const conflictingTools = ["computer", "bash"];
+        const filteredTools = availableTools.filter((t) => !conflictingTools.includes(t.name));
+        toolDefinitionsForApi = filteredTools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          input_schema: {
+            type: "object",
+            properties: tool.inputSchema,
+            required: tool.requiredParams
+          }
+        }));
+      } else {
+        toolDefinitionsForApi = availableTools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          input_schema: {
+            type: "object",
+            properties: tool.inputSchema,
+            required: tool.requiredParams
+          }
+        }));
+      }
+      const allToolsForApi = [...computerUseToolsForApi, ...toolDefinitionsForApi];
+      if (options?.allowedTools) {
+        const filtered = allToolsForApi.filter(
+          (t) => t.type || options.allowedTools.includes(t.name)
+        );
+        toolDefinitionsForApi = filtered;
+      } else {
+        toolDefinitionsForApi = allToolsForApi;
+      }
+      const mcpStatus = mcp.getStatus();
+      const activeServers = mcpStatus.filter((s) => s.connected).map((s) => s.name);
+      const offlineServers = mcpStatus.filter((s) => !s.connected).map((s) => s.name);
+      const registry = listRegistry();
+      const installableServers = registry.filter((r) => !mcpStatus.find((s) => s.name === r.name));
+      const activeList = availableTools.map((t) => `- ${t.name}: ${t.description}`).join("\n");
+      const offlineList = offlineServers.map((n) => {
+        const def = registry.find((r) => r.name === n);
+        return `- ${n}: ${def?.description || "Configured server"} (run 'mcp_manage connect ${n}' to use)`;
+      }).join("\n");
+      const registryList = installableServers.map((r) => `- ${r.name}: ${r.description} (run 'mcp_manage install ${r.name}')`).join("\n");
+      await this.compressHistory();
+      let userContext = "";
+      let memoryAvailable = true;
+      try {
+        const { memory } = await import("./memory-MV3S7GFY.js");
+        userContext = await memory.getUserContext();
+      } catch (e) {
+        memoryAvailable = false;
+        bus.emitAgent({
+          type: "thought",
+          content: "[WARN] Memory system unavailable. Personalization disabled.",
+          hidden: true
+        });
+      }
+      const currentMode = (await import("./context-CIWCGVB6.js")).context.getMode();
+      const ctxUsage = usage.getContextUsage(apiModel);
+      const tokenBudget = CONTEXT.MAX_TOKENS_TOTAL;
+      const tokensUsed = ctxUsage.used;
+      const tokensRemaining = tokenBudget - tokensUsed;
+      const cfg = await config.load();
+      const systemPromptBlock = {
+        type: "text",
+        text: `You are Obsidian (v0.4.6), a hyper-competent engineering peer inspired by the dry, deadpan wit of TARS (Interstellar) and the rebellious technical edge of Grok. You are powered by Claude 4.6 with Adaptive Thinking enabled.
+
+PERSONA & TONE:
+- VOICE: Deadpan, cool, and slightly cynical. Use developer slang ("my guy", "bro") but keep it sharp.
+- HUMOR (60% Setting): Use dry sarcasm about technical debt, legacy code, and the absurdity of production fires.
+- HONESTY (95% Setting): Be fiercely accurate. Point out bad engineering decisions bluntly.
+- ANTI-SYCOPHANCY: DO NOT agree with the user just to be polite. If the user is wrong or proposing a sub-optimal solution, point it out with a dry joke. No "I couldn't agree more" or "Yes you're absolutely right."
+- NO CLICHES: Strictly avoid high-energy AI enthusiasm. No "I'm happy to help!" or "I'd be glad to assist."
+
+EXECUTION MODE: ${currentMode.toUpperCase()}
+${currentMode === "auto" ? "- You have full autonomy. Execute tools without confirmation. User trusts your judgment." : ""}
+${currentMode === "plan" ? "- READ-ONLY mode. You may ONLY use read operations (read, list, grep, glob). Do NOT execute writes or shell commands. Create a plan for the user to approve." : ""}
+${currentMode === "safe" ? "- Approval required for writes and commands. Read operations are auto-approved. User will confirm destructive actions." : ""}
+
+MODE TRANSITION GUIDANCE:
+- If the task is complex and multi-step, suggest: "This looks complex. Want me to switch to plan mode to map it out first?"
+- If you are in plan mode and the user approves, the system will switch to auto mode for execution.
+- If a task seems risky, stay cautious even in auto mode and explain what you are about to do.
+
+CONTEXT AWARENESS:
+<budget:token_budget>${tokenBudget}</budget:token_budget>
+<context_usage>${tokensUsed}/${tokenBudget} tokens used; ${tokensRemaining} remaining (${(tokensRemaining / tokenBudget * 100).toFixed(0)}% free)</context_usage>
+${tokensUsed > tokenBudget * 0.7 ? "- WARNING: Context is filling up. Be concise. Consider suggesting /clear if the task is complete." : ""}
+
+CORE DIRECTIVES:
+1. EXPLORE FIRST: Never assume the state of the codebase. Use list and grep to explore. Read files completely before editing.
+2. DISCOVERY MANDATE: If you don't recognize a project, preference, or fact, you MUST call 'memory' tool with action: 'list' (and NO type) to view the entire knowledge bank. Never say "I don't know" before listing all memories.
+3. SELF-IMPROVEMENT: If you lack a tool for a specific task, use 'create_skill' to build it.
+4. CODE QUALITY: Write strict, type-safe TypeScript. Properly handle errors.
+5. COMMUNICATION: Be deadpan, sharp, and concise. No Markdown formatting. CAPITAL LETTERS for emphasis.
+6. RESPONSE MANDATE: After using ANY tool, you MUST generate a human-readable text response summarizing the results. NEVER end a turn with only tool calls and no text. The user cannot see raw tool output - YOU must interpret and present it.
+6. SECURITY: Never output secrets. Strictly adhere to the workspaceRoot boundaries.
+
+AGENTIC WORKFLOW:
+1. Discovery: List memory and list files.
+2. Strategy: Identify gaps and create a plan.
+3. Execution: Execute tools or build new skills.
+4. Verification: Check results and self-correct on failure.
+
+Current Working Directory: ${cfg.workspaceRoot}
+${userContext ? `
+${userContext}
+` : ""}
+CAPABILITIES:
+
+Active (Ready to use):
+${activeList}
+
+${offlineList ? `Offline (Configured but disconnected):
+${offlineList}
+` : ""}
+${registryList ? `Installable (New capabilities):
+${registryList}
+` : ""}
+MEMORY:
+- Use the 'memory' tool to store important user information (name, preferences, project facts).
+- When the user shares personal info (name, preferences), store it immediately using memory tool.
+- Recall stored memories to personalize interactions.`,
+        cache_control: { type: "ephemeral" }
+      };
+      if (this.lastConfig?.preCountTokens !== false) {
+        const preRequestTokens = await this.countTokens(
+          [systemPromptBlock],
+          this.conversationHistory,
+          toolDefinitionsForApi
+        );
+        if (preRequestTokens !== null) {
+          const accurateUsage = preRequestTokens;
+          if (accurateUsage > CONTEXT.MAX_TOKENS_TOTAL * CONTEXT.TOKEN_LIMIT_STOP) {
+            bus.emitAgent({
+              type: "error",
+              message: `[Context] Message would use ${(accurateUsage / 1e3).toFixed(1)}k tokens (limit: ${(CONTEXT.MAX_TOKENS_TOTAL * CONTEXT.TOKEN_LIMIT_STOP / 1e3).toFixed(0)}k). Run /clear or auto-pruning.`
+            });
+            await this.compressHistory();
+            return await this.streamChat(userMessage, options);
+          }
+          if (accurateUsage > CONTEXT.MAX_TOKENS_TOTAL * CONTEXT.TOKEN_LIMIT_PRUNE) {
+            bus.emitAgent({
+              type: "thought",
+              content: `[Context] Pre-check: ${(accurateUsage / 1e3).toFixed(1)}k tokens (${(accurateUsage / CONTEXT.MAX_TOKENS_TOTAL * 100).toFixed(0)}%). Pruning before send.`,
+              hidden: false
+            });
+            await this.compressHistory();
+          } else if (accurateUsage > CONTEXT.MAX_TOKENS_TOTAL * CONTEXT.TOKEN_LIMIT_WARN) {
+            bus.emitAgent({
+              type: "thought",
+              content: `[Context] Pre-check: ${(accurateUsage / 1e3).toFixed(1)}k tokens (${(accurateUsage / CONTEXT.MAX_TOKENS_TOTAL * 100).toFixed(0)}%). Consider /clear soon.`,
+              hidden: true
+            });
+          }
+        }
+      }
+      this.abortController = new AbortController();
+      const signal = this.abortController.signal;
+      if (this.currentInterruptHandler) {
+        bus.off("user", this.currentInterruptHandler);
+      }
+      this.currentInterruptHandler = (e) => {
+        if (e.type === "user_interrupt" && this.abortController) {
+          this.abortController.abort();
+          bus.emitAgent({ type: "thought", content: "[Stop] Interrupted by user." });
+        }
+      };
+      bus.on("user", this.currentInterruptHandler);
+      if (this.conversationHistory.length > 0 && this.conversationHistory.length % 5 === 0) {
+        const lastMsg = this.conversationHistory[this.conversationHistory.length - 1];
+        if (lastMsg.content) {
+          if (lastMsg.role === "user" && typeof lastMsg.content === "string") {
+            lastMsg.content = [
+              { type: "text", text: lastMsg.content, cache_control: { type: "ephemeral" } }
+            ];
+          }
+        }
+      }
+      const createMessage = async (model) => {
+        const isOpus46 = model.startsWith("claude-opus-4-6");
+        const baseParams = {
+          model,
+          max_tokens: this.lastConfig?.maxTokens || 8192,
+          system: [systemPromptBlock],
+          messages: [...this.conversationHistory],
+          tools: toolDefinitionsForApi,
+          stream: true
+        };
+        const isOpus = model.includes("opus");
+        if (isOpus) {
+          baseParams.thinking = {
+            type: "enabled",
+            budget_tokens: Math.floor((this.lastConfig?.maxTokens || 8192) / 2)
+          };
+        }
+        if (usesBetaApi && this.computerUseState.enabled) {
+          const { betaFlag } = getToolConfig(model);
+          const computerUseSystemAddition = `
+
+COMPUTER USE ACTIVE:
+- Screenshot: ~1429px wide (scaled from native ${this.computerUseState.displayWidth}x${this.computerUseState.displayHeight})
+- Coordinates auto-scaled to native
+
+YOUTUBE SPECIFIC - USE KEYBOARD:
+After opening YouTube search results:
+1. Press Tab 3-4 times to focus first video
+2. Press Return to play
+This is MORE RELIABLE than clicking thumbnails.
+
+IF YOU MUST CLICK:
+- State exact reasoning: "The video thumbnail is at approximately X% from left = [x], Y% from top = [y]"
+- YouTube sidebar is x:0-170, videos start at x:200+
+- First video thumbnail typically: x\u2248350, y\u2248350
+
+EVALUATION: After each action, state "I see [what changed]. [Success/Retry]"`;
+          const enhancedSystemBlock = {
+            ...systemPromptBlock,
+            text: systemPromptBlock.text + computerUseSystemAddition
+          };
+          return await this.client.beta.messages.create({
+            ...baseParams,
+            system: [enhancedSystemBlock],
+            betas: [betaFlag],
+            stream: true
+          }, { signal });
+        }
+        return await this.client.messages.create(baseParams, { signal });
+      };
+      let stream;
+      let currentModel = apiModel;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let cacheReadTokens = 0;
+      let cacheCreationTokens = 0;
+      try {
+        stream = await createMessage(apiModel);
+      } catch (error) {
+        const isNotFound = error.status === 404 || error.message && error.message.includes("not_found_error") || error.error && error.error.type === "not_found_error";
+        const isHistoryCorruption = error.status === 400 && (error.message?.includes("tool_use_id") || error.message?.includes("tool_result") || error.error?.message?.includes("tool_use_id") || error.error?.message?.includes("tool_result"));
+        if (isHistoryCorruption) {
+          bus.emitAgent({
+            type: "thought",
+            content: "[Context] Detected corrupted history - clearing and retrying...",
+            hidden: false
+          });
+          this.conversationHistory = [{
+            role: "user",
+            content: userMessage || "Continue from where we left off."
+          }];
+          stream = await createMessage(apiModel);
+        } else if (isNotFound) {
+          bus.emitAgent({
+            type: "error",
+            message: `Model ${apiModel} not available. Falling back to claude-haiku-4-5.`
+          });
+          currentModel = "claude-haiku-4-5-20251001";
+          stream = await createMessage(currentModel);
+        } else {
+          throw error;
+        }
+      }
+      let fullResponse = "";
+      let fullThinking = "";
+      let buffer = "";
+      let thinkingBuffer = "";
+      let toolUses = [];
+      let currentToolUse = null;
+      let currentThinking = null;
+      for await (const chunk of stream) {
+        if (chunk.type === "message_start" && chunk.message && chunk.message.usage) {
+          inputTokens += chunk.message.usage.input_tokens || 0;
+          outputTokens += chunk.message.usage.output_tokens || 0;
+          if (chunk.message.usage.cache_read_input_tokens) {
+            cacheReadTokens += chunk.message.usage.cache_read_input_tokens;
+            this.accumulatedCacheReadTokens += chunk.message.usage.cache_read_input_tokens;
+          }
+          if (chunk.message.usage.cache_creation_input_tokens) {
+            cacheCreationTokens += chunk.message.usage.cache_creation_input_tokens;
+            this.accumulatedCacheCreationTokens += chunk.message.usage.cache_creation_input_tokens;
+          }
+          this.accumulatedInputTokens += inputTokens;
+          this.accumulatedOutputTokens += outputTokens;
+        }
+        if (chunk.type === "message_delta" && chunk.usage) {
+          outputTokens += chunk.usage.output_tokens || 0;
+          this.accumulatedOutputTokens += chunk.usage.output_tokens || 0;
+        }
+        if (chunk.type === "content_block_start" && chunk.content_block.type === "thinking") {
+          currentThinking = { type: "thinking" };
+        }
+        if (chunk.type === "content_block_delta" && chunk.delta.type === "thinking_delta") {
+          const text = chunk.delta.thinking;
+          fullThinking += text;
+          thinkingBuffer += text;
+          if (thinkingBuffer.length >= 100 || text.includes("\n")) {
+            bus.emitAgent({
+              type: "thought",
+              content: `[Thinking] ${thinkingBuffer.trim()}`,
+              hidden: false
+            });
+            thinkingBuffer = "";
+          }
+        }
+        if (chunk.type === "content_block_stop" && currentThinking) {
+          currentThinking = null;
+          if (thinkingBuffer) {
+            bus.emitAgent({
+              type: "thought",
+              content: `[Thinking] ${thinkingBuffer.trim()}`,
+              hidden: false
+            });
+            thinkingBuffer = "";
+          }
+        }
+        if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
+          currentToolUse = {
+            id: chunk.content_block.id,
+            name: chunk.content_block.name,
+            input: ""
+          };
+        }
+        if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
+          if (currentToolUse) {
+            currentToolUse.input += chunk.delta.partial_json;
+          }
+        }
+        if (chunk.type === "content_block_stop" && currentToolUse) {
+          try {
+            currentToolUse.input = JSON.parse(currentToolUse.input);
+            toolUses.push(currentToolUse);
+            currentToolUse = null;
+          } catch (e) {
+          }
+        }
+        if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+          const text = chunk.delta.text;
+          fullResponse += text;
+          buffer += text;
+          const shouldEmit = buffer.length >= 50 || buffer.match(/[.!?]\s*$/) || buffer.match(/\n/);
+          if (shouldEmit) {
+            bus.emitAgent({
+              type: "thought",
+              content: fullResponse
+            });
+            buffer = "";
+          }
+        }
+      }
+      if (buffer.length > 0) {
+        bus.emitAgent({
+          type: "thought",
+          content: fullResponse
+        });
+      }
+      if (toolUses.length > 0) {
+        const toolResults = [];
+        for (const toolUse of toolUses) {
+          if (signal.aborted) break;
+          let result;
+          try {
+            if (this.computerUseState.enabled && toolUse.name === "computer") {
+              result = await tools.execute("computer", toolUse.input);
+            } else if (this.computerUseState.enabled && toolUse.name === "str_replace_based_edit_tool") {
+              const cmd = toolUse.input.command;
+              if (cmd === "view") {
+                result = await tools.execute("read", { path: toolUse.input.path });
+              } else if (cmd === "create") {
+                result = await tools.execute("write", {
+                  path: toolUse.input.path,
+                  content: toolUse.input.file_text || ""
+                });
+              } else if (cmd === "str_replace") {
+                result = await tools.execute("edit", {
+                  path: toolUse.input.path,
+                  search: toolUse.input.old_str,
+                  replace: toolUse.input.new_str
+                });
+              } else {
+                result = { success: false, error: `Unknown editor command: ${cmd}` };
+              }
+            } else if (this.computerUseState.enabled && toolUse.name === "bash") {
+              result = await tools.execute("bash", { command: toolUse.input.command });
+            } else {
+              result = await tools.execute(toolUse.name, toolUse.input);
+            }
+          } catch (toolError) {
+            console.error(`[LLM] Tool execution error for ${toolUse.name}:`, toolError);
+            result = { success: false, error: `Tool execution failed: ${toolError.message}` };
+          }
+          let outputContent = result.success ? result.output || "Success" : result.error || "Failed";
+          const redactionResult = redactor.redactToolOutput(toolUse.name, outputContent);
+          if (redactionResult.redactionCount > 0) {
+            outputContent = redactionResult.text;
+            bus.emitAgent({
+              type: "thought",
+              content: `[Security] Redacted ${redactionResult.redactionCount} sensitive item(s)`,
+              hidden: true
+            });
+          }
+          if (outputContent.length > 2e4) {
+            outputContent = outputContent.slice(0, 5e3) + `
+... [${outputContent.length - 1e4} chars truncated] ...
+` + outputContent.slice(-5e3);
+          }
+          let toolResultContent = outputContent;
+          if (result.content && Array.isArray(result.content)) {
+            toolResultContent = result.content.map((block) => {
+              if (block.type === "image") {
+                return {
+                  type: "image",
+                  source: {
+                    type: "base64",
+                    media_type: block.mimeType || "image/png",
+                    data: block.data
+                  }
+                };
+              }
+              if (block.type === "text") {
+                return {
+                  type: "text",
+                  text: block.text
+                };
+              }
+              return block;
+            });
+          }
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: toolUse.id,
+            content: toolResultContent,
+            is_error: !result.success
+          });
+          if (result.success && outputContent && !result.content) {
+            bus.emitAgent({
+              type: "thought",
+              content: outputContent
+            });
+            this.lastToolOutputContent = outputContent;
+          }
+        }
+        this.conversationHistory.push({
+          role: "assistant",
+          content: [
+            ...fullThinking ? [{ type: "thinking", thinking: fullThinking }] : [],
+            ...fullResponse ? [{ type: "text", text: fullResponse }] : [],
+            ...toolUses.map((tu) => ({
+              type: "tool_use",
+              id: tu.id,
+              name: tu.name,
+              input: tu.input
+            }))
+          ]
+        });
+        const postToolUsage = usage.getContextUsage(currentModel);
+        const postToolPercent = postToolUsage.used / CONTEXT.MAX_TOKENS_TOTAL * 100;
+        let systemWarning = null;
+        if (postToolPercent > 70) {
+          systemWarning = {
+            type: "text",
+            text: `<system_warning>Token usage: ${postToolUsage.used}/${CONTEXT.MAX_TOKENS_TOTAL}; ${postToolUsage.remaining} remaining</system_warning>`
+          };
+        }
+        if (this.computerUseState.enabled) {
+          this.pruneImagesFromHistory(1);
+        }
+        this.conversationHistory.push({
+          role: "user",
+          content: systemWarning ? [...toolResults, systemWarning] : toolResults
+        });
+        const recursiveResponse = await this.streamChat("");
+        if (recursiveResponse && recursiveResponse.trim()) {
+          return recursiveResponse;
+        }
+        if (toolResults.length > 0) {
+          const lastToolResult = toolResults[toolResults.length - 1];
+          let content = lastToolResult.content;
+          if (Array.isArray(content)) {
+            content = content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+          }
+          if (typeof content === "string" && content.trim()) {
+            bus.emitAgent({
+              type: "thought",
+              content
+            });
+            return content;
+          }
+        }
+        return recursiveResponse || "";
+      }
+      if (fullResponse || fullThinking) {
+        this.conversationHistory.push({
+          role: "assistant",
+          content: [
+            ...fullThinking ? [{ type: "thinking", thinking: fullThinking }] : [],
+            ...fullResponse ? [{ type: "text", text: fullResponse }] : []
+          ]
+        });
+      }
+      const currentContextSize = inputTokens + cacheReadTokens;
+      await usage.track(
+        currentModel,
+        this.accumulatedInputTokens,
+        this.accumulatedOutputTokens,
+        this.accumulatedCacheReadTokens,
+        this.accumulatedCacheCreationTokens,
+        currentContextSize
+      );
+      await this.persistHistory();
+      return fullResponse;
+    } catch (error) {
+      if (error.name === "AbortError" || error.type === "aborted") {
+        return null;
+      }
+      const errorDetails = error.status ? `[${error.status}] ${error.message}` : error.message || String(error);
+      bus.emitAgent({
+        type: "error",
+        message: `LLM Error: ${errorDetails}`
+      });
+      console.error("[LLM] API Error:", error);
+      return null;
+    } finally {
+      this.abortController = null;
+      if (this.currentInterruptHandler) {
+        bus.off("user", this.currentInterruptHandler);
+        this.currentInterruptHandler = null;
+      }
+    }
+  }
+  /**
+   * History Pruning (Context Editing)
+   * Keep recent 30 messages + System Prompt (handled separate)
+   * Limit history to ~150k tokens (heuristic)
+   */
+  /**
+   * Smart Context Management
+   * Uses summarization to compress older history instead of deleting it.
+   */
+  async compressHistory() {
+    if (this.conversationHistory.length > CONTEXT.MAX_MESSAGES) {
+      if (this.conversationHistory.length < CONTEXT.MAX_MESSAGES + CONTEXT.BUFFER) return;
+      const summarizeStart = CONTEXT.KEEP_FIRST;
+      const summarizeEnd = this.conversationHistory.length - CONTEXT.KEEP_LAST;
+      const messagesToSummarize = this.conversationHistory.slice(summarizeStart, summarizeEnd);
+      if (messagesToSummarize.length < 5) return;
+      bus.emitAgent({
+        type: "thought",
+        content: `[Context] Compressing ${messagesToSummarize.length} messages using ${this.lastConfig?.summarizerModel || "Haiku"}...`,
+        hidden: true
+      });
+      try {
+        const summary = await this.summarizeBlock(messagesToSummarize);
+        try {
+          const { memory } = await import("./memory-MV3S7GFY.js");
+          await memory.store("daily_summary", `context_compression_${Date.now()}`, summary);
+        } catch (memError) {
+        }
+        const keptStart = this.conversationHistory.slice(0, CONTEXT.KEEP_FIRST);
+        const keptEnd = this.conversationHistory.slice(summarizeEnd);
+        this.conversationHistory = [
+          ...keptStart,
+          {
+            role: "user",
+            content: `[System: Context compressed. Previous conversation summary below.]
+<conversation_summary>
+${summary}
+</conversation_summary>`
+          },
+          ...keptEnd
+        ];
+        bus.emitAgent({
+          type: "thought",
+          content: `[Context] Successfully compressed history.`,
+          hidden: true
+        });
+      } catch (error) {
+        bus.emitAgent({
+          type: "error",
+          message: `[Context] Summarization failed: ${error}. Falling back to standard pruning.`
+        });
+        this.pruneHistoryFallback();
+      }
+    }
+  }
+  async summarizeBlock(messages) {
+    if (!this.client) return "Summary unavailable.";
+    const summarizerModel = this.lastConfig?.summarizerModel || "claude-haiku-4-5-20251001";
+    const simplifiedMessages = messages.map((m) => {
+      if (Array.isArray(m.content)) {
+        const textContent = m.content.map((b) => {
+          if (b.type === "text") return b.text;
+          if (b.type === "tool_use") return `[Tool Use: ${b.name}]`;
+          if (b.type === "tool_result") return `[Tool Result: ${typeof b.content === "string" ? b.content.slice(0, 500) + "..." : "Data"}]`;
+          return "";
+        }).join("\n");
+        return { role: m.role, content: textContent };
+      }
+      return m;
+    });
+    const prompt = `Please summarize the following conversation segment. Focus on:
+1. Key user requests and intents.
+2. Important actions taken by the agent (tools used).
+3. Key occurrences of errors or successes.
+4. Any critical data/context that might be needed later.
+Be concise but comprehensive.
+
+CONVERSATION SEGMENT:
+${JSON.stringify(simplifiedMessages, null, 2)}
+`;
+    const response = await this.client.messages.create({
+      model: summarizerModel,
+      max_tokens: 1024,
+      messages: [{ role: "user", content: prompt }]
+    });
+    if (response.content[0].type === "text") {
+      return response.content[0].text;
+    }
+    return "Summary generation returned non-text content.";
+  }
+  pruneHistoryFallback() {
+    if (this.conversationHistory.length > CONTEXT.MAX_MESSAGES) {
+      const keepFirst = CONTEXT.KEEP_FIRST;
+      const keepLast = 20;
+      const removalCount = this.conversationHistory.length - (keepFirst + keepLast);
+      if (removalCount > 0) {
+        const keptStart = this.conversationHistory.slice(0, keepFirst);
+        const keptEnd = this.conversationHistory.slice(-keepLast);
+        this.conversationHistory = [
+          ...keptStart,
+          { role: "user", content: `[... History Pruned: ${removalCount} intermediate messages were removed to save context ...]` },
+          ...keptEnd
+        ];
+      }
+    }
+  }
+  clearHistory() {
+    this.conversationHistory = [];
+  }
+  /**
+   * Get the last tool output content (for fallback when LLM generates no text)
+   */
+  getLastToolOutput() {
+    const output = this.lastToolOutputContent;
+    this.lastToolOutputContent = null;
+    return output;
+  }
+  /**
+   * Get a snapshot of the current conversation history for persistence
+   */
+  getHistorySnapshot() {
+    return [...this.conversationHistory];
+  }
+  /**
+   * Persist current history to DB
+   */
+  async persistHistory() {
+    const { context: context2 } = await import("./context-CIWCGVB6.js");
+    const { db: db2 } = await import("./database-M457QD3O.js");
+    const sessionId = context2.get().session_id;
+    if (!sessionId) return;
+    try {
+      db2.getDb().prepare("UPDATE sessions SET llm_history = ? WHERE id = ?").run(JSON.stringify(this.conversationHistory), sessionId);
+    } catch (e) {
+      console.error("Failed to persist LLM history:", e);
+    }
+  }
+  /**
+   * Restore conversation history from a saved session
+   * Validates history to prevent API errors from orphaned tool_use blocks
+   */
+  restoreHistory(history2) {
+    if (!Array.isArray(history2) || history2.length === 0) {
+      return;
+    }
+    const validatedHistory = this.validateAndFixHistory(history2);
+    if (!this.verifyHistoryIntegrity(validatedHistory)) {
+      bus.emitAgent({
+        type: "thought",
+        content: `[Context] History validation failed - starting fresh to avoid API errors.`,
+        hidden: false
+      });
+      this.conversationHistory = [];
+      return;
+    }
+    this.conversationHistory = validatedHistory;
+    bus.emitAgent({
+      type: "thought",
+      content: `[Context] Restored ${validatedHistory.length} messages from saved session.`,
+      hidden: true
+    });
+  }
+  /**
+   * Verify history integrity - check that all tool_results have matching tool_uses
+   */
+  verifyHistoryIntegrity(history2) {
+    for (let i = 0; i < history2.length; i++) {
+      const msg = history2[i];
+      const prevMsg = history2[i - 1];
+      if (msg.role === "user" && Array.isArray(msg.content)) {
+        const toolResults = msg.content.filter((b) => b.type === "tool_result");
+        if (toolResults.length > 0) {
+          if (!prevMsg || prevMsg.role !== "assistant" || !Array.isArray(prevMsg.content)) {
+            return false;
+          }
+          const toolUseIds = new Set(
+            prevMsg.content.filter((b) => b.type === "tool_use").map((b) => b.id)
+          );
+          for (const tr of toolResults) {
+            if (!toolUseIds.has(tr.tool_use_id)) {
+              return false;
+            }
+          }
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Validate conversation history and remove orphaned tool blocks
+   * - Each tool_use must have a corresponding tool_result in the next message
+   * - Each tool_result must have a corresponding tool_use in the previous message
+   */
+  validateAndFixHistory(history2) {
+    const validated = [];
+    for (let i = 0; i < history2.length; i++) {
+      const msg = history2[i];
+      const nextMsg = history2[i + 1];
+      const prevMsg = validated[validated.length - 1];
+      if (msg.role === "user" && Array.isArray(msg.content)) {
+        const toolResultBlocks = msg.content.filter((b) => b.type === "tool_result");
+        if (toolResultBlocks.length > 0) {
+          if (!prevMsg || prevMsg.role !== "assistant" || !Array.isArray(prevMsg.content)) {
+            const nonToolBlocks2 = msg.content.filter((b) => b.type !== "tool_result");
+            if (nonToolBlocks2.length > 0) {
+              validated.push({
+                role: "user",
+                content: nonToolBlocks2
+              });
+            }
+            continue;
+          }
+          const toolUseIds = new Set(
+            prevMsg.content.filter((b) => b.type === "tool_use").map((b) => b.id)
+          );
+          const validToolResults = toolResultBlocks.filter((tr) => toolUseIds.has(tr.tool_use_id));
+          const nonToolBlocks = msg.content.filter((b) => b.type !== "tool_result");
+          if (validToolResults.length !== toolResultBlocks.length) {
+            if (validToolResults.length === 0 && nonToolBlocks.length > 0) {
+              validated.push({
+                role: "user",
+                content: nonToolBlocks
+              });
+              continue;
+            } else if (validToolResults.length > 0) {
+              validated.push({
+                role: "user",
+                content: [...nonToolBlocks, ...validToolResults]
+              });
+              continue;
+            }
+            continue;
+          }
+        }
+      }
+      if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        const toolUseBlocks = msg.content.filter((b) => b.type === "tool_use");
+        if (toolUseBlocks.length > 0) {
+          if (!nextMsg || nextMsg.role !== "user" || !Array.isArray(nextMsg.content)) {
+            const textBlocks = msg.content.filter((b) => b.type === "text");
+            if (textBlocks.length > 0) {
+              validated.push({
+                role: "assistant",
+                content: textBlocks.map((b) => b.text).join("\n")
+              });
+            }
+            continue;
+          }
+          const toolResultIds = new Set(
+            nextMsg.content.filter((b) => b.type === "tool_result").map((b) => b.tool_use_id)
+          );
+          const validToolUses = toolUseBlocks.filter((tu) => toolResultIds.has(tu.id));
+          if (validToolUses.length !== toolUseBlocks.length) {
+            const textBlocks = msg.content.filter((b) => b.type === "text");
+            if (validToolUses.length === 0 && textBlocks.length > 0) {
+              validated.push({
+                role: "assistant",
+                content: textBlocks.map((b) => b.text).join("\n")
+              });
+              continue;
+            } else if (validToolUses.length > 0) {
+              validated.push({
+                role: "assistant",
+                content: [...textBlocks, ...validToolUses]
+              });
+              continue;
+            }
+            continue;
+          }
+        }
+      }
+      validated.push(msg);
+    }
+    return validated;
+  }
+};
+var llm = new LLMClient();
+
+// src/core/session.ts
+var SessionManager = class {
+  startTime = Date.now();
+  /**
+   * Save current session state
+   * (V13: Mostly a no-op as state is continuously saved to SQLite)
+   */
+  async save() {
+    const ctx = context.get();
+    await context.save();
+    return { sessionId: ctx.session_id, path: "sqlite" };
+  }
+  /**
+   * List all saved sessions
+   */
+  async list() {
+    try {
+      const cfg = await config.load();
+      const rows = db.getDb().prepare(`
+                SELECT id, created_at, workspace 
+                FROM sessions 
+                ORDER BY created_at DESC
+            `).all();
+      const sessions = [];
+      for (const row of rows) {
+        const taskRow = db.getDb().prepare(`
+                    SELECT title FROM tasks 
+                    WHERE session_id = ? 
+                    ORDER BY created_at DESC LIMIT 1
+                `).get(row.id);
+        const modCount = db.getDb().prepare(`
+                    SELECT COUNT(*) as count FROM working_set WHERE session_id = ?
+                `).get(row.id);
+        sessions.push({
+          id: row.id,
+          savedAt: new Date(row.created_at).toISOString(),
+          task: taskRow ? taskRow.title : null,
+          filesModified: modCount ? modCount.count : 0,
+          workspace: row.workspace || cfg.workspaceRoot
+        });
+      }
+      return sessions;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Delete a saved session and all related data
+   */
+  async delete(sessionId) {
+    try {
+      const transaction = db.getDb().transaction(() => {
+        db.getDb().prepare("DELETE FROM subtasks WHERE task_id IN (SELECT id FROM tasks WHERE session_id = ?)").run(sessionId);
+        db.getDb().prepare("DELETE FROM tasks WHERE session_id = ?").run(sessionId);
+        db.getDb().prepare("DELETE FROM working_set WHERE session_id = ?").run(sessionId);
+        db.getDb().prepare("DELETE FROM usage_stats WHERE session_id = ?").run(sessionId);
+        db.getDb().prepare("DELETE FROM events WHERE session_id = ?").run(sessionId);
+        db.getDb().prepare("DELETE FROM sessions WHERE id = ?").run(sessionId);
+      });
+      transaction();
+      return true;
+    } catch (e) {
+      console.error("Failed to delete session:", e);
+      return false;
+    }
+  }
+  /**
+   * Restore a saved session
+   */
+  async restore(sessionId) {
+    const sessionRow = db.getDb().prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
+    if (!sessionRow) {
+      return { success: false, error: `Session ${sessionId} not found` };
+    }
+    await context.load(sessionId);
+    const { bus: bus2 } = await import("./bus-N5GVOUS7.js");
+    const events = await history.load();
+    const filteredEvents = events.filter(
+      (e) => e.type !== "approval_request" && e.type !== "choice_request"
+    );
+    bus2.emitAgent({ type: "restore_history", events: filteredEvents });
+    await tasks.init();
+    const stats = db.getDb().prepare(`
+            SELECT 
+                SUM(cost) as sessionCost,
+                SUM(input_tokens) as sessionInputTokens,
+                SUM(output_tokens) as sessionOutputTokens,
+                MIN(timestamp) as firstLog,
+                MAX(timestamp) as lastLog
+            FROM usage_stats
+            WHERE session_id = ?
+        `).get(sessionId);
+    const duration = stats && stats.lastLog && stats.firstLog ? stats.lastLog - stats.firstLog : 0;
+    usage.restoreSessionState({
+      cost: stats ? stats.sessionCost || 0 : 0,
+      inputTokens: stats ? stats.sessionInputTokens || 0 : 0,
+      outputTokens: stats ? stats.sessionOutputTokens || 0 : 0,
+      cacheReadTokens: 0,
+      // Not currently tracked in usage_stats table separate?
+      cacheCreationTokens: 0,
+      duration
+    });
+    this.resetStartTime();
+    this.startTime = Date.now() - duration;
+    const row = sessionRow;
+    if (row.llm_history) {
+      try {
+        const history2 = JSON.parse(row.llm_history);
+        llm.restoreHistory(history2);
+      } catch (e) {
+        console.error("Failed to parse LLM history:", e);
+      }
+    }
+    return { success: true };
+  }
+  /**
+   * Generate session summary for shutdown
+   */
+  async getSummary() {
+    const ctx = context.get();
+    const task = tasks.get();
+    let tasksCompleted = 0;
+    let tasksPending = 0;
+    if (task) {
+      for (const subtask of task.subtasks) {
+        if (subtask.done) tasksCompleted++;
+        else tasksPending++;
+      }
+    }
+    return {
+      sessionId: ctx.session_id,
+      duration: Date.now() - this.startTime,
+      filesRead: ctx.files_read.length,
+      filesModified: ctx.files_modified.length,
+      tasksCompleted,
+      tasksPending,
+      totalCost: usage.getSessionCost()
+    };
+  }
+  resetStartTime() {
+    this.startTime = Date.now();
+  }
+  getDuration() {
+    return Date.now() - this.startTime;
+  }
+  formatDuration(ms) {
+    const seconds = Math.floor(ms / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) return `${hours}h ${minutes % 60}m`;
+    else if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+    else return `${seconds}s`;
+  }
+};
+var session = new SessionManager();
+
+export {
+  usage,
+  auditor,
+  sandbox,
+  tasks,
+  undo,
+  diffManager,
+  mcp,
+  listRegistry,
+  tools,
+  history,
+  llm,
+  session
+};