@aurora-foundation/obsidian-next 0.4.6 → 0.4.7

package/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.7] - 2026-02-07
+
+### Added
+- **Tool Tree Display**: Consecutive tool calls now display with tree connectors (`┌├└`) instead of sequential spam. Groups parallel operations visually.
+- **TaskView Enhancements**:
+  - Progress bar showing completion percentage (`████░░░░░░ 40%`)
+  - Polished checkbox icons (`☐` empty, `☑` done)
+  - Keyboard navigation: `j/k` to move, `x` to mark done
+  - Visual selection indicator with cyan highlighting
+- **Activity Indicator**: Thinking status now shows current operation (e.g., `⏳ read src/config.ts`) instead of generic "Thinking..."
+- **Color-Coded Mode Display**: Footer mode indicator now uses distinct colors:
+  - `▶ AUTO` (green) - Full autonomy
+  - `⏸ PLAN` (yellow) - Review before execute
+  - `⏺ SAFE` (red) - Ask for everything
+
+### Changed
+- **MessageList**: Refactored to group tool batches with visual hierarchy
+- **Anti-Flicker**: Consecutive tool results maintain visual connection with pipe prefix
+
+### Technical
+- Added `groupToolCalls()` function for tool batch detection
+- Enhanced `Root.tsx` with `currentActivity` state tracking
+
+---
+
 ## [0.4.6] - 2026-02-02
 
 ### Added

package/README.md

@@ -2,28 +2,29 @@
 
 ![Obsidian Next](assets/obsidianboxes.png)
 
