stellavault 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+
+## [0.4.0] - 2026-04-06
+
+### Features
+- **i18n Global Service** — Full EN/KO/JA/ZH language switcher for web UI; saved notes follow user's language setting
+- **Web UI Ingest Panel** — Add knowledge from browser (+) button, no terminal needed
+- **YouTube Deep Extraction** — Full description, transcript with clickable timestamps, auto-summary, metadata (channel, views, duration)
+- **YouTube Transcript via yt-dlp** — Fallback to yt-dlp when YouTube bot protection blocks direct caption fetch
+- **Edit/Delete Notes from Web** — Edit and delete notes directly from web UI, syncs to Obsidian vault
+- **Ask Q&A Web UI** — Intelligence > Ask tab for querying your knowledge base from the browser
+- **Reindex from Web** — One-click reindex button, no terminal needed
+- **Recent Saves Navigation** — Click recent saves to navigate to node in 3D graph
+- **Auto-index after Ingest** — New notes are automatically indexed and graph refreshes
+- **Onboarding Guide** — 4-step walkthrough for new users
+- **LLM Knowledge Base** — `stellavault ask` (Q&A + auto-filing), `compile` (raw→wiki), `lint` (health check), `digest --visual` (Mermaid charts)
+- **Zettelkasten System** — Luhmann-style index codes, frontmatter scan, inbox zero, atomicity verification, orphan/broken link detection
+- **Unified Ingest Pipeline** — URL/file/text auto-classification, `stellavault ingest`, `promote`, `autopilot` flywheel
+- **Fleeting Capture** — `stellavault fleeting` for quick thoughts
+
+### Fixes
+- YouTube extractor v2 — HTML entities, tags cleanup, summary quality, duplicate frontmatter removal
+- YouTube full description extraction (shortDescription JSON parsing)
+- CLI YouTube ingest now properly calls extractYouTubeContent instead of basic HTML scrape
+- Strict node matching — exact title/path only, no partial match
+- React hooks order in Layout, ConstellationView, MultiverseView
+- Natural Korean translations (감쇠→잊고 있는 것, 갭→빠진 지식)
+- Reindex API — pass vaultPath, use all-MiniLM-L6-v2, error details
+
+### Security
+- Path traversal protection (archiveFile, ingest)
+- YAML injection prevention (sanitizeYaml)
+- SSRF protection (private IP blocking)
+- Empty catch blocks → proper error logging
+
+### Infrastructure
+- MCP: 19 tools | CLI: 36+ commands | Tests: 127 ALL PASS
+- Hardcoded Korean removed — core modules default to English
+- Subpath exports for youtube-extractor module
+
+## [0.3.0] - 2026-04-04
+
+### Features
+- 3D Knowledge Graph with Three.js / React Three Fiber
+- Hybrid search (vector + keyword + RRF)
+- Memory decay tracking (FSRS algorithm)
+- MCP server with 16 tools
+- Notion ↔ Obsidian sync (packages/sync)
+- Web UI with constellation/multiverse views
+
+## [0.2.0] - 2026-04-03
+
+- Initial Obsidian vault indexer
+- Vector store with all-MiniLM-L6-v2
+- Basic CLI commands
+
+## [0.1.0] - 2026-04-02
+
+- Project inception
+- Notion-Obsidian sync tool

package/README.md

@@ -2,23 +2,37 @@
 
 > **Notes die in folders. Stellavault keeps your knowledge alive.**
 
-Your Obsidian vault is more than files. It's a living network — connections emerge, memories fade, gaps appear. Stellavault turns it into a knowledge system that **discovers hidden connections**, **detects fading memories**, **finds blind spots**, and **gives AI agents direct access to everything you know**.
+Your Obsidian vault is more than files — it's a living network. Stellavault turns it into a self-compiling knowledge system that **discovers hidden connections**, **tracks fading memories**, **finds blind spots**, and **gives AI agents direct access to everything you know**.
 
