@aurora-foundation/obsidian-next 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import React7 from "react";
+import React8 from "react";
 import { render } from "ink";
 
 // src/ui/Root.tsx
-import { useState as useState4, useEffect, useCallback as useCallback3 } from "react";
-import { Box as Box7, Text as Text7, useApp, useInput as useInput3 } from "ink";
+import { useState as useState5, useEffect as useEffect2, useCallback as useCallback4 } from "react";
+import { Box as Box8, Text as Text8, useApp, useInput as useInput4 } from "ink";
 import TextInput from "ink-text-input";
 
 // src/core/bus.ts
@@ -423,10 +423,432 @@ var ChoicePrompt = ({
   );
 };
 
-// src/ui/Dashboard.tsx
-import React5 from "react";
-import { Box as Box5, Text as Text5 } from "ink";
+// src/components/SettingsMenu.tsx
+import { useState as useState4, useCallback as useCallback3, useEffect } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput3 } from "ink";
+
+// src/core/settings.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var SETTINGS_DIR = ".obsidian";
+var SETTINGS_FILE = "settings.json";
+var SettingsSchema = z.object({
+  // Execution mode
+  mode: z.enum(["auto", "plan", "safe"]).default("safe"),
+  // Auto-accept settings
+  autoAccept: z.object({
+    enabled: z.boolean().default(false),
+    readOperations: z.boolean().default(true),
+    safeCommands: z.boolean().default(true)
+  }).default({}),
+  // Tool permissions
+  permissions: z.object({
+    // Patterns always allowed without prompt: "tool:pattern"
+    allow: z.array(z.string()).default([]),
+    // Patterns always blocked
+    deny: z.array(z.string()).default([])
+  }).default({}),
+  // Security settings
+  security: z.object({
+    // PII redaction before sending to LLM
+    piiRedaction: z.boolean().default(true),
+    // Audit logging of all commands
+    auditLogging: z.boolean().default(true),
+    // Key storage backend preference
+    keyBackend: z.enum(["auto", "keychain", "secret-tool", "encrypted-file", "env"]).default("auto")
+  }).default({}),
+  // UI preferences
+  ui: z.object({
+    syntaxHighlight: z.boolean().default(true),
+    diffColors: z.boolean().default(true),
+    showLineNumbers: z.boolean().default(true)
+  }).default({})
+});
+var DEFAULT_SETTINGS = {
+  mode: "safe",
+  autoAccept: {
+    enabled: false,
+    readOperations: false,
+    safeCommands: false
+  },
+  permissions: {
+    allow: [],
+    // Empty - user builds their own allow list
+    deny: []
+  },
+  security: {
+    piiRedaction: true,
+    // Enabled by default - protects user privacy
+    auditLogging: true,
+    // Enabled by default - for accountability
+    keyBackend: "auto"
+    // Auto-detect best available backend
+  },
+  ui: {
+    syntaxHighlight: true,
+    diffColors: true,
+    showLineNumbers: true
+  }
+};
+var SettingsManager = class {
+  settingsPath;
+  cached = null;
+  constructor() {
+    this.settingsPath = path.join(process.cwd(), SETTINGS_DIR, SETTINGS_FILE);
+  }
+  async load() {
+    if (this.cached) return this.cached;
+    return this.reload();
+  }
+  async reload() {
+    try {
+      const data = await fs.readFile(this.settingsPath, "utf-8");
+      const parsed = JSON.parse(data);
+      this.cached = SettingsSchema.parse({ ...DEFAULT_SETTINGS, ...parsed });
+    } catch {
+      this.cached = DEFAULT_SETTINGS;
+      await this.save(DEFAULT_SETTINGS);
+    }
+    return this.cached;
+  }
+  /**
+   * Add a permission to the allow list (called when user approves a command)
+   */
+  async addAllowedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.allow.includes(pattern)) {
+      s.permissions.allow.push(pattern);
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  /**
+   * Add a permission to the deny list
+   */
+  async addDeniedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.deny.includes(pattern)) {
+      s.permissions.deny.push(pattern);
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  async save(newSettings) {
+    const current = await this.load();
+    const merged = { ...current, ...newSettings };
+    if (newSettings.autoAccept) {
+      merged.autoAccept = { ...current.autoAccept, ...newSettings.autoAccept };
+    }
+    if (newSettings.permissions) {
+      merged.permissions = { ...current.permissions, ...newSettings.permissions };
+    }
+    if (newSettings.security) {
+      merged.security = { ...current.security, ...newSettings.security };
+    }
+    if (newSettings.ui) {
+      merged.ui = { ...current.ui, ...newSettings.ui };
+    }
+    const validated = SettingsSchema.parse(merged);
+    const dir = path.dirname(this.settingsPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(this.settingsPath, JSON.stringify(validated, null, 2));
+    this.cached = validated;
+  }
+  async get(key) {
+    const s = await this.load();
+    return s[key];
+  }
+  async set(key, value) {
+    await this.save({ [key]: value });
+  }
+  /**
+   * Check if a tool:command pattern is allowed
+   */
+  async isAllowed(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    for (const deny of s.permissions.deny) {
+      if (this.matchPattern(pattern, deny)) {
+        return false;
+      }
+    }
+    for (const allow of s.permissions.allow) {
+      if (this.matchPattern(pattern, allow)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a tool:command pattern is explicitly denied
+   */
+  async isDenied(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    for (const deny of s.permissions.deny) {
+      if (this.matchPattern(pattern, deny)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Simple glob-like pattern matching
+   * Supports * as wildcard
+   */
+  matchPattern(value, pattern) {
+    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${regex}$`).test(value);
+  }
+  clearCache() {
+    this.cached = null;
+  }
+  getPath() {
+    return this.settingsPath;
+  }
+};
+var settings = new SettingsManager();
+
+// src/components/SettingsMenu.tsx
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var SettingsMenu = ({ onClose }) => {
+  const [view, setView] = useState4("categories");
+  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const [currentSettings, setCurrentSettings] = useState4(null);
+  const [saving, setSaving] = useState4(false);
+  useEffect(() => {
+    settings.load().then(setCurrentSettings);
+  }, []);
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [view]);
+  const saveAndUpdate = useCallback3(async (updates) => {
+    setSaving(true);
+    await settings.save(updates);
+    const updated = await settings.reload();
+    setCurrentSettings(updated);
+    setSaving(false);
+  }, []);
+  const getMenuItems = useCallback3(() => {
+    if (!currentSettings) return [];
+    switch (view) {
+      case "categories":
+        return [
+          { key: "mode", label: "Execution Mode", type: "category", description: `Current: ${currentSettings.mode}` },
+          { key: "security", label: "Security", type: "category", description: "PII redaction, audit logging" },
+          { key: "ui", label: "UI Preferences", type: "category", description: "Syntax highlighting, colors" },
+          { key: "permissions", label: "Permissions", type: "category", description: "Allow/deny lists" },
+          { key: "close", label: "Close Settings", type: "action" }
+        ];
+      case "mode":
+        return [
+          { key: "auto", label: "Auto Mode", type: "select", value: currentSettings.mode === "auto", description: "Execute all commands without confirmation" },
+          { key: "plan", label: "Plan Mode", type: "select", value: currentSettings.mode === "plan", description: "Read-only planning, approve before execution" },
+          { key: "safe", label: "Safe Mode", type: "select", value: currentSettings.mode === "safe", description: "Require approval for all write operations" },
+          { key: "back", label: "Back", type: "action" }
+        ];
+      case "security":
+        return [
+          { key: "piiRedaction", label: "PII Redaction", type: "toggle", value: currentSettings.security.piiRedaction, description: "Redact sensitive data before sending to AI" },
+          { key: "auditLogging", label: "Audit Logging", type: "toggle", value: currentSettings.security.auditLogging, description: "Log all commands and file operations" },
+          { key: "keyBackend", label: "Key Storage", type: "category", description: `Current: ${currentSettings.security.keyBackend}` },
+          { key: "back", label: "Back", type: "action" }
+        ];
+      case "ui":
+        return [
+          { key: "syntaxHighlight", label: "Syntax Highlighting", type: "toggle", value: currentSettings.ui.syntaxHighlight, description: "Colorize code output" },
+          { key: "diffColors", label: "Diff Colors", type: "toggle", value: currentSettings.ui.diffColors, description: "Show colored diffs" },
+          { key: "showLineNumbers", label: "Line Numbers", type: "toggle", value: currentSettings.ui.showLineNumbers, description: "Show line numbers in file output" },
+          { key: "back", label: "Back", type: "action" }
+        ];
+      case "permissions":
+        const allowCount = currentSettings.permissions.allow.length;
+        const denyCount = currentSettings.permissions.deny.length;
+        return [
+          { key: "viewAllow", label: "View Allowed Patterns", type: "category", description: `${allowCount} pattern(s)` },
+          { key: "viewDeny", label: "View Denied Patterns", type: "category", description: `${denyCount} pattern(s)` },
+          { key: "clearAllow", label: "Clear Allowed Patterns", type: "action", description: "Reset allow list" },
+          { key: "clearDeny", label: "Clear Denied Patterns", type: "action", description: "Reset deny list" },
+          { key: "back", label: "Back", type: "action" }
+        ];
+      default:
+        return [];
+    }
+  }, [view, currentSettings]);
+  const items = getMenuItems();
+  const handleSelect = useCallback3(async () => {
+    const item = items[selectedIndex];
+    if (!item || !currentSettings) return;
+    switch (item.type) {
+      case "category":
+        if (item.key === "keyBackend") {
+          const backends = ["auto", "keychain", "secret-tool", "encrypted-file", "env"];
+          const currentIdx = backends.indexOf(currentSettings.security.keyBackend);
+          const nextBackend = backends[(currentIdx + 1) % backends.length];
+          await saveAndUpdate({ security: { ...currentSettings.security, keyBackend: nextBackend } });
+        } else if (item.key === "viewAllow") {
+        } else if (item.key === "viewDeny") {
+        } else {
+          setView(item.key);
+        }
+        break;
+      case "toggle":
+        if (view === "security") {
+          await saveAndUpdate({
+            security: {
+              ...currentSettings.security,
+              [item.key]: !item.value
+            }
+          });
+        } else if (view === "ui") {
+          await saveAndUpdate({
+            ui: {
+              ...currentSettings.ui,
+              [item.key]: !item.value
+            }
+          });
+        }
+        break;
+      case "select":
+        if (view === "mode" && item.key !== "back") {
+          await saveAndUpdate({ mode: item.key });
+        }
+        break;
+      case "action":
+        if (item.key === "back") {
+          setView("categories");
+        } else if (item.key === "close") {
+          onClose();
+        } else if (item.key === "clearAllow") {
+          await saveAndUpdate({ permissions: { ...currentSettings.permissions, allow: [] } });
+        } else if (item.key === "clearDeny") {
+          await saveAndUpdate({ permissions: { ...currentSettings.permissions, deny: [] } });
+        }
+        break;
+    }
+  }, [items, selectedIndex, currentSettings, view, saveAndUpdate, onClose]);
+  useInput3((input, key) => {
+    if (key.upArrow) {
+      setSelectedIndex((prev) => prev > 0 ? prev - 1 : items.length - 1);
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => prev < items.length - 1 ? prev + 1 : 0);
+    }
+    if (key.return) {
+      handleSelect();
+    }
+    if (key.escape) {
+      if (view === "categories") {
+        onClose();
+      } else {
+        setView("categories");
+      }
+    }
+    const num = parseInt(input, 10);
+    if (num >= 1 && num <= items.length) {
+      setSelectedIndex(num - 1);
+    }
+  });
+  if (!currentSettings) {
+    return /* @__PURE__ */ jsx5(Box5, { borderStyle: "round", borderColor: "cyan", padding: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Loading settings..." }) });
+  }
+  const getViewTitle = () => {
+    switch (view) {
+      case "categories":
+        return "Settings";
+      case "mode":
+        return "Execution Mode";
+      case "security":
+        return "Security Settings";
+      case "ui":
+        return "UI Preferences";
+      case "permissions":
+        return "Permission Lists";
+      default:
+        return "Settings";
+    }
+  };
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "cyan",
+      paddingX: 1,
+      paddingY: 0,
+      marginY: 1,
+      children: [
+        /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "cyan", children: [
+            "[*] ",
+            getViewTitle()
+          ] }),
+          saving && /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "Saving..." })
+        ] }),
+        /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginBottom: 1, children: items.map((item, index) => {
+          const isSelected = index === selectedIndex;
+          const indicator = isSelected ? ">" : " ";
+          let valueDisplay = null;
+          if (item.type === "toggle") {
+            valueDisplay = /* @__PURE__ */ jsxs5(Text5, { color: item.value ? "green" : "red", children: [
+              "[",
+              item.value ? "ON" : "OFF",
+              "]"
+            ] });
+          } else if (item.type === "select" && view === "mode") {
+            valueDisplay = /* @__PURE__ */ jsx5(Text5, { color: item.value ? "green" : "gray", children: item.value ? "[*]" : "[ ]" });
+          }
+          return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs5(Box5, { children: [
+              /* @__PURE__ */ jsxs5(Text5, { color: isSelected ? "cyan" : "gray", children: [
+                indicator,
+                " "
+              ] }),
+              /* @__PURE__ */ jsxs5(Text5, { color: isSelected ? "white" : "gray", bold: isSelected, children: [
+                "[",
+                index + 1,
+                "] ",
+                item.label
+              ] }),
+              valueDisplay && /* @__PURE__ */ jsx5(Text5, { children: " " }),
+              valueDisplay
+            ] }),
+            item.description && isSelected && /* @__PURE__ */ jsx5(Box5, { marginLeft: 4, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: item.description }) })
+          ] }, item.key);
+        }) }),
+        view === "permissions" && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [
+          /* @__PURE__ */ jsx5(Text5, { color: "gray", bold: true, children: "Allowed patterns:" }),
+          currentSettings.permissions.allow.length === 0 ? /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: "  (none)" }) : currentSettings.permissions.allow.slice(0, 5).map((p, i) => /* @__PURE__ */ jsxs5(Text5, { color: "green", children: [
+            "  + ",
+            p
+          ] }, i)),
+          currentSettings.permissions.allow.length > 5 && /* @__PURE__ */ jsxs5(Text5, { color: "gray", dimColor: true, children: [
+            "  ... and ",
+            currentSettings.permissions.allow.length - 5,
+            " more"
+          ] }),
+          /* @__PURE__ */ jsx5(Text5, { color: "gray", bold: true, children: "Denied patterns:" }),
+          currentSettings.permissions.deny.length === 0 ? /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: "  (none)" }) : currentSettings.permissions.deny.slice(0, 5).map((p, i) => /* @__PURE__ */ jsxs5(Text5, { color: "red", children: [
+            "  - ",
+            p
+          ] }, i)),
+          currentSettings.permissions.deny.length > 5 && /* @__PURE__ */ jsxs5(Text5, { color: "gray", dimColor: true, children: [
+            "  ... and ",
+            currentSettings.permissions.deny.length - 5,
+            " more"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx5(Box5, { borderStyle: "single", borderColor: "gray", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, paddingTop: 0, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: "Arrows: navigate | Enter: select/toggle | Esc: back | 1-9: quick select" }) })
+      ]
+    }
+  );
+};
+
+// src/ui/Dashboard.tsx
+import React6 from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 var flareAnim2 = ["\xB7", "\u25AA", "\u259A", "\u2756", "\u2726", "\u2739", "\u2726", "\u25AA"];
 var owlSprites = {
   idle: `\u2590\u259B\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u259C\u258C
@@ -459,23 +881,23 @@ var Dashboard = ({
   model = "Claude Sonnet 4.5",
   workspace = process.cwd()
 }) => {
-  const [flareFrame, setFlareFrame] = React5.useState(0);
-  const [owlState, setOwlState] = React5.useState("idle");
-  const [columns, setColumns] = React5.useState(process.stdout.columns);
-  React5.useEffect(() => {
+  const [flareFrame, setFlareFrame] = React6.useState(0);
+  const [owlState, setOwlState] = React6.useState("idle");
+  const [columns, setColumns] = React6.useState(process.stdout.columns);
+  React6.useEffect(() => {
     const onResize = () => setColumns(process.stdout.columns);
     process.stdout.on("resize", onResize);
     return () => {
       process.stdout.off("resize", onResize);
     };
   }, []);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     const interval = setInterval(() => {
       setFlareFrame((prev) => (prev + 1) % flareAnim2.length);
     }, 100);
     return () => clearInterval(interval);
   }, []);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     let isActive = true;
     const loop = async () => {
       while (isActive) {
@@ -497,8 +919,8 @@ var Dashboard = ({
     };
   }, []);
   const showRightColumn = columns >= 100;
-  return /* @__PURE__ */ jsxs5(
-    Box5,
+  return /* @__PURE__ */ jsxs6(
+    Box6,
     {
       borderStyle: "round",
       borderColor: "red",
@@ -506,45 +928,45 @@ var Dashboard = ({
       paddingX: 1,
       paddingY: 0,
       children: [
-        /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", width: showRightColumn ? "60%" : "100%", paddingRight: showRightColumn ? 1 : 0, children: [
-          /* @__PURE__ */ jsx5(Box5, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "white", children: [
+        /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", width: showRightColumn ? "60%" : "100%", paddingRight: showRightColumn ? 1 : 0, children: [
+          /* @__PURE__ */ jsx6(Box6, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsxs6(Text6, { bold: true, color: "white", children: [
             "Welcome back, ",
             username,
             "!"
           ] }) }),
-          /* @__PURE__ */ jsx5(Box5, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "red", children: owlSprites[owlState] }) }),
-          /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", alignItems: "center", children: [
-            /* @__PURE__ */ jsxs5(Text5, { color: "white", children: [
+          /* @__PURE__ */ jsx6(Box6, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "red", children: owlSprites[owlState] }) }),
+          /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", alignItems: "center", children: [
+            /* @__PURE__ */ jsxs6(Text6, { color: "white", children: [
               model,
               " ",
-              /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: flareAnim2[flareFrame] }),
+              /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: flareAnim2[flareFrame] }),
               " Obsidian Next"
             ] }),
-            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: workspace })
+            /* @__PURE__ */ jsx6(Text6, { color: "gray", children: workspace })
           ] })
         ] }),
-        showRightColumn && /* @__PURE__ */ jsx5(Box5, { borderStyle: "single", borderTop: false, borderBottom: false, borderLeft: false, borderColor: "red", marginX: 1 }),
-        showRightColumn && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", width: "40%", paddingLeft: 1, children: [
-          /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
-            /* @__PURE__ */ jsx5(Text5, { bold: true, color: "red", children: "Commands" }),
-            /* @__PURE__ */ jsxs5(Text5, { color: "white", children: [
-              /* @__PURE__ */ jsx5(Text5, { bold: true, children: "/help" }),
+        showRightColumn && /* @__PURE__ */ jsx6(Box6, { borderStyle: "single", borderTop: false, borderBottom: false, borderLeft: false, borderColor: "red", marginX: 1 }),
+        showRightColumn && /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", width: "40%", paddingLeft: 1, children: [
+          /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginBottom: 1, children: [
+            /* @__PURE__ */ jsx6(Text6, { bold: true, color: "red", children: "Commands" }),
+            /* @__PURE__ */ jsxs6(Text6, { color: "white", children: [
+              /* @__PURE__ */ jsx6(Text6, { bold: true, children: "/help" }),
               "  Show all commands"
             ] }),
-            /* @__PURE__ */ jsxs5(Text5, { color: "white", children: [
-              /* @__PURE__ */ jsx5(Text5, { bold: true, children: "/tool" }),
+            /* @__PURE__ */ jsxs6(Text6, { color: "white", children: [
+              /* @__PURE__ */ jsx6(Text6, { bold: true, children: "/tool" }),
               "  Execute tools"
             ] }),
-            /* @__PURE__ */ jsxs5(Text5, { color: "white", children: [
-              /* @__PURE__ */ jsx5(Text5, { bold: true, children: "/clear" }),
+            /* @__PURE__ */ jsxs6(Text6, { color: "white", children: [
+              /* @__PURE__ */ jsx6(Text6, { bold: true, children: "/clear" }),
               " Clear history"
             ] })
           ] }),
-          /* @__PURE__ */ jsx5(Box5, { borderStyle: "single", borderTop: false, borderLeft: false, borderRight: false, borderColor: "red", marginBottom: 1 }),
-          /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
-            /* @__PURE__ */ jsx5(Text5, { bold: true, color: "red", children: "Quick Start" }),
-            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Ask me to read, edit, or" }),
-            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "run commands in your code." })
+          /* @__PURE__ */ jsx6(Box6, { borderStyle: "single", borderTop: false, borderLeft: false, borderRight: false, borderColor: "red", marginBottom: 1 }),
+          /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx6(Text6, { bold: true, color: "red", children: "Quick Start" }),
+            /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "Ask me to read, edit, or" }),
+            /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "run commands in your code." })
           ] })
         ] })
       ]