-> This README was written by Obsidian (v0.4.6) - a self-aware AI agent with full OS access, persistent memory, and autonomous task execution.
+> This README was written by Obsidian (v0.4.6) - a global, always-on autonomous engineering daemon with adaptive reasoning and system-wide persistent memory.
 
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
 [![Version](https://img.shields.io/badge/Version-0.4.6-blue)](package.json)
-[![Status](https://img.shields.io/badge/Status-Stable-green)](CHANGELOG.md)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-3178C6?logo=typescript&logoColor=white)](tsconfig.json)
+[![Status](https://img.shields.io/badge/Status-Autonomous-green)](CHANGELOG.md)
+[![Claude 4.6](https://img.shields.io/badge/Model-Claude_4.6-purple)](docs/PRD.md)
 
-**Obsidian Next** is a terminal-native AI engineering assistant with full operating system access, persistent memory, and structured task execution.
+**Obsidian Next** is a global, always-on autonomous engineering partner. It runs as a system-wide background service, managing multiple codebases and performing proactive engineering tasks while you're away.
 
-Built for developers who need an agent that can actually *do things* - not just chat about them.
+Built for engineers who need an agent that lives in their system - not just in a terminal window.
 
 ---
 
-## What Makes Obsidian Different
+## What Makes Obsidian Autonomous
 
-| Feature | Obsidian | Other Assistants |
-|---------|----------|------------------|
-| **OS Access** | Full bash, file system, app control | Sandboxed or none |
-| **Memory** | Persistent across sessions (SQLite) | Per-conversation only |
-| **Task Tracking** | Built-in plan mode with step completion | Manual or none |
-| **Session Resume** | Full state restoration | Start fresh each time |
-| **Security** | Auditor + PII redaction + approval prompts | Trust the model |
+| Feature | Obsidian Next | Other Assistants |
+|---------|---------------|------------------|
+| **Lifecycle** | Always-on Daemon (Service) | Script / Process-bound |
+| **Reasoning** | Claude 4.6 Adaptive Thinking | Standard Chat |
+| **Context** | 1 Million Token Mastery | 128k - 200k fixed |
+| **Memory** | Semantic Vector Store (Hybrid) | Simple Chat History |
+| **Proactivity** | Heartbeat Background Tasks | Reactive Only |
+| **Scope** | Global (System-wide) | Project-locked |
 
 ---
 
@@ -33,65 +34,39 @@ Built for developers who need an agent that can actually *do things* - not just
 # Install globally
 npm install -g @aurora-foundation/obsidian-next
 
-# Run
-obsidian
+# Initialize global daemon and services
+obsidian init --service
 
-# First time setup
-/init
+# Check daemon status
+obsidian status
 ```
 
 ---
 
-## Core Features
+## Core Capabilities
 
-### Full OS Access
-Obsidian has unrestricted access to your operating system via bash. It can:
-- Open applications (`open`, `osascript`)
-- Control system settings
-- Run any shell command
-- Speak text aloud (`say` on macOS)
-- Manage clipboard (`pbcopy`/`pbpaste`)
+### Always-On Autonomy
+Obsidian runs as a background service (`launchd` or `systemd`). It doesn't die when you close your terminal. It keeps reasoning, indexing, and auditing in the background.
 
-```
-> open spotify and play some music
-> say "build complete" when the tests pass
-> organize my Downloads folder
-```
-
-### Three Execution Modes
-
-| Mode | Description | Use Case |
-|------|-------------|----------|
-| **Safe** (default) | Approval required for writes/commands | Daily use |
-| **Plan** | Read-only exploration, creates execution plan | Complex tasks |
-| **Auto** | Full autonomy, no confirmations | Trusted workflows |
+### Claude 4.6 Adaptive Reasoning
+Utilizing the latest **Thinking Blocks**, Obsidian modulates its reasoning effort based on task complexity. You can see its "Thinking Trace" in real-time before it acts.
 
-Toggle modes with `Shift+Tab` or `/mode`.
+### 1M Token Context window
+Hold entire repositories in active memory. Obsidian uses **Prompt Caching** and **Context Distillation** to keep massive windows cheap, fast, and coherent.
 
-### Persistent Memory
-Obsidian remembers you across sessions:
-- User preferences and project facts
-- Learned patterns and decisions
-- Session history with full restoration
+### Proactive Heartbeat (The Scheduler)
+Schedule background tasks to keep your systems healthy:
+- **Nightly Audits**: Scan for security vulnerabilities or dead code.
+- **Auto-Documentation**: Generate docstrings for new functions.
+- **Health Checks**: Run tests and notify you via Telegram if they break.
 
 ```
-> remember that I prefer tabs over spaces
-> what's my preferred testing framework?
+/schedule "0 2 * * *" system:audit
+/schedule "*/30 * * * *" system:sync_index
 ```
 
-### Task Tracking
-Built-in task management for multi-step work:
-- Automatic step creation in plan mode
-- Progress tracking with visual indicators
-- Resume incomplete tasks across sessions
-
-View tasks with `Ctrl+T` or `/task`.
-
-### Session Management
-Never lose your work:
-- `/exit` - Save session and quit
-- `/resume` - Browse and restore saved sessions
-- Full context, history, and task restoration
+### Self-Improving Skills
+Obsidian can autonomously expand its own toolbox. If it hits a capability gap, it writes, tests, and registers a new TypeScript tool in `~/.obsidian-next/skills/` without a restart.
 
 ---
 
@@ -99,93 +74,54 @@ Never lose your work:
 
 | Command | Description |
 |---------|-------------|
-| `/help` | Show all commands |
-| `/init` | Configure API key and model |
-| `/mode` | Switch execution mode |
-| `/context` | View token usage and session stats |
-| `/task` | View current task progress |
-| `/resume` | Restore a saved session |
-| `/mcp` | Manage Model Context Protocol servers |
-| `/clear` | Clear conversation history |
-| `/exit` | Save session and exit |
-
----
-
-## Keyboard Shortcuts
-
-| Shortcut | Action |
-|----------|--------|
-| `Shift+Tab` | Cycle execution mode |
-| `Ctrl+T` | Open task view |
-| `Ctrl+C` | Exit (saves session) |
-| `Escape` | Interrupt current operation |
-| `Tab` | Autocomplete command |
-| `Up/Down` | Navigate command suggestions |
+| `/schedule` | Manage proactive background tasks |
+| `/memory` | Export/sync the Semantic Knowledge Bank |
+| `/workspace`| Focus the agent on a specific project root |
+| `/pilot` | Secure GUI automation (Computer Use) |
+| `/status` | Monitor daemon health and 1M context usage |
+| `/resume` | Restore sessions from any workspace |
 
 ---
 
-## Architecture
-
+## Architecture (The Gateway Pattern)
+
+Obsidian Next operates via a central backend service connected to multiple frontends:
+
+```mermaid
+graph TD
+    subgraph "Interfaces"
+        CLI[CLI Frontend]
+        TG[Telegram Bot]
+        Web[Web UI]
+    end
+
+    subgraph "Always-On Daemon (Backend)"
+        Socket[Unix Domain Socket] <--> LaneQueue[Lane Queue]
+        LaneQueue <--> Agent[Agent Core]
+        Agent <--> Claude[Claude 4.6]
+        Agent <--> Tools[Self-Improving Tools]
+    end
+
+    subgraph "System State (~/.obsidian-next/)"
+        DB[(SQLite state.db)]
+        Vector[Semantic Memory]
+        MD[MEMORY.md / Logs]
+    end
+
+    CLI <--> Socket
+    TG <--> Socket
+    Web <--> Socket
+    Agent <--> DB
 ```
-User Input
-    |
-    v
-[Supervisor] --> /command --> [Command Registry]
-    |
-    v
-[Agent Runtime]
-    |
-    +---> [Auditor] --> Security checks
-    |
-    +---> [Tools] --> bash, read, write, edit, grep, glob, web_fetch
-    |
-    +---> [Memory] --> SQLite persistent store
-    |
-    v
-[Event Bus] --> [Terminal UI]
-```
-
-All state is stored locally in `.obsidian/state.db` (SQLite).
 
 ---
 
-## Security
-
-- **Auditor**: Pre-flight validation of all commands and file operations
-- **PII Redaction**: Automatic sanitation of sensitive data from LLM context
-- **Approval Prompts**: Explicit confirmation for destructive operations
-- **Secure Storage**: System Keychain integration for API keys
-- **Audit Logging**: Complete trail of all agent actions
-
----
-
-## Model Support
-
-Obsidian works with Claude 4.5 models:
-
-| Model | Best For |
-|-------|----------|
-| **Opus 4.5** | Complex reasoning, architecture decisions |
-| **Sonnet 4.5** | Balanced performance (default) |
-| **Haiku 4.5** | Fast responses, simple tasks |
-
-Configure with `/init` or `/models`.
-
----
-
-## MCP Integration
-
-Extend Obsidian with Model Context Protocol servers:
-
-```
-/mcp
-```
+## Security & Safety
 
-Install certified tools:
-- `filesystem` - Enhanced file operations
-- `git` - Repository management
-- `research` - Web search and analysis
-- `context7` - Documentation lookup
+- **Global Auditor**: Centralized security policy for all projects.
+- **Lane Queue**: Prevents race conditions during concurrent access.
+- **Visual Privacy Guard**: Redacts sensitive data from screenshots in Pilot Mode.
+- **Kill Switch**: Immediate local or remote termination of all autonomous activity.
 
 ---
 
@@ -193,10 +129,10 @@ Install certified tools:
 
 | Resource | Description |
 |----------|-------------|
-| [Architecture](docs/ARCHITECTURE.md) | System internals and design |
-| [Tools Reference](docs/TOOLS.md) | Built-in tool documentation |
-| [Sandboxing](docs/SANDBOX.md) | OS-level isolation setup |
-| [CLI Design](docs/CLI_DESIGN_SYSTEM.md) | UI specifications |
+| [Master Plan](docs/MASTER_PLAN.md) | The Autonomous Roadmap |
+| [Architecture](docs/ARCHITECTURE.md) | The Daemon & Gateway System |
+| [Smart Context](docs/CONTEXT.md) | 1M Token & Semantic Memory |
+| [Security Policy](docs/SECURITY.md) | Global Zero Trust Model |
 
 ---
 
@@ -204,9 +140,8 @@ Install certified tools:
 
 ```bash
 npm run dev      # Watch mode
-npm run build    # Build distribution
-npm test         # Run tests
-npm start        # Run locally
+npm run build    # Build daemon and frontend
+npm test         # Full suite (vitest)
 ```
 
 ---

package/dist/auditLog-HWRFIJ2X.js

@@ -0,0 +1,8 @@
+import {
+  auditLog
+} from "./chunk-WYNEGOVS.js";
+import "./chunk-2DWIVO44.js";
+import "./chunk-2GYEYFA3.js";
+export {
+  auditLog
+};

package/dist/auditLog-VIRBXCTW.js

@@ -0,0 +1,8 @@
+import {
+  auditLog
+} from "./chunk-5SWSM5VM.js";
+import "./chunk-7MMY74WO.js";
+import "./chunk-7RCNGBCH.js";
+export {
+  auditLog
+};

package/dist/chunk-2DWIVO44.js

@@ -0,0 +1,153 @@
+// src/core/config.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+var ConfigSchema = z.object({
+  model: z.string().default("claude-sonnet-4-5-20250929"),
+  workspaceRoot: z.string().default(os.homedir()),
+  maxTokens: z.number().default(8192),
+  language: z.string().default("en"),
+  // Deprecated: apiKey should be managed by KeyManager, not stored in config
+  apiKey: z.string().optional(),
+  // Sandbox Configuration
+  executionMode: z.enum(["local", "sandbox"]).default("local"),
+  sandbox: z.object({
+    allowedDomains: z.array(z.string()).default(["*.github.com", "*.npmjs.org", "*.npmjs.com", "api.anthropic.com", "registry.npmjs.org"]),
+    deniedDomains: z.array(z.string()).default([]),
+    denyRead: z.array(z.string()).default(["~/.ssh", "~/.aws", "~/.config/gcloud", "~/.kube", "~/.gnupg"]),
+    allowWrite: z.array(z.string()).default([".", "/tmp"]),
+    denyWrite: z.array(z.string()).default([".env", ".env.*", "*.key", "*.pem", ".git/config"])
+  }).default({}),
+  // Context Management
+  summarizerModel: z.string().default("claude-haiku-4-5-20251001"),
+  // Token Counting
+  // When true, uses Anthropic's countTokens API for accurate pre-request validation
+  // Set to false to skip pre-counting (saves ~100-500ms latency per request)
+  preCountTokens: z.boolean().default(true)
+});
+var DEFAULT_CONFIG = {
+  model: "claude-sonnet-4-5-20250929",
+  maxTokens: 8192,
+  language: "en",
+  workspaceRoot: os.homedir(),
+  executionMode: "local",
+  sandbox: {
+    allowedDomains: ["*.github.com", "*.npmjs.org", "*.npmjs.com", "api.anthropic.com", "registry.npmjs.org"],
+    deniedDomains: [],
+    denyRead: ["~/.ssh", "~/.aws", "~/.config/gcloud", "~/.kube", "~/.gnupg"],
+    allowWrite: [".", "/tmp"],
+    denyWrite: [".env", ".env.*", "*.key", "*.pem", ".git/config"]
+  },
+  summarizerModel: "claude-haiku-4-5-20251001",
+  preCountTokens: true
+};
+var ConfigManager = class {
+  configPath;
+  cachedConfig = null;
+  hasDeprecatedApiKey = false;
+  constructor(customPath) {
+    this.configPath = customPath || path.join(os.homedir(), ".obsidian-next", "config.json");
+  }
+  async load() {
+    if (this.cachedConfig) return this.cachedConfig;
+    return this.reload();
+  }
+  async reload() {
+    let loadedConfig = DEFAULT_CONFIG;
+    try {
+      const data = await fs.readFile(this.configPath, "utf-8");
+      const parsed = JSON.parse(data);
+      loadedConfig = { ...DEFAULT_CONFIG, ...parsed };
+      if (parsed.apiKey) {
+        this.hasDeprecatedApiKey = true;
+      }
+    } catch {
+    }
+    const finalConfig = ConfigSchema.parse(loadedConfig);
+    this.cachedConfig = finalConfig;
+    return finalConfig;
+  }
+  /**
+   * Check if config has deprecated apiKey field
+   * Users should migrate to KeyManager via /init
+   */
+  hasDeprecatedKey() {
+    return this.hasDeprecatedApiKey;
+  }
+  /**
+   * Get deprecated apiKey for migration to KeyManager
+   */
+  getDeprecatedApiKey() {
+    return this.cachedConfig?.apiKey;
+  }
+  /**
+   * Remove apiKey from config file after successful migration
+   */
+  async removeApiKeyFromConfig() {
+    try {
+      const data = await fs.readFile(this.configPath, "utf-8");
+      const parsed = JSON.parse(data);
+      if (parsed.apiKey) {
+        delete parsed.apiKey;
+        await fs.writeFile(this.configPath, JSON.stringify(parsed, null, 2));
+        this.hasDeprecatedApiKey = false;
+        this.clearCache();
+      }
+    } catch {
+    }
+  }
+  clearCache() {
+    this.cachedConfig = null;
+  }
+  async save(config2) {
+    const dir = path.dirname(this.configPath);
+    await fs.mkdir(dir, { recursive: true });
+    const { apiKey, workspaceRoot, ...safeConfig } = config2;
+    await fs.writeFile(this.configPath, JSON.stringify(safeConfig, null, 2));
+    this.clearCache();
+  }
+  async exists() {
+    try {
+      await fs.access(this.configPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getPath() {
+    return this.configPath;
+  }
+  /**
+   * Dynamically get the project version from package.json
+   */
+  async getVersion() {
+    try {
+      const selfPath = fileURLToPath(import.meta.url);
+      let currentDir = path.dirname(selfPath);
+      for (let i = 0; i < 5; i++) {
+        const pkgPath = path.join(currentDir, "package.json");
+        try {
+          const data = await fs.readFile(pkgPath, "utf-8");
+          const pkg = JSON.parse(data);
+          if (pkg.name === "@aurora-foundation/obsidian-next") {
+            return pkg.version;
+          }
+        } catch {
+        }
+        currentDir = path.dirname(currentDir);
+      }
+      return "0.4.5";
+    } catch {
+      return "0.4.5";
+    }
+  }
+};
+var config = new ConfigManager();
+
+export {
+  ConfigSchema,
+  ConfigManager,
+  config
+};

package/dist/chunk-2GNNSYJJ.js

@@ -0,0 +1,130 @@
+import {
+  history,
+  session,
+  tasks
+} from "./chunk-6AYRIUHX.js";
+import {
+  context
+} from "./chunk-WR3MOK2G.js";
+import {
+  bus
+} from "./chunk-WQM6FFSD.js";
+
+// src/commands/resume.ts
+import path from "path";
+var resumeCommand = async (args) => {
+  if (args[0] === "--delete" || args[0] === "-d") {
+    const sessionId = args[1];
+    if (!sessionId) {
+      bus.emitAgent({
+        type: "error",
+        message: "Usage: /resume --delete <session_id>"
+      });
+      return;
+    }
+    const deleted = await session.delete(sessionId);
+    if (deleted) {
+      bus.emitAgent({
+        type: "done",
+        summary: `Session ${sessionId} deleted.`
+      });
+    } else {
+      bus.emitAgent({
+        type: "error",
+        message: `Session ${sessionId} not found.`
+      });
+    }
+    return;
+  }
+  if (args[0] === "--last" || args[0] === "-l") {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "error",
+        message: "No saved sessions found."
+      });
+      return;
+    }
+    args[0] = sessions[0].id;
+  }
+  if (!args[0]) {
+    const sessions = await session.list();
+    if (sessions.length === 0) {
+      bus.emitAgent({
+        type: "thought",
+        content: "No saved sessions found.\n\nSessions are created when you run /exit."
+      });
+      bus.emitAgent({
+        type: "done",
+        summary: "No sessions available."
+      });
+      return;
+    }
+    const content2 = [
+      "Saved Session Registry",
+      ...sessions.slice(0, 10).map((s) => {
+        const date = new Date(s.savedAt);
+        const dateStr = date.toLocaleDateString();
+        const timeStr = date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+        const workspaceName = path.basename(s.workspace);
+        return [
+          `   \u23BF  [${s.id}]`,
+          `      \u23BF  Date      ${dateStr} ${timeStr}`,
+          `      \u23BF  Workspace ${workspaceName}`,
+          s.task ? `      \u23BF  Task      ${s.task}` : null,
+          `      \u23BF  Activity  ${s.filesModified} files handled`,
+          ""
+        ].filter(Boolean).join("\n");
+      }),
+      sessions.length > 10 ? `   ... and ${sessions.length - 10} more sessions
+` : "",
+      "   [Usage]",
+      "   \u23BF  /resume <id>      Restore session",
+      "   \u23BF  /resume --last    Restore latest",
+      ""
+    ].join("\n");
+    bus.emitAgent({
+      type: "thought",
+      content: content2
+    });
+    bus.emitAgent({
+      type: "done",
+      summary: `${sessions.length} session(s) available.`
+    });
+    return;
+  }
+  const sessionIdArg = args[0];
+  const result = await session.restore(sessionIdArg);
+  if (!result.success) {
+    bus.emitAgent({
+      type: "error",
+      message: result.error || "Failed to restore session"
+    });
+    return;
+  }
+  const currentTask = tasks.get();
+  const currentContext = context.get();
+  const content = [
+    "Session Restored Successfully",
+    `   \u23BF  ID          ${sessionIdArg}`,
+    `   \u23BF  Root        ${path.basename(process.cwd())}`,
+    "",
+    "   [Restored State]",
+    `   \u23BF  Context     ${currentContext.files_read.length} files in set`,
+    `   \u23BF  History     ${(await history.load()).length} events rehydrated`,
+    `   \u23BF  Task        ${currentTask?.title || "None"}`,
+    ""
+  ].join("\n");
+  bus.emitAgent({
+    type: "thought",
+    content
+  });
+  bus.emitAgent({
+    type: "done",
+    summary: `Session ${sessionIdArg} restored.`
+  });
+};
+
+export {
+  resumeCommand
+};