-## 30-Second Setup
+<p align="center">
+  <img src="images/screenshots/graph-dark-full.png" alt="3D Knowledge Graph" width="800" />
+  <br><em>Your vault as a neural network. Clusters form constellations.</em>
+</p>
+
+## Why Stellavault?
+
+| Problem | Stellavault Solution |
+|---------|---------------------|
+| Notes pile up but never become knowledge | **Self-compiling wiki** — raw notes auto-organized into linked concepts |
+| You forget what you wrote | **FSRS decay tracking** — see what's fading, get review suggestions |
+| Search finds words, not meaning | **Hybrid AI search** — BM25 + vector + RRF fusion, locally |
+| AI agents can't access your knowledge | **17 MCP tools** — Claude remembers everything you know |
+| No way to see the big picture | **3D neural graph** — constellations, heatmaps, timeline |
+
+## 5-Minute Setup
 
 ```bash
-# Install globally
+# Install
 npm install -g stellavault
 
-# Interactive setup wizard
+# Interactive setup (indexes your vault + verifies search)
 stellavault init
 
-# Or manually: index your vault + launch 3D graph
-stellavault index /path/to/obsidian/vault
+# Launch 3D graph + API server
 stellavault graph
 ```
 
-That's it. Open `http://localhost:5173` to see your knowledge come alive in 3D.
+> **Prerequisites**: Node.js 20+ (`node --version`)
 
 ## Give Your AI Agent Memory
 
@@ -26,77 +40,81 @@ That's it. Open `http://localhost:5173` to see your knowledge come alive in 3D.
 claude mcp add stellavault -- stellavault serve
 ```
 
-Now Claude Code can search your notes, track your decisions, tell you what's fading, and give you a daily knowledge briefing — using 17+ MCP tools.
+Now Claude Code can search your notes, track decisions, detect knowledge gaps, and generate daily briefings — using 17 MCP tools.
+
+## Screenshots
 
-## What It Does
+<p align="center">
+  <img src="images/screenshots/graph-search-highlight.png" alt="Semantic Search" width="800" />
+  <br><em>Search by meaning. Matching nodes pulse and glow.</em>
+</p>
 
-**Understands** — Vectorizes every note locally (no API keys needed). Hybrid search combines BM25 + cosine similarity + RRF fusion.
+<details>
+<summary>More screenshots</summary>
 
-**Remembers** — FSRS spaced repetition tracks what you're forgetting. `stellavault decay` shows what's fading. `stellavault review` runs a review session.
+| Light Mode | Timeline Slider | Heatmap |
+|:---:|:---:|:---:|
+| <img src="images/screenshots/graph-light-mode.png" width="260" /> | <img src="images/screenshots/graph-timeline.png" width="260" /> | <img src="images/screenshots/graph-heatmap.png" width="260" /> |
 
-**Discovers** — Gap detector finds missing connections. Duplicate finder catches redundancy. Contradiction detector spots conflicting statements. Learning path tells you what to study next.
+</details>
 
-**Visualizes** — Interactive 3D neural graph with constellation view, timeline slider, type filters, health dashboard, and keyboard navigation.
+## Core Workflow
 
-**Connects** — Federation protocol links your vault to other Stellavault nodes via P2P. Search across the network without sharing your raw text. Multiverse UI shows your universe alongside connected peers.
+```
+Capture → Compile → Connect → Review
+
+stellavault fleeting "idea"     # Instant capture
+stellavault ingest <url>        # Clip any URL/file
+stellavault compile             # Raw → structured wiki
+stellavault autopilot           # Full flywheel: inbox → compile → lint
+stellavault ask "question"      # Q&A with auto-filing (--save)
+stellavault lint                # Knowledge health check (score 0-100)
+```
 
-## Key Features
+## Daily Commands
 
-| Category | Features |
-|----------|----------|
-| **Search** | Hybrid BM25+Vector+RRF, semantic search, search history |
-| **Intelligence** | FSRS decay, gap detection, duplicates, contradictions, predictive gaps, learning paths |
-| **Visualization** | 3D graph, constellation view, timeline, type filter, health dashboard, embed widget |
-| **AI Integration** | 17+ MCP tools, custom MCP tool builder (YAML), agentic graph construction |
-| **Federation** | P2P search, multiverse UI, reputation system, trust scoring, differential privacy |
-| **Security** | E2E cloud sync (AES-256-GCM), team auth (RBAC), sharing controls, SSRF/XSS protection |
-| **Platform** | Web dashboard, PWA, voice capture (Whisper), Notion sync, multi-vault, i18n (en/ko/ja/zh) |
-| **Extensibility** | Plugin SDK, webhook system, Knowledge Pack marketplace |
+```bash
+stellavault brief               # Morning knowledge briefing
+stellavault decay               # What's fading from memory?
+stellavault learn               # AI-generated learning path
+stellavault digest --visual     # Weekly report with Mermaid charts
+stellavault review              # FSRS spaced repetition session
+stellavault gaps                # Knowledge gap detection
+```
 
-## CLI (28+ commands)
+## Intelligence Features
+
+| Feature | Command | What it does |
+|---------|---------|-------------|
+| **FSRS Decay** | `sv decay` | Track memory strength with spaced repetition |
+| **Gap Detection** | `sv gaps` | Find missing connections between topics |
+| **Contradiction Detection** | `sv contradictions` | Spot conflicting statements |
+| **Duplicate Detection** | `sv duplicates` | Find redundant notes |
+| **Knowledge Lint** | `sv lint` | Health score + issues + suggestions |
+| **Learning Path** | `sv learn` | AI-recommended review order |
+| **Semantic Evolution** | MCP `get-evolution` | Track how ideas change over time |
+| **Code Linker** | MCP `link-code` | Connect code files to knowledge notes |
+| **Adaptive Search** | MCP `search` | Context-aware result reranking |
+
+## Zettelkasten Automation
+
+Inspired by Luhmann + Karpathy's "Self-Compiling Zettelkasten":
 
 ```bash