@@ -553,8 +975,8 @@ var Dashboard = ({
 };
 
 // src/ui/CommandPopup.tsx
-import { Box as Box6, Text as Text6 } from "ink";
-import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
 var COMMANDS = [
   { name: "/help", desc: "Show available commands" },
   { name: "/init", desc: "Initialize configuration" },
@@ -575,8 +997,8 @@ var COMMANDS = [
 ];
 var CommandPopup = ({ matches, selectedIndex }) => {
   if (matches.length === 0) return null;
-  return /* @__PURE__ */ jsx6(
-    Box6,
+  return /* @__PURE__ */ jsx7(
+    Box7,
     {
       flexDirection: "column",
       borderStyle: "round",
@@ -586,12 +1008,12 @@ var CommandPopup = ({ matches, selectedIndex }) => {
       width: "100%",
       children: matches.map((cmd, i) => {
         const isSelected = i === selectedIndex;
-        return /* @__PURE__ */ jsxs6(Box6, { justifyContent: "space-between", children: [
-          /* @__PURE__ */ jsxs6(Text6, { color: isSelected ? "cyan" : "red", bold: isSelected, children: [
+        return /* @__PURE__ */ jsxs7(Box7, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? "cyan" : "red", bold: isSelected, children: [
             isSelected ? "> " : "  ",
             cmd.name
           ] }),
-          /* @__PURE__ */ jsx6(Text6, { color: isSelected ? "white" : "gray", children: cmd.desc })
+          /* @__PURE__ */ jsx7(Text7, { color: isSelected ? "white" : "gray", children: cmd.desc })
         ] }, cmd.name);
       })
     }
@@ -599,18 +1021,18 @@ var CommandPopup = ({ matches, selectedIndex }) => {
 };
 
 // src/core/history.ts
-import fs from "fs/promises";
-import path from "path";
+import fs2 from "fs/promises";
+import path2 from "path";
 import os from "os";
 var HistoryManager = class {
   historyPath;
   saveTimer = null;
   constructor(customPath) {
-    this.historyPath = customPath || path.join(os.homedir(), ".obsidian", "history.json");
+    this.historyPath = customPath || path2.join(os.homedir(), ".obsidian", "history.json");
   }
   async load() {
     try {
-      const data = await fs.readFile(this.historyPath, "utf-8");
+      const data = await fs2.readFile(this.historyPath, "utf-8");
       const events = JSON.parse(data);
       return Array.isArray(events) ? events : [];
     } catch {
@@ -621,9 +1043,9 @@ var HistoryManager = class {
     if (this.saveTimer) clearTimeout(this.saveTimer);
     this.saveTimer = setTimeout(async () => {
       try {
-        const dir = path.dirname(this.historyPath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(this.historyPath, JSON.stringify(events, null, 2));
+        const dir = path2.dirname(this.historyPath);
+        await fs2.mkdir(dir, { recursive: true });
+        await fs2.writeFile(this.historyPath, JSON.stringify(events, null, 2));
       } catch (error) {
         console.error("Failed to save history:", error);
       }
@@ -632,7 +1054,7 @@ var HistoryManager = class {
   async clear() {
     if (this.saveTimer) clearTimeout(this.saveTimer);
     try {
-      await fs.writeFile(this.historyPath, JSON.stringify([], null, 2));
+      await fs2.writeFile(this.historyPath, JSON.stringify([], null, 2));
     } catch {
     }
   }
@@ -640,16 +1062,16 @@ var HistoryManager = class {
 var history = new HistoryManager();
 
 // src/core/usage.ts
-import fs2 from "fs/promises";
-import path2 from "path";
+import fs3 from "fs/promises";
+import path3 from "path";
 import os2 from "os";
-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),
-  totalCost: z.number().default(0)
+import { z as z2 } from "zod";
+var UsageSchema = z2.object({
+  totalSessions: z2.number().default(0),
+  totalRequests: z2.number().default(0),
+  totalInputTokens: z2.number().default(0),
+  totalOutputTokens: z2.number().default(0),
+  totalCost: z2.number().default(0)
 });
 var MODEL_PRICES = {
   // Claude 4.5 Family (2025-2026)
@@ -668,12 +1090,12 @@ var UsageTracker = class {
   stats;
   sessionCost = 0;
   constructor(customPath) {
-    this.usagePath = customPath || path2.join(os2.homedir(), ".obsidian", "usage.json");
+    this.usagePath = customPath || path3.join(os2.homedir(), ".obsidian", "usage.json");
     this.stats = UsageSchema.parse({});
   }
   async init() {
     try {
-      const data = await fs2.readFile(this.usagePath, "utf-8");
+      const data = await fs3.readFile(this.usagePath, "utf-8");
       this.stats = UsageSchema.parse(JSON.parse(data));
     } catch {
       await this.save();
@@ -704,250 +1126,85 @@ var UsageTracker = class {
     return this.stats;
   }
   async save() {
-    const dir = path2.dirname(this.usagePath);
-    await fs2.mkdir(dir, { recursive: true });
-    await fs2.writeFile(this.usagePath, JSON.stringify(this.stats, null, 2));
+    const dir = path3.dirname(this.usagePath);
+    await fs3.mkdir(dir, { recursive: true });
+    await fs3.writeFile(this.usagePath, JSON.stringify(this.stats, null, 2));
   }
 };
 var usage = new UsageTracker();
 
 // src/core/config.ts
-import fs3 from "fs/promises";
-import path3 from "path";
-import os3 from "os";
-import { z as z2 } from "zod";
-import dotenv from "dotenv";
-dotenv.config();
-var ConfigSchema = z2.object({
-  apiKey: z2.string().optional(),
-  model: z2.string().default("claude-sonnet-4-5-20250929"),
-  workspaceRoot: z2.string().default(process.cwd()),
-  maxTokens: z2.number().default(8192),
-  language: z2.string().default("en")
-});
-var DEFAULT_CONFIG = {
-  model: "claude-3-5-sonnet",
-  maxTokens: 4096,
-  language: "en",
-  workspaceRoot: process.cwd()
-};
-var ConfigManager = class {
-  configPath;
-  cachedConfig = null;
-  constructor(customPath) {
-    this.configPath = customPath || path3.join(os3.homedir(), ".obsidian", "config.json");
-  }
-  async load() {
-    if (this.cachedConfig) return this.cachedConfig;
-    return this.reload();
-  }
-  async reload() {
-    let loadedConfig = DEFAULT_CONFIG;
-    try {
-      const data = await fs3.readFile(this.configPath, "utf-8");
-      const parsed = JSON.parse(data);
-      loadedConfig = { ...DEFAULT_CONFIG, ...parsed };
-    } catch {
-    }
-    const envKey = process.env.ANTHROPIC_API_KEY;
-    const finalConfig = ConfigSchema.parse({
-      ...loadedConfig,
-      apiKey: envKey || loadedConfig.apiKey
-    });
-    this.cachedConfig = finalConfig;
-    return finalConfig;
-  }
-  clearCache() {
-    this.cachedConfig = null;
-  }
-  async save(config2) {
-    const dir = path3.dirname(this.configPath);
-    await fs3.mkdir(dir, { recursive: true });
-    await fs3.writeFile(this.configPath, JSON.stringify(config2, null, 2));
-    this.clearCache();
-  }
-  async exists() {
-    try {
-      await fs3.access(this.configPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  getPath() {
-    return this.configPath;
-  }
-};
-var config = new ConfigManager();
-
-// src/core/context.ts
-import fs5 from "fs/promises";
-import path5 from "path";
-
-// src/core/settings.ts
 import fs4 from "fs/promises";
 import path4 from "path";
+import os3 from "os";
 import { z as z3 } from "zod";
-var SETTINGS_DIR = ".obsidian";
-var SETTINGS_FILE = "settings.json";
-var SettingsSchema = z3.object({
-  // Execution mode
-  mode: z3.enum(["auto", "plan", "safe"]).default("safe"),
-  // Auto-accept settings
-  autoAccept: z3.object({
-    enabled: z3.boolean().default(false),
-    readOperations: z3.boolean().default(true),
-    safeCommands: z3.boolean().default(true)
-  }).default({}),
-  // Tool permissions
-  permissions: z3.object({
-    // Patterns always allowed without prompt: "tool:pattern"
-    allow: z3.array(z3.string()).default([]),
-    // Patterns always blocked
-    deny: z3.array(z3.string()).default([])
-  }).default({}),
-  // UI preferences
-  ui: z3.object({
-    syntaxHighlight: z3.boolean().default(true),
-    diffColors: z3.boolean().default(true),
-    showLineNumbers: z3.boolean().default(true)
-  }).default({})
-});
-var DEFAULT_SETTINGS = {
-  mode: "safe",
-  autoAccept: {
-    enabled: false,
-    readOperations: false,
-    safeCommands: false
-  },
-  permissions: {
-    allow: [],
-    // Empty - user builds their own allow list
-    deny: []
-  },
-  ui: {
-    syntaxHighlight: true,
-    diffColors: true,
-    showLineNumbers: true
-  }
+import dotenv from "dotenv";
+dotenv.config();
+var ConfigSchema = z3.object({
+  apiKey: z3.string().optional(),
+  model: z3.string().default("claude-sonnet-4-5-20250929"),
+  workspaceRoot: z3.string().default(process.cwd()),
+  maxTokens: z3.number().default(8192),
+  language: z3.string().default("en")
+});
+var DEFAULT_CONFIG = {
+  model: "claude-3-5-sonnet",
+  maxTokens: 4096,
+  language: "en",
+  workspaceRoot: process.cwd()
 };
-var SettingsManager = class {
-  settingsPath;
-  cached = null;
-  constructor() {
-    this.settingsPath = path4.join(process.cwd(), SETTINGS_DIR, SETTINGS_FILE);
+var ConfigManager = class {
+  configPath;
+  cachedConfig = null;
+  constructor(customPath) {
+    this.configPath = customPath || path4.join(os3.homedir(), ".obsidian", "config.json");
   }
   async load() {
-    if (this.cached) return this.cached;
+    if (this.cachedConfig) return this.cachedConfig;
     return this.reload();
   }
   async reload() {
+    let loadedConfig = DEFAULT_CONFIG;
     try {
-      const data = await fs4.readFile(this.settingsPath, "utf-8");
+      const data = await fs4.readFile(this.configPath, "utf-8");
       const parsed = JSON.parse(data);
-      this.cached = SettingsSchema.parse({ ...DEFAULT_SETTINGS, ...parsed });
+      loadedConfig = { ...DEFAULT_CONFIG, ...parsed };
     } catch {
-      this.cached = DEFAULT_SETTINGS;
-      await this.save(DEFAULT_SETTINGS);
-    }
-    return this.cached;
-  }
-  /**
-   * Add a permission to the allow list (called when user approves a command)
-   */
-  async addAllowedPermission(tool, command) {
-    const s = await this.load();
-    const pattern = `${tool}:${command}`;
-    if (!s.permissions.allow.includes(pattern)) {
-      s.permissions.allow.push(pattern);
-      await this.save({ permissions: s.permissions });
     }
+    const envKey = process.env.ANTHROPIC_API_KEY;
+    const finalConfig = ConfigSchema.parse({
+      ...loadedConfig,
+      apiKey: envKey || loadedConfig.apiKey
+    });
+    this.cachedConfig = finalConfig;
+    return finalConfig;
   }
-  /**
-   * Add a permission to the deny list
-   */
-  async addDeniedPermission(tool, command) {
-    const s = await this.load();
-    const pattern = `${tool}:${command}`;
-    if (!s.permissions.deny.includes(pattern)) {
-      s.permissions.deny.push(pattern);
-      await this.save({ permissions: s.permissions });
-    }
+  clearCache() {
+    this.cachedConfig = null;
   }
-  async save(newSettings) {
-    const current = await this.load();
-    const merged = { ...current, ...newSettings };
-    if (newSettings.autoAccept) {
-      merged.autoAccept = { ...current.autoAccept, ...newSettings.autoAccept };
-    }
-    if (newSettings.permissions) {
-      merged.permissions = { ...current.permissions, ...newSettings.permissions };
-    }
-    if (newSettings.ui) {
-      merged.ui = { ...current.ui, ...newSettings.ui };
-    }
-    const validated = SettingsSchema.parse(merged);
-    const dir = path4.dirname(this.settingsPath);
+  async save(config2) {
+    const dir = path4.dirname(this.configPath);
     await fs4.mkdir(dir, { recursive: true });
-    await fs4.writeFile(this.settingsPath, JSON.stringify(validated, null, 2));
-    this.cached = validated;
-  }
-  async get(key) {
-    const s = await this.load();
-    return s[key];
-  }
-  async set(key, value) {
-    await this.save({ [key]: value });
-  }
-  /**
-   * Check if a tool:command pattern is allowed
-   */
-  async isAllowed(tool, command) {
-    const s = await this.load();
-    const pattern = `${tool}:${command}`;
-    for (const deny of s.permissions.deny) {
-      if (this.matchPattern(pattern, deny)) {
-        return false;
-      }
-    }
-    for (const allow of s.permissions.allow) {
-      if (this.matchPattern(pattern, allow)) {
-        return true;
-      }
-    }
-    return false;
+    await fs4.writeFile(this.configPath, JSON.stringify(config2, null, 2));
+    this.clearCache();
   }
-  /**
-   * Check if a tool:command pattern is explicitly denied
-   */
-  async isDenied(tool, command) {
-    const s = await this.load();
-    const pattern = `${tool}:${command}`;
-    for (const deny of s.permissions.deny) {
-      if (this.matchPattern(pattern, deny)) {
-        return true;
-      }
+  async exists() {
+    try {
+      await fs4.access(this.configPath);
+      return true;
+    } catch {
+      return false;
     }
-    return false;
-  }
-  /**
-   * Simple glob-like pattern matching
-   * Supports * as wildcard
-   */
-  matchPattern(value, pattern) {
-    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-    return new RegExp(`^${regex}$`).test(value);
-  }
-  clearCache() {
-    this.cached = null;
   }
   getPath() {
-    return this.settingsPath;
+    return this.configPath;
   }
 };
-var settings = new SettingsManager();
+var config = new ConfigManager();
 
 // src/core/context.ts
+import fs5 from "fs/promises";
+import path5 from "path";
 var CONTEXT_DIR = ".obsidian";
 var CONTEXT_FILE = "context.json";
 function generateSessionId() {
@@ -1079,8 +1336,8 @@ import Anthropic from "@anthropic-ai/sdk";
 // src/core/tools.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 
 // src/core/auditor.ts
 import path6 from "path";
@@ -1095,12 +1352,17 @@ var BLOCKED_PATTERNS = [
   "mkfs",
   "dd if=",
   "chmod -R 777",
-  ":(){ :|:& };:",
-  "curl | sh",
-  // Pipe to shell
-  "wget | sh",
-  "curl | bash",
-  "wget | bash"
+  ":(){ :|:& };:"
+];
+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" },
@@ -1127,6 +1389,13 @@ var Auditor = class {
         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,
@@ -1143,7 +1412,7 @@ var Auditor = class {
     for (const { pattern, reason } of APPROVAL_PATTERNS) {
       if (lowerCommand.includes(pattern.toLowerCase())) {
         return {
-          approved: true,
+          approved: false,
           requiresApproval: true,
           reason
         };
@@ -1152,7 +1421,7 @@ var Auditor = class {
     const s = await settings.load();
     if (s.mode === "safe") {
       return {
-        approved: true,
+        approved: false,
         requiresApproval: true,
         reason: "Safe mode requires approval for all commands"
       };
@@ -1449,56 +1718,279 @@ var UndoManager = class {
     if (toUndo.length === 0) {
       return { success: false, message: "Nothing to undo" };
     }
-    const results = [];
-    for (const change of toUndo) {
-      try {
-        const fullPath = path7.resolve(process.cwd(), change.filePath);
-        switch (change.operation) {
-          case "create":
-            await fs7.unlink(fullPath);
-            results.push(`Deleted: ${change.filePath}`);
-            break;
-          case "edit":
-            if (change.beforeContent !== null) {
-              await fs7.writeFile(fullPath, change.beforeContent, "utf-8");
-              results.push(`Restored: ${change.filePath}`);
-            }
-            break;
-          case "delete":
-            if (change.beforeContent !== null) {
-              await fs7.mkdir(path7.dirname(fullPath), { recursive: true });
-              await fs7.writeFile(fullPath, change.beforeContent, "utf-8");
-              results.push(`Restored: ${change.filePath}`);
-            }
-            break;
-        }
-        change.undone = true;
-        if (this.dbEnabled && this.prisma) {
-          await this.prisma.fileChange.update({
-            where: { id: change.id },
-            data: { undone: true }
-          }).catch(() => {
-          });
+    const results = [];
+    for (const change of toUndo) {
+      try {
+        const fullPath = path7.resolve(process.cwd(), change.filePath);
+        switch (change.operation) {
+          case "create":
+            await fs7.unlink(fullPath);
+            results.push(`Deleted: ${change.filePath}`);
+            break;
+          case "edit":
+            if (change.beforeContent !== null) {
+              await fs7.writeFile(fullPath, change.beforeContent, "utf-8");
+              results.push(`Restored: ${change.filePath}`);
+            }
+            break;
+          case "delete":
+            if (change.beforeContent !== null) {
+              await fs7.mkdir(path7.dirname(fullPath), { recursive: true });
+              await fs7.writeFile(fullPath, change.beforeContent, "utf-8");
+              results.push(`Restored: ${change.filePath}`);
+            }
+            break;
+        }
+        change.undone = true;
+        if (this.dbEnabled && this.prisma) {
+          await this.prisma.fileChange.update({
+            where: { id: change.id },
+            data: { undone: true }
+          }).catch(() => {
+          });
+        }
+      } 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() {
+    if (this.prisma) {
+      await this.prisma.$disconnect();
+    }
+  }
+};
+var undo = new UndoManager();
+
+// src/core/auditLog.ts
+import fs8 from "fs/promises";
+import path8 from "path";
+var LOG_DIR = ".obsidian";
+var LOG_FILE = "audit.log";
+var MAX_LOG_SIZE = 10 * 1024 * 1024;
+var AuditLogger = class {
+  logPath;
+  sessionId;
+  enabled = true;
+  writeQueue = [];
+  isWriting = false;
+  constructor() {
+    this.logPath = path8.join(process.cwd(), LOG_DIR, LOG_FILE);
+    this.sessionId = `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  }
+  /**
+   * Initialize the audit logger
+   */
+  async init() {
+    const s = await settings.load();
+    this.enabled = s.security?.auditLogging ?? true;
+    if (!this.enabled) return;
+    const dir = path8.dirname(this.logPath);
+    await fs8.mkdir(dir, { recursive: true });
+    await this.rotateIfNeeded();
+    await this.log({
+      eventType: "session_start",
+      success: true,
+      metadata: {
+        cwd: process.cwd(),
+        pid: process.pid,
+        nodeVersion: process.version
+      }
+    });
+  }
+  /**
+   * Set the session ID (called from agent)
+   */
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  /**
+   * Enable or disable logging
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Log a command execution
+   */
+  async logCommand(command, success, reason) {
+    await this.log({
+      eventType: success ? "command_executed" : "command_blocked",
+      tool: "bash",
+      command,
+      success,
+      reason
+    });
+  }
+  /**
+   * Log a file operation
+   */
+  async logFileOperation(operation, filePath, success, reason) {
+    const eventMap = {
+      read: "file_read",
+      write: "file_write",
+      edit: "file_edit",
+      delete: "file_delete"
+    };
+    await this.log({
+      eventType: eventMap[operation],
+      filePath,
+      success,
+      reason
+    });
+  }
+  /**
+   * Log an approval decision
+   */
+  async logApproval(status, command, reason) {
+    const eventMap = {
+      requested: "approval_requested",
+      granted: "approval_granted",
+      denied: "approval_denied",
+      timeout: "approval_timeout"
+    };
+    await this.log({
+      eventType: eventMap[status],
+      command,
+      success: status === "granted",
+      reason
+    });
+  }
+  /**
+   * Log a security violation
+   */
+  async logSecurityViolation(command, reason) {
+    await this.log({
+      eventType: "security_violation",
+      command,
+      success: false,
+      reason
+    });
+  }
+  /**
+   * Log PII redaction
+   */
+  async logRedaction(count, types) {
+    await this.log({
+      eventType: "pii_redacted",
+      success: true,
+      metadata: { count, types }
+    });
+  }
+  /**
+   * Core logging function
+   */
+  async log(entry) {
+    if (!this.enabled) return;
+    const fullEntry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: this.sessionId,
+      ...entry
+    };
+    this.writeQueue.push(fullEntry);
+    if (!this.isWriting) {
+      await this.processQueue();
+    }
+  }
+  /**
+   * Process the write queue
+   */
+  async processQueue() {
+    if (this.isWriting || this.writeQueue.length === 0) return;
+    this.isWriting = true;
+    try {
+      const entries = [...this.writeQueue];
+      this.writeQueue = [];
+      const lines = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+      await fs8.appendFile(this.logPath, lines, { encoding: "utf-8", mode: 384 });
+    } catch (error) {
+    } finally {
+      this.isWriting = false;
+      if (this.writeQueue.length > 0) {
+        setImmediate(() => this.processQueue());
+      }
+    }
+  }
+  /**
+   * Rotate log file if too large
+   */
+  async rotateIfNeeded() {
+    try {
+      const stats = await fs8.stat(this.logPath);
+      if (stats.size >= MAX_LOG_SIZE) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        const rotatedPath = this.logPath.replace(".log", `.${timestamp}.log`);
+        await fs8.rename(this.logPath, rotatedPath);
+        await this.cleanupOldLogs();
+      }
+    } catch {
+    }
+  }
+  /**
+   * Clean up old rotated log files
+   */
+  async cleanupOldLogs() {
+    try {
+      const dir = path8.dirname(this.logPath);
+      const files = await fs8.readdir(dir);
+      const auditLogs = files.filter((f) => f.startsWith("audit.") && f.endsWith(".log") && f !== "audit.log").sort().reverse();
+      for (const file of auditLogs.slice(5)) {
+        await fs8.unlink(path8.join(dir, file));
+      }
+    } catch {
+    }
+  }
+  /**
+   * Read recent audit entries
+   */
+  async getRecentEntries(count = 100) {
+    try {
+      const content = await fs8.readFile(this.logPath, "utf-8");
+      const lines = content.trim().split("\n").filter((l) => l);
+      const entries = lines.slice(-count).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
         }
-      } catch (error) {
-        results.push(`Failed: ${change.filePath} - ${error.message}`);
-      }
+      }).filter((e) => e !== null);
+      return entries;
+    } catch {
+      return [];
     }
-    return {
-      success: true,
-      message: results.join("\n")
-    };
   }
-  getHistory(limit = 10) {
-    return this.changes.filter((c) => !c.undone).slice(0, limit);
+  /**
+   * Search audit log by event type or command
+   */
+  async search(query) {
+    const entries = await this.getRecentEntries(1e3);
+    return entries.filter((e) => {
+      if (query.eventType && e.eventType !== query.eventType) return false;
+      if (query.command && (!e.command || !e.command.includes(query.command))) return false;
+      if (query.since && new Date(e.timestamp) < query.since) return false;
+      return true;
+    });
   }
+  /**
+   * Log session end (call on shutdown)
+   */
   async close() {
-    if (this.prisma) {
-      await this.prisma.$disconnect();
-    }
+    if (!this.enabled) return;
+    await this.log({
+      eventType: "session_end",
+      success: true
+    });
+    await this.processQueue();
   }
 };
-var undo = new UndoManager();
+var auditLog = new AuditLogger();
 
 // src/core/tools.ts
 var execAsync2 = promisify2(exec2);
@@ -1554,22 +2046,26 @@ var BashTool = {
       return { success: false, error: "No command provided" };
     }
     const audit = await auditor.checkCommand(command);
-    if (!audit.approved) {
+    if (!audit.approved && audit.isCritical) {
+      await auditLog.logSecurityViolation(command, audit.reason || "Critical security violation");
       return {
         success: false,
         error: `Security violation: ${audit.reason}`
       };
     }
-    if (audit.requiresApproval && !audit.autoApproved) {
+    if (!audit.approved && audit.requiresApproval) {
+      await auditLog.logApproval("requested", command, audit.reason);
       const approved = await requestApproval(command, audit.reason || "Potentially dangerous operation");
       if (!approved) {
         await settings.addDeniedPermission("bash", command);
+        await auditLog.logApproval("denied", command);
         return {
           success: false,
           error: "Command rejected by user"
         };
       }
       await settings.addAllowedPermission("bash", command);
+      await auditLog.logApproval("granted", command);
     }
     try {
       const execCommand = await sandbox.wrapCommand(command);
@@ -1581,11 +2077,13 @@ var BashTool = {
         // 1MB buffer (reduced from 10MB)
       });
       const output = stdout || stderr || "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"
@@ -1615,8 +2113,8 @@ var ReadTool = {
       };
     }
     try {
-      const fullPath = path8.resolve(process.cwd(), filePath);
-      const content = await fs8.readFile(fullPath, "utf-8");
+      const fullPath = path9.resolve(process.cwd(), filePath);
+      const content = await fs9.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");
@@ -1624,6 +2122,7 @@ var ReadTool = {
 
 ... [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)
@@ -1631,6 +2130,7 @@ ${"=".repeat(60)}
 ${numbered}${truncationNote}`)
       };
     } catch (error) {
+      await auditLog.logFileOperation("read", filePath, false, error.message);
       return {
         success: false,
         error: `Failed to read file: ${error.message}`
@@ -1658,24 +2158,26 @@ var WriteTool = {
       };
     }
     try {
-      const fullPath = path8.resolve(process.cwd(), filePath);
+      const fullPath = path9.resolve(process.cwd(), filePath);
       try {
-        await fs8.access(fullPath);
+        await fs9.access(fullPath);
         return {
           success: false,
           error: `File already exists: ${filePath}. Use 'edit' tool to modify.`
         };
       } catch {
       }
-      await fs8.mkdir(path8.dirname(fullPath), { recursive: true });
-      await fs8.writeFile(fullPath, content, "utf-8");
+      await fs9.mkdir(path9.dirname(fullPath), { recursive: true });
+      await fs9.writeFile(fullPath, content, "utf-8");
       await context.trackModified(filePath);
       await undo.recordChange(filePath, "create", null, content);
+      await auditLog.logFileOperation("write", filePath, true);
       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}`
@@ -1707,29 +2209,33 @@ var EditTool = {
       };
     }
     try {
-      const fullPath = path8.resolve(process.cwd(), filePath);
-      const original = await fs8.readFile(fullPath, "utf-8");
+      const fullPath = path9.resolve(process.cwd(), filePath);
+      const original = await fs9.readFile(fullPath, "utf-8");
       if (!original.includes(search)) {
         return {
           success: false,
           error: `Search string not found in ${filePath}`
         };
       }
-      const modified = original.replace(search, replace);
+      const occurrences = original.split(search).length - 1;
+      const modified = original.replaceAll(search, replace);
       const diffPreview = generateDiffPreview(search, replace);
-      await fs8.writeFile(fullPath, modified, "utf-8");
+      await fs9.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);
+      const occurrenceText = occurrences > 1 ? ` (${occurrences} occurrences)` : "";
       return {
         success: true,
-        output: `Edited ${filePath}:
+        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}`
@@ -1772,8 +2278,8 @@ var ListTool = {
       };
     }
     try {
-      const fullPath = path8.resolve(process.cwd(), dirPath);
-      const entries = await fs8.readdir(fullPath, { withFileTypes: true });
+      const fullPath = path9.resolve(process.cwd(), dirPath);
+      const entries = await fs9.readdir(fullPath, { withFileTypes: true });
       const filtered = entries.filter(
         (entry) => !IGNORED_DIRS.includes(entry.name) && !entry.name.startsWith(".")
       );
@@ -1817,7 +2323,7 @@ var GrepTool = {
       };
     }
     try {
-      const fullPath = path8.resolve(process.cwd(), searchPath);
+      const fullPath = path9.resolve(process.cwd(), searchPath);
       const results = [];
       await searchDirectory(fullPath, pattern, results, maxResults);
       if (results.length === 0) {
@@ -1843,23 +2349,23 @@ ${results.join("\n")}`)
 async function searchDirectory(dir, pattern, results, maxResults, depth = 0) {
   if (results.length >= maxResults || depth > 10) return;
   try {
-    const entries = await fs8.readdir(dir, { withFileTypes: true });
+    const entries = await fs9.readdir(dir, { withFileTypes: true });
     const regex = new RegExp(pattern, "gi");
     for (const entry of entries) {
       if (results.length >= maxResults) break;
-      const fullPath = path8.join(dir, entry.name);
-      const relativePath = path8.relative(process.cwd(), fullPath);
+      const fullPath = path9.join(dir, entry.name);
+      const relativePath = path9.relative(process.cwd(), fullPath);
       if (entry.name.startsWith(".") || IGNORED_DIRS.includes(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
         await searchDirectory(fullPath, pattern, results, maxResults, depth + 1);
       } else if (entry.isFile()) {
-        const ext = path8.extname(entry.name).toLowerCase();
+        const ext = path9.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 fs8.readFile(fullPath, "utf-8");
+            const content = await fs9.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])) {
@@ -1886,7 +2392,7 @@ var GlobTool = {
     }
     try {
       const results = [];
-      const fullBase = path8.resolve(process.cwd(), basePath);
+      const fullBase = path9.resolve(process.cwd(), basePath);
       await globSearch(fullBase, pattern, results, 100);
       if (results.length === 0) {
         return {
@@ -1910,7 +2416,7 @@ ${results.join("\n")}`)
 async function globSearch(dir, pattern, results, maxResults, depth = 0) {
   if (results.length >= maxResults || depth > 15) return;
   try {
-    const entries = await fs8.readdir(dir, { withFileTypes: true });
+    const entries = await fs9.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) {
@@ -1918,8 +2424,8 @@ async function globSearch(dir, pattern, results, maxResults, depth = 0) {
       if (entry.name.startsWith(".") || IGNORED_DIRS.includes(entry.name)) {
         continue;
       }
-      const fullPath = path8.join(dir, entry.name);
-      const relativePath = path8.relative(process.cwd(), fullPath);
+      const fullPath = path9.join(dir, entry.name);
+      const relativePath = path9.relative(process.cwd(), fullPath);
       if (entry.isDirectory()) {
         if (pattern.includes("**") || pattern.includes("/")) {
           await globSearch(fullPath, pattern, results, maxResults, depth + 1);
@@ -2048,6 +2554,520 @@ var ToolRegistry = class {
 };
 var tools = new ToolRegistry();
 
+// src/core/redactor.ts
+var BUILTIN_RULES = [
+  // Email addresses
+  {
+    name: "email",
+    pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+    replacement: "[REDACTED:email]",
+    enabled: true,
+    description: "Email addresses"
+  },
+  // Phone numbers (various formats) - must have separators to avoid false positives
+  {
+    name: "phone",
+    pattern: /(\+?1[-.\s])?\(?\d{3}\)?[-.\s]\d{3}[-.\s]\d{4}\b/g,
+    replacement: "[REDACTED:phone]",
+    enabled: true,
+    description: "Phone numbers (US format with separators)"
+  },
+  // Social Security Numbers
+  {
+    name: "ssn",
+    pattern: /\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b/g,
+    replacement: "[REDACTED:ssn]",
+    enabled: true,
+    description: "Social Security Numbers"
+  },
+  // Credit card numbers (basic patterns)
+  {
+    name: "credit-card",
+    pattern: /\b(?:4\d{3}|5[1-5]\d{2}|6(?:011|5\d{2})|3[47]\d{2})[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g,
+    replacement: "[REDACTED:credit-card]",
+    enabled: true,
+    description: "Credit card numbers"
+  },
+  // AWS Access Keys
+  {
+    name: "aws-access-key",
+    pattern: /\b(AKIA|ABIA|ACCA|ASIA)[A-Z0-9]{16}\b/g,
+    replacement: "[REDACTED:aws-key]",
+    enabled: true,
+    description: "AWS access key IDs"
+  },
+  // AWS Secret Keys (40 char base64-like)
+  {
+    name: "aws-secret-key",
+    pattern: /\b[A-Za-z0-9/+=]{40}\b/g,
+    replacement: (match) => {
+      if (/[A-Z]/.test(match) && /[a-z]/.test(match) && /[/+=]/.test(match)) {
+        return "[REDACTED:aws-secret]";
+      }
+      return match;
+    },
+    enabled: true,
+    description: "AWS secret access keys"
+  },
+  // Anthropic API Keys
+  {
+    name: "anthropic-key",
+    pattern: /\bsk-ant-[a-zA-Z0-9-_]{20,}/g,
+    replacement: "[REDACTED:anthropic-key]",
+    enabled: true,
+    description: "Anthropic API keys"
+  },
+  // OpenAI API Keys (start with sk- but not sk-ant-)
+  {
+    name: "openai-key",
+    pattern: /sk-(?!ant)[a-zA-Z0-9]{20,}/g,
+    replacement: "[REDACTED:openai-key]",
+    enabled: true,
+    description: "OpenAI API keys"
+  },
+  // Generic API keys (common patterns)
+  {
+    name: "api-key-generic",
+    pattern: /\b(api[_-]?key|apikey|api[_-]?secret|api[_-]?token)\s*[=:]\s*['"]?([a-zA-Z0-9_-]{20,})['"]?/gi,
+    replacement: (match) => {
+      const keyName = match.split(/[=:]/)[0].trim();
+      return `${keyName}=[REDACTED:api-key]`;
+    },
+    enabled: true,
+    description: "Generic API keys in config"
+  },
+  // Passwords in config files (various naming conventions)
+  {
+    name: "password-config",
+    pattern: /\b([A-Z_]*(?:PASSWORD|PASSWD|PWD|SECRET)[A-Z_]*)\s*[=:]\s*['"]?([^'"\s\n]{4,})['"]?/gi,
+    replacement: (match) => {
+      const keyName = match.split(/[=:]/)[0].trim();
+      return `${keyName}=[REDACTED:password]`;
+    },
+    enabled: true,
+    description: "Passwords in configuration"
+  },
+  // Private keys (PEM format)
+  {
+    name: "private-key",
+    pattern: /-----BEGIN\s+(RSA\s+)?PRIVATE\s+KEY-----[\s\S]*?-----END\s+(RSA\s+)?PRIVATE\s+KEY-----/g,
+    replacement: "[REDACTED:private-key]",
+    enabled: true,
+    description: "PEM private keys"
+  },
+  // JWT tokens
+  {
+    name: "jwt",
+    pattern: /\beyJ[a-zA-Z0-9_-]*\.eyJ[a-zA-Z0-9_-]*\.[a-zA-Z0-9_-]*/g,
+    replacement: "[REDACTED:jwt]",
+    enabled: true,
+    description: "JWT tokens"
+  },
+  // GitHub tokens (various prefixes)
+  {
+    name: "github-token",
+    pattern: /(ghp|gho|ghu|ghs|ghr)_[a-zA-Z0-9]{20,}/g,
+    replacement: "[REDACTED:github-token]",
+    enabled: true,
+    description: "GitHub tokens"
+  },
+  // Stripe keys
+  {
+    name: "stripe-key",
+    pattern: /\b(sk|pk)_(test|live)_[a-zA-Z0-9]{24,}/g,
+    replacement: "[REDACTED:stripe-key]",
+    enabled: true,
+    description: "Stripe API keys"
+  },
+  // IP addresses (private networks only by default)
+  {
+    name: "private-ip",
+    pattern: /\b(10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})\b/g,
+    replacement: "[REDACTED:private-ip]",
+    enabled: false,
+    // Disabled by default - may cause issues with code
+    description: "Private IP addresses"
+  }
+];
+var Redactor = class {
+  rules = [...BUILTIN_RULES];
+  enabled = true;
+  allowlist = /* @__PURE__ */ new Set();
+  /**
+   * Enable or disable redaction globally
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Check if redaction is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Enable or disable a specific rule
+   */
+  setRuleEnabled(ruleName, enabled) {
+    const rule = this.rules.find((r) => r.name === ruleName);
+    if (rule) {
+      rule.enabled = enabled;
+    }
+  }
+  /**
+   * Add a pattern to the allowlist (won't be redacted)
+   */
+  addToAllowlist(pattern) {
+    this.allowlist.add(pattern);
+  }
+  /**
+   * Remove a pattern from the allowlist
+   */
+  removeFromAllowlist(pattern) {
+    this.allowlist.delete(pattern);
+  }
+  /**
+   * Add a custom redaction rule
+   */
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+  /**
+   * Get all available rules
+   */
+  getRules() {
+    return this.rules;
+  }
+  /**
+   * Redact sensitive information from text
+   */
+  redact(text) {
+    if (!this.enabled || !text) {
+      return { text, redactionCount: 0, redactedTypes: [] };
+    }
+    let result = text;
+    let totalRedactions = 0;
+    const redactedTypes = /* @__PURE__ */ new Set();
+    for (const rule of this.rules) {
+      if (!rule.enabled) continue;
+      rule.pattern.lastIndex = 0;
+      const matches = text.match(rule.pattern);
+      if (matches) {
+        for (const match of matches) {
+          if (this.allowlist.has(match)) continue;
+          const replacement = typeof rule.replacement === "function" ? rule.replacement(match) : rule.replacement;
+          if (replacement !== match) {
+            result = result.replace(match, replacement);
+            totalRedactions++;
+            redactedTypes.add(rule.name);
+          }
+        }
+      }
+    }
+    return {
+      text: result,
+      redactionCount: totalRedactions,
+      redactedTypes: Array.from(redactedTypes)
+    };
+  }
+  /**
+   * Redact tool output specifically (used before sending to LLM)
+   */
+  redactToolOutput(toolName, output) {
+    return this.redact(output);
+  }
+  /**
+   * Check if text contains any sensitive patterns
+   */
+  containsSensitiveData(text) {
+    if (!text) {
+      return { hasSensitive: false, types: [] };
+    }
+    const types = [];
+    for (const rule of this.rules) {
+      if (!rule.enabled) continue;
+      rule.pattern.lastIndex = 0;
+      if (rule.pattern.test(text)) {
+        types.push(rule.name);
+      }
+    }
+    return { hasSensitive: types.length > 0, types };
+  }
+  /**
+   * Get statistics about what would be redacted
+   */
+  analyze(text) {
+    const stats = [];
+    for (const rule of this.rules) {
+      if (!rule.enabled) continue;
+      rule.pattern.lastIndex = 0;
+      const matches = text.match(rule.pattern) || [];
+      if (matches.length > 0) {
+        stats.push({
+          ruleName: rule.name,
+          count: matches.length,
+          // Only show first 3 examples, partially masked
+          examples: matches.slice(0, 3).map(
+            (m) => m.length > 10 ? m.slice(0, 5) + "..." + m.slice(-3) : "***"
+          )
+        });
+      }
+    }
+    return stats;
+  }
+};
+var redactor = new Redactor();
+
+// src/core/keyManager.ts
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import fs10 from "fs/promises";
+import path10 from "path";
+import os5 from "os";
+import crypto from "crypto";
+var execAsync3 = promisify3(exec3);
+var ROTATION_CHECK_INTERVAL = 4 * 60 * 60 * 1e3;
+var SERVICE_NAME = "obsidian-next";
+var ACCOUNT_NAME = "anthropic-api-key";
+var KeyManager = class {
+  currentKey = null;
+  encryptedFilePath;
+  machineId = null;
+  constructor() {
+    this.encryptedFilePath = path10.join(os5.homedir(), ".obsidian", ".keystore");
+  }
+  /**
+   * Load API key from the most secure available backend
+   */
+  async loadKey() {
+    if (this.currentKey && !this.shouldRotate()) {
+      return this.currentKey.key;
+    }
+    let key = null;
+    let backend = "env";
+    key = process.env.ANTHROPIC_API_KEY || null;
+    if (key) {
+      backend = "env";
+    }
+    if (!key && process.platform === "darwin") {
+      key = await this.loadFromKeychain();
+      if (key) backend = "keychain";
+    }
+    if (!key && process.platform === "linux") {
+      key = await this.loadFromSecretTool();
+      if (key) backend = "secret-tool";
+    }
+    if (!key) {
+      key = await this.loadFromEncryptedFile();
+      if (key) backend = "encrypted-file";
+    }
+    if (key) {
+      this.currentKey = {
+        key,
+        loadedAt: Date.now(),
+        backend
+      };
+    }
+    return key;
+  }
+  /**
+   * Store API key in the most secure available backend
+   */
+  async storeKey(key) {
+    if (process.platform === "darwin") {
+      const result2 = await this.storeInKeychain(key);
+      if (result2.success) {
+        this.currentKey = { key, loadedAt: Date.now(), backend: "keychain" };
+        return { success: true, backend: "keychain" };
+      }
+    }
+    if (process.platform === "linux") {
+      const result2 = await this.storeInSecretTool(key);
+      if (result2.success) {
+        this.currentKey = { key, loadedAt: Date.now(), backend: "secret-tool" };
+        return { success: true, backend: "secret-tool" };
+      }
+    }
+    const result = await this.storeInEncryptedFile(key);
+    if (result.success) {
+      this.currentKey = { key, loadedAt: Date.now(), backend: "encrypted-file" };
+      return { success: true, backend: "encrypted-file" };
+    }
+    return { success: false, backend: "env", error: result.error };
+  }
+  /**
+   * Delete stored key from all backends
+   */
+  async deleteKey() {
+    this.currentKey = null;
+    if (process.platform === "darwin") {
+      await this.deleteFromKeychain();
+    }
+    if (process.platform === "linux") {
+      await this.deleteFromSecretTool();
+    }
+    try {
+      await fs10.unlink(this.encryptedFilePath);
+    } catch {
+    }
+  }
+  /**
+   * Check if key should be rotated (for long-running sessions)
+   */
+  shouldRotate() {
+    if (!this.currentKey) return true;
+    return Date.now() - this.currentKey.loadedAt > ROTATION_CHECK_INTERVAL;
+  }
+  /**
+   * Force reload key from backend
+   */
+  async refreshKey() {
+    this.currentKey = null;
+    return this.loadKey();
+  }
+  /**
+   * Get current backend being used
+   */
+  getBackend() {
+    return this.currentKey?.backend || null;
+  }
+  // ==================== macOS Keychain ====================
+  async loadFromKeychain() {
+    try {
+      const { stdout } = await execAsync3(
+        `security find-generic-password -s "${SERVICE_NAME}" -a "${ACCOUNT_NAME}" -w 2>/dev/null`
+      );
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  async storeInKeychain(key) {
+    try {
+      await this.deleteFromKeychain();
+      await execAsync3(
+        `security add-generic-password -s "${SERVICE_NAME}" -a "${ACCOUNT_NAME}" -w "${key}" -U`
+      );
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+  async deleteFromKeychain() {
+    try {
+      await execAsync3(
+        `security delete-generic-password -s "${SERVICE_NAME}" -a "${ACCOUNT_NAME}" 2>/dev/null`
+      );
+    } catch {
+    }
+  }
+  // ==================== Linux secret-tool ====================
+  async loadFromSecretTool() {
+    try {
+      const { stdout } = await execAsync3(
+        `secret-tool lookup service "${SERVICE_NAME}" account "${ACCOUNT_NAME}" 2>/dev/null`
+      );
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  async storeInSecretTool(key) {
+    try {
+      await execAsync3(
+        `echo -n "${key}" | secret-tool store --label="Obsidian Next API Key" service "${SERVICE_NAME}" account "${ACCOUNT_NAME}"`
+      );
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+  async deleteFromSecretTool() {
+    try {
+      await execAsync3(
+        `secret-tool clear service "${SERVICE_NAME}" account "${ACCOUNT_NAME}" 2>/dev/null`
+      );
+    } catch {
+    }
+  }
+  // ==================== Encrypted File ====================
+  async getMachineId() {
+    if (this.machineId) return this.machineId;
+    const components = [
+      os5.hostname(),
+      os5.userInfo().username,
+      os5.platform(),
+      os5.arch()
+    ];
+    if (process.platform === "darwin") {
+      try {
+        const { stdout } = await execAsync3("ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID");
+        const match = stdout.match(/"IOPlatformUUID" = "([^"]+)"/);
+        if (match) components.push(match[1]);
+      } catch {
+      }
+    } else if (process.platform === "linux") {
+      try {
+        const machineId = await fs10.readFile("/etc/machine-id", "utf-8");
+        components.push(machineId.trim());
+      } catch {
+      }
+    }
+    this.machineId = crypto.createHash("sha256").update(components.join(":")).digest("hex");
+    return this.machineId;
+  }
+  async deriveEncryptionKey() {
+    const machineId = await this.getMachineId();
+    return crypto.pbkdf2Sync(machineId, "obsidian-next-salt", 1e5, 32, "sha256");
+  }
+  async loadFromEncryptedFile() {
+    try {
+      const encrypted = await fs10.readFile(this.encryptedFilePath, "utf-8");
+      const data = JSON.parse(encrypted);
+      const key = await this.deriveEncryptionKey();
+      const iv = Buffer.from(data.iv, "hex");
+      const authTag = Buffer.from(data.tag, "hex");
+      const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+      decipher.setAuthTag(authTag);
+      let decrypted = decipher.update(data.encrypted, "hex", "utf-8");
+      decrypted += decipher.final("utf-8");
+      return decrypted;
+    } catch {
+      return null;
+    }
+  }
+  async storeInEncryptedFile(apiKey) {
+    try {
+      const key = await this.deriveEncryptionKey();
+      const iv = crypto.randomBytes(16);
+      const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+      let encrypted = cipher.update(apiKey, "utf-8", "hex");
+      encrypted += cipher.final("hex");
+      const authTag = cipher.getAuthTag();
+      const data = {
+        encrypted,
+        iv: iv.toString("hex"),
+        tag: authTag.toString("hex"),
+        version: 1
+      };
+      await fs10.mkdir(path10.dirname(this.encryptedFilePath), { recursive: true });
+      await fs10.writeFile(this.encryptedFilePath, JSON.stringify(data), { mode: 384 });
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Clear key from memory (call when done with sensitive operations)
+   */
+  clearFromMemory() {
+    if (this.currentKey) {
+      this.currentKey = null;
+    }
+  }
+};
+var keyManager = new KeyManager();
+
 // src/core/llm.ts
 var MAX_TOOL_ITERATIONS = 10;
 var LLMClient = class {
@@ -2060,19 +3080,44 @@ var LLMClient = class {
   async initialize() {
     const cfg = await config.load();
     await usage.init();
-    if (!cfg.apiKey) {
+    let apiKey = await keyManager.loadKey();
+    if (!apiKey) {
+      apiKey = cfg.apiKey || null;
+    }
+    if (!apiKey) {
       bus.emitAgent({
         type: "error",
-        message: "Missing ANTHROPIC_API_KEY. Please set it in .env or via /init."
+        message: "Missing ANTHROPIC_API_KEY. Set via environment, keychain, or /init command."
       });
       return false;
     }
     this.client = new Anthropic({
-      apiKey: cfg.apiKey
+      apiKey
     });
     this.lastConfig = cfg;
+    const backend = keyManager.getBackend();
+    if (backend && backend !== "env") {
+      bus.emitAgent({
+        type: "thought",
+        content: `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;
+  }
   async streamChat(userMessage) {
     if (!this.client) {
       const initialized = await this.initialize();
@@ -2220,10 +3265,20 @@ cwd: ${process.cwd()}`;
         const toolResults = [];
         for (const toolUse of toolUses) {
           const result = await tools.execute(toolUse.name, toolUse.input);
+          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): ${redactionResult.redactedTypes.join(", ")}`,
+              hidden: true
+            });
+          }
           toolResults.push({
             type: "tool_result",
             tool_use_id: toolUse.id,
-            content: result.success ? result.output || "Success" : result.error || "Failed",
+            content: outputContent,
             is_error: !result.success
           });
         }
@@ -2358,24 +3413,24 @@ cwd: ${process.cwd()}`;
 var llm = new LLMClient();
 
 // src/core/tasks.ts
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs11 from "fs/promises";
+import path11 from "path";
 var TASKS_DIR = ".obsidian";
 var TASKS_FILE = "tasks.md";
 var TaskTracker = class {
   task = null;
   tasksPath;
   constructor() {
-    this.tasksPath = path9.join(process.cwd(), TASKS_DIR, TASKS_FILE);
+    this.tasksPath = path11.join(process.cwd(), TASKS_DIR, TASKS_FILE);
   }
   async init() {
-    const dir = path9.join(process.cwd(), TASKS_DIR);
-    await fs9.mkdir(dir, { recursive: true });
+    const dir = path11.join(process.cwd(), TASKS_DIR);
+    await fs11.mkdir(dir, { recursive: true });
     await this.load();
   }
   async load() {
     try {
-      const content = await fs9.readFile(this.tasksPath, "utf-8");
+      const content = await fs11.readFile(this.tasksPath, "utf-8");
       this.task = this.parse(content);
     } catch {
       this.task = null;
@@ -2445,7 +3500,7 @@ var TaskTracker = class {
   }
   async save() {
     const content = this.serialize();
-    await fs9.writeFile(this.tasksPath, content);
+    await fs11.writeFile(this.tasksPath, content);
   }
   // Task management
   async create(title) {
@@ -2519,10 +3574,17 @@ var tasks = new TaskTracker();
 var Agent = class {
   initialized = false;
   pendingPlan = null;
+  sessionId;
+  constructor() {
+    this.sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  }
   async init() {
     if (this.initialized) return;
     await context.init();
     await tasks.init();
+    await undo.init(this.sessionId);
+    auditLog.setSessionId(this.sessionId);
+    await auditLog.init();
     this.initialized = true;
   }
   async run(input) {
@@ -2596,6 +3658,15 @@ ${this.formatPlan(plan)}`
 [Context: ${ctxSummary}]
 [${taskProgress}]`;
     }
+    const redactionResult = redactor.redact(enhancedInput);
+    if (redactionResult.redactionCount > 0) {
+      enhancedInput = redactionResult.text;
+      bus.emitAgent({
+        type: "thought",
+        content: `[Security] Redacted ${redactionResult.redactionCount} sensitive item(s) from context`,
+        hidden: true
+      });
+    }
     const response = await llm.streamChat(enhancedInput);
     if (response) {
       await context.setLastAction(input.slice(0, 50));
@@ -2698,18 +3769,19 @@ Execute each step carefully. Use available tools as needed.`;
 var agent = new Agent();
 
 // src/ui/Root.tsx
-import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
 var MAX_EVENTS = 50;
 var Root = () => {
-  const [events, setEvents] = useState4([]);
-  const [input, setInput] = useState4("");
-  const [pendingPrompt, setPendingPrompt] = useState4(null);
+  const [events, setEvents] = useState5([]);
+  const [input, setInput] = useState5("");
+  const [pendingPrompt, setPendingPrompt] = useState5(null);
   const { exit } = useApp();
-  const [stats, setStats] = useState4({ cost: 0, model: "Loading...", mode: "safe" });
-  const handlePromptResolve = useCallback3(() => {
+  const [stats, setStats] = useState5({ cost: 0, model: "Loading...", mode: "safe" });
+  const [showSettings, setShowSettings] = useState5(false);
+  const handlePromptResolve = useCallback4(() => {
     setPendingPrompt(null);
   }, []);
-  useEffect(() => {
+  useEffect2(() => {
     const updateStats = async () => {
       const cfg = await config.load();
       setStats({
@@ -2729,19 +3801,19 @@ var Root = () => {
       bus.off("agent", statHandler);
     };
   }, []);
-  useEffect(() => {
+  useEffect2(() => {
     history.load().then((loadedEvents) => {
       if (loadedEvents.length > 0) {
         setEvents(loadedEvents);
       }
     });
   }, []);
-  useEffect(() => {
+  useEffect2(() => {
     if (events.length > 0) {
       history.save(events);
     }
   }, [events]);
-  useEffect(() => {
+  useEffect2(() => {
     const handler = (event) => {
       if (event.type === "clear_history") {
         setEvents([]);
@@ -2789,22 +3861,22 @@ var Root = () => {
       bus.off("user", userHandler);
     };
   }, []);
-  const [inputKey, setInputKey] = useState4(0);
-  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const [inputKey, setInputKey] = useState5(0);
+  const [selectedIndex, setSelectedIndex] = useState5(0);
   const query = input.toLowerCase();
   const isCommand = input.startsWith("/");
   const matches = isCommand ? COMMANDS.filter((c) => c.name.startsWith(query)) : [];
-  useEffect(() => {
+  useEffect2(() => {
     setSelectedIndex(0);
   }, [input]);
-  const cycleMode = useCallback3(async () => {
+  const cycleMode = useCallback4(async () => {
     const modes = ["auto", "plan", "safe"];
     const currentIndex = modes.indexOf(stats.mode);
     const nextMode = modes[(currentIndex + 1) % modes.length];
     await agent.setMode(nextMode);
     setStats((prev) => ({ ...prev, mode: nextMode }));
   }, [stats.mode]);
-  useInput3((input2, key) => {
+  useInput4((input2, key) => {
     if (key.shift && key.tab) {
       cycleMode();
       return;
@@ -2836,21 +3908,26 @@ var Root = () => {
       exit();
       return;
     }
+    if (value.trim() === "/settings") {
+      setShowSettings(true);
+      setInput("");
+      return;
+    }
     bus.emitUser({ type: "user_input", content: value });
     setInput("");
   };
-  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", height: "100%", children: [
-    /* @__PURE__ */ jsx7(Dashboard, {}),
-    /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", flexGrow: 1, marginY: 1, overflowY: "hidden", justifyContent: "flex-end", children: events.slice(-MAX_EVENTS).map((event, i) => {
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx8(Dashboard, {}),
+    /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", flexGrow: 1, marginY: 1, overflowY: "hidden", justifyContent: "flex-end", children: events.slice(-MAX_EVENTS).map((event, i) => {
       let content = null;
       if (event.type === "user_input") {
-        content = /* @__PURE__ */ jsx7(Box7, { flexDirection: "row", paddingX: 1, marginBottom: 0, children: /* @__PURE__ */ jsxs7(Text7, { backgroundColor: "#222222", dimColor: true, children: [
-          /* @__PURE__ */ jsx7(Text7, { color: "gray", children: " > " }),
-          /* @__PURE__ */ jsx7(Text7, { color: "white", children: event.content }),
-          /* @__PURE__ */ jsx7(Text7, { children: " " })
+        content = /* @__PURE__ */ jsx8(Box8, { flexDirection: "row", paddingX: 1, marginBottom: 0, children: /* @__PURE__ */ jsxs8(Text8, { backgroundColor: "#222222", dimColor: true, children: [
+          /* @__PURE__ */ jsx8(Text8, { color: "gray", children: " > " }),
+          /* @__PURE__ */ jsx8(Text8, { color: "white", children: event.content }),
+          /* @__PURE__ */ jsx8(Text8, { children: " " })
         ] }) }, i);
       } else if (event.type === "thought") {
-        content = /* @__PURE__ */ jsx7(AgentLine, { content: event.content }, i);
+        content = /* @__PURE__ */ jsx8(AgentLine, { content: event.content }, i);
       } else if (event.type === "tool_start") {
         let argsSummary = "";
         try {
@@ -2861,37 +3938,37 @@ var Root = () => {
           }
         } catch {
         }
-        content = /* @__PURE__ */ jsxs7(Box7, { children: [
-          /* @__PURE__ */ jsx7(Text7, { backgroundColor: "#1a1a2e", color: "cyan", children: " \u23FA " }),
-          /* @__PURE__ */ jsxs7(Text7, { backgroundColor: "#1a1a2e", color: "white", bold: true, children: [
+        content = /* @__PURE__ */ jsxs8(Box8, { children: [
+          /* @__PURE__ */ jsx8(Text8, { backgroundColor: "#1a1a2e", color: "cyan", children: " \u23FA " }),
+          /* @__PURE__ */ jsxs8(Text8, { backgroundColor: "#1a1a2e", color: "white", bold: true, children: [
             " ",
             event.tool
           ] }),
-          /* @__PURE__ */ jsxs7(Text7, { backgroundColor: "#1a1a2e", color: "gray", children: [
+          /* @__PURE__ */ jsxs8(Text8, { backgroundColor: "#1a1a2e", color: "gray", children: [
             "(",
             argsSummary,
             ") "
           ] })
         ] }, i);
       } else if (event.type === "tool_result") {
-        content = /* @__PURE__ */ jsx7(ToolOutput, { tool: event.tool, output: event.output, isError: event.isError }, i);
+        content = /* @__PURE__ */ jsx8(ToolOutput, { tool: event.tool, output: event.output, isError: event.isError }, i);
       } else if (event.type === "done") {
-        content = /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
+        content = /* @__PURE__ */ jsxs8(Text8, { color: "green", children: [
           "[OK] ",
           event.summary
         ] }, i);
       } else if (event.type === "error") {
-        content = /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+        content = /* @__PURE__ */ jsxs8(Text8, { color: "red", children: [
           "[ERR] ",
           event.message
         ] }, i);
       } else if (event.type === "clear_history") {
-        content = /* @__PURE__ */ jsx7(Text7, { color: "gray", children: "[SYS] History cleared" }, i);
+        content = /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "[SYS] History cleared" }, i);
       }
       if (!content) return null;
-      return /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: content }, i);
+      return /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: content }, i);
     }) }),
-    pendingPrompt?.type === "approval" && /* @__PURE__ */ jsx7(
+    pendingPrompt?.type === "approval" && /* @__PURE__ */ jsx8(
       ApprovalPrompt,
       {
         requestId: pendingPrompt.requestId,
@@ -2900,7 +3977,7 @@ var Root = () => {
         onResolve: handlePromptResolve
       }
     ),
-    pendingPrompt?.type === "choice" && /* @__PURE__ */ jsx7(
+    pendingPrompt?.type === "choice" && /* @__PURE__ */ jsx8(
       ChoicePrompt,
       {
         question: pendingPrompt.question,
@@ -2908,17 +3985,18 @@ var Root = () => {
         onResolve: handlePromptResolve
       }
     ),
-    /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(
+    showSettings && /* @__PURE__ */ jsx8(SettingsMenu, { onClose: () => setShowSettings(false) }),
+    /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(
         CommandPopup,
         {
           matches,
           selectedIndex
         }
       ),
-      /* @__PURE__ */ jsxs7(Box7, { borderStyle: "round", borderColor: pendingPrompt ? "gray" : "gray", paddingX: 1, children: [
-        /* @__PURE__ */ jsx7(Text7, { color: "red", bold: true, children: "> " }),
-        /* @__PURE__ */ jsx7(
+      /* @__PURE__ */ jsxs8(Box8, { borderStyle: "round", borderColor: pendingPrompt ? "gray" : "gray", paddingX: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { color: "red", bold: true, children: "> " }),
+        /* @__PURE__ */ jsx8(
           TextInput,
           {
             value: input,
@@ -2932,8 +4010,8 @@ var Root = () => {
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsxs7(
-      Box7,
+    /* @__PURE__ */ jsxs8(
+      Box8,
       {
         borderStyle: "single",
         borderTop: false,
@@ -2945,20 +4023,20 @@ var Root = () => {
         flexDirection: "row",
         justifyContent: "space-between",
         children: [
-          /* @__PURE__ */ jsx7(Box7, { minWidth: 22, children: /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+          /* @__PURE__ */ jsx8(Box8, { minWidth: 22, children: /* @__PURE__ */ jsxs8(Text8, { color: "gray", children: [
             "[ ",
-            /* @__PURE__ */ jsx7(Text7, { color: stats.mode === "plan" ? "yellow" : stats.mode === "auto" ? "green" : "white", children: stats.mode === "auto" ? "auto-accept ON" : stats.mode === "plan" ? "plan mode" : "default" }),
+            /* @__PURE__ */ jsx8(Text8, { color: stats.mode === "plan" ? "yellow" : stats.mode === "auto" ? "green" : "white", children: stats.mode === "auto" ? "auto-accept ON" : stats.mode === "plan" ? "plan mode" : "default" }),
             " ]"
           ] }) }),
-          /* @__PURE__ */ jsx7(Box7, { minWidth: 20, children: /* @__PURE__ */ jsx7(Text7, { color: "gray", children: "[ Context: 0 files ]" }) }),
-          /* @__PURE__ */ jsx7(Box7, { minWidth: 25, justifyContent: "center", children: /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+          /* @__PURE__ */ jsx8(Box8, { minWidth: 20, children: /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "[ Context: 0 files ]" }) }),
+          /* @__PURE__ */ jsx8(Box8, { minWidth: 25, justifyContent: "center", children: /* @__PURE__ */ jsxs8(Text8, { color: "gray", children: [
             "[ Model: ",
-            /* @__PURE__ */ jsx7(Text7, { color: "white", children: stats.model }),
+            /* @__PURE__ */ jsx8(Text8, { color: "white", children: stats.model }),
             " ]"
           ] }) }),
-          /* @__PURE__ */ jsx7(Box7, { minWidth: 15, justifyContent: "flex-end", children: /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+          /* @__PURE__ */ jsx8(Box8, { minWidth: 15, justifyContent: "flex-end", children: /* @__PURE__ */ jsxs8(Text8, { color: "gray", children: [
             "[ Cost: ",
-            /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
+            /* @__PURE__ */ jsxs8(Text8, { color: "green", children: [
               "$",
               stats.cost.toFixed(4)
             ] }),
@@ -3138,15 +4216,15 @@ Usage: /tool <name> <json-args>`
 };
 
 // src/commands/status.ts
-import os5 from "os";
-import path10 from "path";
+import os6 from "os";
+import path12 from "path";
 var statusCommand = async (_args) => {
   const cfg = await config.load();
   const stats = usage.getStats();
-  const platform = `${os5.type()} ${os5.release()}`;
+  const platform = `${os6.type()} ${os6.release()}`;
   const nodeVersion = process.version;
   const workspace = process.cwd();
-  const workspaceName = path10.basename(workspace);
+  const workspaceName = path12.basename(workspace);
   const sessionCost = usage.getSessionCost();
   const toolList = tools.list().map((t) => t.name).join(", ");
   const statusLines = [
@@ -3713,7 +4791,7 @@ var supervisor = new Supervisor();
 async function main() {
   process.stdout.write("\x1B[?1049h");
   process.stdout.write("\x1Bc");
-  const { waitUntilExit, cleanup } = render(React7.createElement(Root), {
+  const { waitUntilExit, cleanup } = render(React8.createElement(Root), {
     patchConsole: false,
     exitOnCtrlC: true
   });