-# Core
-stellavault init                  # Interactive setup wizard
-stellavault index <vault-path>    # Vectorize your vault
-stellavault search <query>        # Semantic search
-stellavault graph                 # Launch 3D graph
-stellavault serve                 # MCP server for AI agents
-stellavault status                # Index stats
-
-# Intelligence
-stellavault decay                 # What's fading?
-stellavault learn                 # AI learning path
-stellavault brief                 # Daily knowledge briefing
-stellavault digest                # Weekly report
-stellavault review                # FSRS review session
-stellavault gaps                  # Knowledge gap detection
-stellavault duplicates            # Duplicate detection
-stellavault contradictions        # Contradiction detection
-
-# Federation
-stellavault federate join         # Join P2P network
-stellavault federate status       # Node identity
-
-# Multi-Vault
-stellavault vault add <id> <path> # Register a vault
-stellavault vault search-all <q>  # Search across all vaults
-
-# Cloud
-stellavault cloud sync            # E2E encrypted backup
-stellavault cloud restore         # Restore from cloud
-
-# More
-stellavault clip <url>            # Web/YouTube clipper
-stellavault sync                  # Notion → Obsidian
-stellavault capture <audio>       # Voice → knowledge (Whisper)
-stellavault card                  # SVG profile card
-stellavault pack <cmd>            # Knowledge Pack management
+stellavault fleeting "raw idea"          # Capture → raw/
+stellavault ingest https://article.com   # Any URL → auto-classified
+stellavault compile                      # Raw → wiki with concepts + backlinks
+stellavault promote file.md --to permanent  # Upgrade note stage
+stellavault autopilot                    # Full cycle: inbox → compile → lint → archive
 ```
 
-Use short alias `sv` for all commands: `sv graph`, `sv decay`, `sv learn`
+- **Frontmatter-first scanning** — 10x token reduction
+- **Luhmann index codes** — auto-assigned hierarchical numbering (1A → 1A1)
+- **Inbox Zero** — processed notes auto-archived
+- **Atomicity check** — detects notes with too many topics
+- **3-stage classification** — fleeting → literature → permanent
 
-## MCP Tools (17+)
+## MCP Tools (17)
 
 | Tool | What it does |
 |------|-------------|
@@ -107,32 +125,38 @@ Use short alias `sv` for all commands: `sv graph`, `sv decay`, `sv learn`
 | `get-decay-status` | Memory decay report |
 | `get-morning-brief` | Daily knowledge briefing |
 | `get-learning-path` | AI learning recommendations |
-| `federated-search` | Search across P2P network |
-| `create-knowledge-node` | AI creates notes during conversation |
-| `create-knowledge-link` | AI creates links between notes |
-| `log-decision` / `find-decisions` | Technical decision journal |
+| `detect-gaps` | Knowledge gap analysis |
+| `get-evolution` | Semantic drift tracking |
+| `link-code` | Code-knowledge connections |
+| `ask` | Q&A with optional vault filing |
+| `create-knowledge-node` | AI creates wiki-quality notes |
+| `create-knowledge-link` | AI connects existing notes |
+| `log-decision` / `find-decisions` | Decision journal |
 | `create-snapshot` / `load-snapshot` | Context snapshots |
 | `generate-claude-md` | Auto-generate CLAUDE.md |
 | `export` | JSON/CSV export |
 
-## Federation — P2P Knowledge Network
+## 3D Visualization
 
-Each Stellavault is a node. Connect to discover knowledge across the network — without sharing your raw text.
+- **Neural graph** — force-directed layout with cluster coloring
+- **Constellation view** — MST-based star patterns with LOD zoom
+- **Heatmap overlay** — activity score (cold → fire gradient)
+- **Timeline slider** — filter by creation/modification date
+- **Multiverse view** — see connected Federation peers
+- **Decay overlay** — visualize fading knowledge
+- **Dark/Light theme** — monochrome light mode with color-on-interaction
+- **Export** — PNG screenshots + WebM recording
 
-```bash
-stellavault federate join --name "my-node"
-# Interactive mode:
-federation> search kubernetes deployment
-#  87% "K8s Rolling Update Guide" [peer-alice]
-#     Kubernetes에서 무중단 배포를 위해...
-federation> peers
-#  alice (1,209 docs) [trust: 88]
-#  bob (47 docs) [trust: 72]
-```
+## Obsidian Plugin
+
+Manual install (community plugin review pending):
 
-**Privacy**: Only titles + similarity scores + 50-char masked snippets cross the network. Never raw text. Differential privacy noise on embeddings. Sharing controls per tag/folder.
+1. Download `main.js`, `manifest.json`, `styles.css` from [GitHub Releases](https://github.com/Evanciel/stellavault-obsidian/releases/tag/0.1.0)
+2. Copy to `.obsidian/plugins/stellavault/`
+3. Enable in Settings > Community plugins
+4. **Run `stellavault graph` first** — the plugin connects to the API server
 
-**Trust**: Web of Trust + automatic reputation scoring (consistency, consensus, helpfulness).
+Features: semantic search modal, memory decay sidebar, learning path suggestions.
 
 ## Architecture
 
@@ -140,8 +164,8 @@ federation> peers
 stellavault/
 ├── packages/
 │   ├── core/       Search, MCP, API, Intelligence, Federation, Cloud, Team, i18n
-│   ├── cli/        28+ commands
-│   ├── graph/      3D visualization + Multiverse UI (React Three Fiber)
+│   ├── cli/        36+ commands
+│   ├── graph/      3D visualization (React Three Fiber)
 │   └── sync/       Notion ↔ Obsidian sync
 ```
 
@@ -153,23 +177,44 @@ stellavault/
 | Vector Store | SQLite-vec (local, no server) |
 | Embedding | all-MiniLM-L6-v2 (local, no API key) |
 | Search | BM25 + Cosine + RRF Fusion |
-| 3D | React Three Fiber + Three.js + Zustand |
 | Memory | FSRS (Free Spaced Repetition Scheduler) |
+| 3D | React Three Fiber + Three.js + Zustand |
 | P2P | Hyperswarm (NAT traversal + DHT) |
 | AI | MCP (Model Context Protocol) |
 | Security | AES-256-GCM, HMAC-SHA256, Differential Privacy |
 
-## Configuration
+## Troubleshooting
+
+<details>
+<summary>"Stellavault API server not found"</summary>
+
+The Obsidian plugin and 3D graph require the API server. Open a terminal in your vault:
+
+```bash
+stellavault graph
+```
+
+Default port: 3333. Change in `.stellavault.json`: `{ "mcp": { "port": 3334 } }`
+</details>
 
-```json
-{
-  "vaultPath": "/path/to/obsidian/vault",
-  "dbPath": "~/.stellavault/index.db",
-  "embedding": { "model": "local", "localModel": "all-MiniLM-L6-v2" },
-  "search": { "defaultLimit": 10, "rrfK": 60 },
-  "mcp": { "mode": "stdio", "port": 3333 }
-}
+<details>
+<summary>"No documents indexed"</summary>
+
+```bash
+stellavault index /path/to/your/vault
+```
+
+First indexing takes 2-5 minutes for large vaults (1000+ notes).
+</details>
+
+<details>
+<summary>Port conflict</summary>
+
+```bash
+# Use a different port
+stellavault graph --port 3334
 ```
+</details>
 
 ## License
 
@@ -177,6 +222,6 @@ MIT
 
 ## Links
 
+- [Obsidian Plugin](https://github.com/Evanciel/stellavault-obsidian)
 - [Wiki: Vault Structure Guide](docs/wiki/vault-structure.md)
-- [Wiki: Notion Setup](docs/wiki/notion-setup.md)
 - [Wiki: Federation Guide](docs/wiki/federation-guide.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stellavault",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Turn your Obsidian vault into a 3D neural knowledge graph with AI-powered search, memory decay tracking, and MCP integration.",
   "repository": {
     "type": "git",

package/packages/cli/dist/commands/ask-cmd.d.ts

@@ -0,0 +1,4 @@
+export declare function askCommand(question: string, options: {
+    save?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=ask-cmd.d.ts.map

package/packages/cli/dist/commands/ask-cmd.js

@@ -0,0 +1,35 @@
+// stellavault ask — Q&A + auto-filing CLI command
+import chalk from 'chalk';
+import { loadConfig, createKnowledgeHub, askVault } from '@stellavault/core';
+export async function askCommand(question, options) {
+    if (!question || question.trim().length < 2) {
+        console.error(chalk.yellow('Usage: stellavault ask "your question here" [--save]'));
+        console.error(chalk.dim('\nSearch Mode: finds relevant notes from your vault.'));
+        console.error(chalk.dim('For AI-powered answers, use MCP: claude mcp add stellavault -- stellavault serve'));
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const hub = createKnowledgeHub(config);
+    console.error(chalk.dim('Searching your knowledge (local search mode)...'));
+    await hub.store.initialize();
+    await hub.embedder.initialize();
+    const result = await askVault(hub.searchEngine, question, {
+        limit: 10,
+        save: options.save ?? false,
+        vaultPath: config.vaultPath,
+    });
+    // 출력
+    console.log('');
+    console.log(result.answer);
+    if (result.savedTo) {
+        console.log('');
+        console.log(chalk.green(`Saved to: ${result.savedTo}`));
+    }
+    if (result.sources.length > 0 && !options.save) {
+        console.log('');
+        console.log(chalk.dim('Tip: Add --save to file this answer into your vault.'));
+        console.log(chalk.dim('For AI-generated answers: use Claude Code with MCP integration.'));
+    }
+    await hub.store.close?.();
+}
+//# sourceMappingURL=ask-cmd.js.map

package/packages/cli/dist/commands/autopilot-cmd.d.ts

@@ -0,0 +1,4 @@
+export declare function autopilotCommand(options: {
+    once?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=autopilot-cmd.d.ts.map

package/packages/cli/dist/commands/autopilot-cmd.js

@@ -0,0 +1,76 @@
+// stellavault autopilot — 자율형 지식 플라이휠
+// ingest(inbox) → compile → lint → index → 반복
+import chalk from 'chalk';
+import { loadConfig, createKnowledgeHub, compileWiki, lintKnowledge, getInboxItems, archiveFile } from '@stellavault/core';
+import { resolve } from 'node:path';
+export async function autopilotCommand(options) {
+    const config = loadConfig();
+    const vaultPath = config.vaultPath;
+    console.log(chalk.bold('\n  ✦ Stellavault Autopilot'));
+    console.log(chalk.dim('  Knowledge flywheel: inbox → compile → lint → repeat\n'));
+    // Step 1: Inbox 확인
+    console.log(chalk.cyan('Step 1/4: Checking inbox...'));
+    const inbox = getInboxItems(vaultPath);
+    if (inbox.length === 0) {
+        console.log(chalk.dim('  No new items in raw/ folder.'));
+    }
+    else {
+        console.log(chalk.green(`  ${inbox.length} new items found.`));
+        for (const item of inbox.slice(0, 5)) {
+            console.log(chalk.dim(`    - ${item.title} (${item.wordCount} words)`));
+        }
+        if (inbox.length > 5)
+            console.log(chalk.dim(`    ... and ${inbox.length - 5} more`));
+    }
+    // Step 2: Compile
+    console.log(chalk.cyan('\nStep 2/4: Compiling wiki...'));
+    const rawPath = resolve(vaultPath, 'raw');
+    const wikiPath = resolve(vaultPath, '_wiki');
+    const compileResult = compileWiki(rawPath, wikiPath);
+    if (compileResult.rawDocCount > 0) {
+        console.log(chalk.green(`  Compiled ${compileResult.rawDocCount} raw → ${compileResult.wikiArticles.length} wiki articles`));
+        console.log(chalk.dim(`  Concepts: ${compileResult.concepts.length}`));
+        // Archive processed raw files
+        for (const item of inbox) {
+            try {
+                archiveFile(resolve(vaultPath, 'raw', item.filePath));
+            }
+            catch { /* skip */ }
+        }
+        console.log(chalk.dim(`  Archived ${inbox.length} processed items.`));
+    }
+    else {
+        console.log(chalk.dim('  No raw documents to compile.'));
+    }
+    // Step 3: Lint
+    console.log(chalk.cyan('\nStep 3/4: Running health check...'));
+    const hub = createKnowledgeHub(config);
+    await hub.store.initialize();
+    const lintResult = await lintKnowledge(hub.store);
+    const scoreColor = lintResult.score >= 80 ? chalk.green : lintResult.score >= 50 ? chalk.yellow : chalk.red;
+    console.log(`  Health: ${scoreColor(lintResult.score + '/100')}`);
+    const critical = lintResult.issues.filter(i => i.severity === 'critical').length;
+    const warnings = lintResult.issues.filter(i => i.severity === 'warning').length;
+    if (critical > 0)
+        console.log(chalk.red(`  Critical: ${critical}`));
+    if (warnings > 0)
+        console.log(chalk.yellow(`  Warnings: ${warnings}`));
+    // Step 4: Summary
+    console.log(chalk.cyan('\nStep 4/4: Summary'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(`  Inbox processed: ${inbox.length}`);
+    console.log(`  Wiki articles: ${compileResult.wikiArticles.length}`);
+    console.log(`  Health score: ${lintResult.score}/100`);
+    console.log(`  Issues: ${lintResult.issues.length}`);
+    if (lintResult.suggestions.length > 0) {
+        console.log(chalk.cyan('\n  Suggestions:'));
+        for (const s of lintResult.suggestions.slice(0, 3)) {
+            console.log(chalk.dim(`    → ${s}`));
+        }
+    }
+    console.log(chalk.dim('\n─'.repeat(40)));
+    console.log(chalk.dim('\n  Next: run `stellavault index` to update search vectors.'));
+    console.log(chalk.green('  Autopilot complete.\n'));
+    await hub.store.close?.();
+}
+//# sourceMappingURL=autopilot-cmd.js.map

package/packages/cli/dist/commands/compile-cmd.d.ts

@@ -0,0 +1,6 @@
+export declare function compileCommand(options: {
+    raw?: string;
+    wiki?: string;
+    force?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=compile-cmd.d.ts.map

package/packages/cli/dist/commands/compile-cmd.js

@@ -0,0 +1,30 @@
+// stellavault compile — raw → wiki 컴파일 CLI
+import chalk from 'chalk';
+import { loadConfig, compileWiki } from '@stellavault/core';
+import { resolve } from 'node:path';
+export async function compileCommand(options) {
+    const config = loadConfig();
+    const vaultPath = config.vaultPath;
+    const rawPath = resolve(vaultPath, options.raw ?? 'raw');
+    const wikiPath = resolve(vaultPath, options.wiki ?? '_wiki');
+    console.error(chalk.dim(`Raw: ${rawPath}`));
+    console.error(chalk.dim(`Wiki: ${wikiPath}`));
+    console.error('');
+    const result = compileWiki(rawPath, wikiPath, { force: options.force });
+    if (result.rawDocCount === 0) {
+        console.error(chalk.yellow(`No documents found in ${rawPath}`));
+        console.error(chalk.dim('Create a raw/ folder in your vault and add .md/.txt files.'));
+        return;
+    }
+    console.log(chalk.green(`Compiled ${result.rawDocCount} raw docs → ${result.wikiArticles.length} wiki articles`));
+    console.log(chalk.dim(`Concepts: ${result.concepts.length}`));
+    console.log(chalk.dim(`Index: ${result.indexFile}`));
+    if (result.concepts.length > 0) {
+        console.log('');
+        console.log(chalk.cyan('Top concepts:'));
+        for (const c of result.concepts.slice(0, 10)) {
+            console.log(`  ${c}`);
+        }
+    }
+}
+//# sourceMappingURL=compile-cmd.js.map

package/packages/cli/dist/commands/digest-cmd.d.ts

@@ -1,4 +1,5 @@
 export declare function digestCommand(options: {
     days?: string;
+    visual?: boolean;
 }): Promise<void>;
 //# sourceMappingURL=digest-cmd.d.ts.map

package/packages/cli/dist/commands/digest-cmd.js

@@ -75,5 +75,62 @@ export async function digestCommand(options) {
     const report = await decayEngine.computeAll();
     console.log(`\n🧠 건강도: R=${report.averageR} | 감쇠 ${report.decayingCount}개 | 위험 ${report.criticalCount}개`);
     console.log(chalk.dim('\n═'.repeat(50)));
+    // --visual: Mermaid 다이어그램 + 요약을 .md로 저장
+    if (options.visual) {
+        const { writeFileSync, mkdirSync, existsSync } = await import('node:fs');
+        const { join, resolve } = await import('node:path');
+        const outputDir = resolve(config.vaultPath, '_stellavault/digests');
+        if (!existsSync(outputDir))
+            mkdirSync(outputDir, { recursive: true });
+        const date = new Date().toISOString().split('T')[0];
+        const filename = `digest-${date}.md`;
+        const outputPath = join(outputDir, filename);
+        // Mermaid 파이 차트
+        const pieData = (typeStats.length > 0 ? typeStats : [{ type: 'note', cnt: 1 }])
+            .map((t) => `    "${t.type}" : ${t.cnt}`)
+            .join('\n');
+        // Mermaid 타임라인
+        const timelineData = dailyActivity
+            .map((d) => `    ${d.day.slice(5)} : ${d.cnt}`)
+            .join('\n');
+        const md = [
+            '---',
+            `title: "Weekly Digest — ${date}"`,
+            'type: digest',
+            `date: ${new Date().toISOString()}`,
+            'source: stellavault-digest',
+            '---',
+            '',
+            `# Weekly Knowledge Digest — ${date}`,
+            '',
+            `## Summary`,
+            `- Total access: **${totalAccess}** in ${days} days`,
+            `- Average R: **${report.averageR.toFixed(2)}**`,
+            `- Decaying: ${report.decayingCount} | Critical: ${report.criticalCount}`,
+            '',
+            '## Activity by Type',
+            '```mermaid',
+            'pie title Note Types Accessed',
+            pieData,
+            '```',
+            '',
+            '## Daily Activity',
+            '```mermaid',
+            'xychart-beta',
+            `    title "Daily Activity (${days} days)"`,
+            '    x-axis [' + dailyActivity.map((d) => `"${d.day.slice(5)}"`).join(', ') + ']',
+            '    y-axis "Access Count"',
+            '    bar [' + dailyActivity.map((d) => d.cnt).join(', ') + ']',
+            '```',
+            '',
+            topDocs.length > 0 ? '## Most Accessed Notes\n' + topDocs.map((d) => `1. **${d.title}** — ${d.cnt} times`).join('\n') : '',
+            '',
+            '---',
+            `*Generated by \`stellavault digest --visual\` on ${new Date().toISOString()}*`,
+        ].filter(Boolean).join('\n');
+        writeFileSync(outputPath, md, 'utf-8');
+        console.log(chalk.green(`\nVisual digest saved: ${filename}`));
+        console.log(chalk.dim(`Open in Obsidian to see Mermaid charts.`));
+    }
 }
 //# sourceMappingURL=digest-cmd.js.map

package/packages/cli/dist/commands/fleeting-cmd.d.ts

@@ -0,0 +1,4 @@
+export declare function fleetingCommand(text: string, options: {
+    tags?: string;
+}): Promise<void>;
+//# sourceMappingURL=fleeting-cmd.d.ts.map