n2-soul 6.0.2 → 6.1.0

package/README.ko.md

@@ -5,16 +5,15 @@
 **AI 에이전트는 세션이 끝나면 모든 걸 잊어버립니다. Soul이 그걸 해결합니다.**
 **AI 에이전트가 위험한 행동을 할 수도 있습니다. Ark가 그걸 막습니다.**
 
-> ### 🚀 v6.0 업데이트 — Ark: 최후의 방패
+> ### 🚀 v6.1 업데이트 — 클라우드 저장
 >
-> Soul v6.0에 **Ark**가 탑재되었습니다. 모든 도구 호출을 검사하고 위험한 행동을 **실행 전에** 차단하는 AI 안전 시스템입니다. LLM 호출 없음, 토큰 비용 0, 지연 없음 — MCP 서버 레벨의 순수 정규식 매칭.
+> AI 기억을 **어디에든** 저장하세요 — Google Drive, OneDrive, NAS, 회사 서버, USB. 설정 한 줄이면 끝:
+> ```js
+> DATA_DIR: 'G:/내 드라이브/n2-soul'
+> ```
+> **월 $0. API 키 없음. 새 의존성 없음.** 다른 서비스가 월 $99~$599를 받을 때, Soul은 기존 파일 동기화를 활용합니다. [자세히 →](#️-클라우드-저장--ai-기억을-원하는-곳-어디에든)
 >
-> - 모든 도구 호출이 `ark.check()`를 통과 — **무조건**
-> - `enabled: false` 옵션 없음 — Ark는 항상 켜져 있음 (의도적 설계)
-> - 12개 블랙리스트 규칙, 125개 패턴, 7개 업종별 템플릿 포함
-> - 자기보호: 4계층으로 AI가 방화벽을 비활성화하는 것을 방지
->
-> v6.0이 **메이저 버전**인 이유: 모든 도구 호출에 수호자가 생겼습니다. [자세히 →](#ark--최후의-방패)
+> **Ark** (v6.0) 포함 — 토큰 비용 0으로 위험한 행동을 차단하는 AI 안전 시스템. [자세히 →](#ark--최후의-방패)
 
 Cursor, VS Code Copilot 등 MCP 호환 AI 에이전트와 새 채팅을 시작할 때마다, 에이전트는 이전에 뭘 했는지 전혀 모른 채 처음부터 시작합니다. Soul은 에이전트에게 이런 능력을 부여하는 MCP 서버입니다:
 
@@ -141,6 +140,69 @@ n2_work_end(project, title, summary, todo, entities, insights)
 | **시맨틱 검색** | Ollama 임베딩 연동 (nomic-embed-text, 선택사항) |
 | **백업/복원** | 설정 가능한 보존 기간의 증분 백업 |
 | **Ark** | 토큰 비용 0으로 위험한 행동을 차단하는 AI 안전 시스템 (v6.0) |
+| **☁️ 클라우드 저장** | 기억을 어디에든 저장 — Google Drive, NAS, 회사 서버, 아무 경로나 (v6.1) |
+
+## ☁️ 클라우드 저장 — AI 기억을 원하는 곳 어디에든
+
+![Cloud Storage](docs/cloud-storage.png)
+
+> **설정 한 줄. API 키 없음. 월 요금 없음.**
+
+다른 AI 메모리 서비스는 클라우드 저장에 **월 $99~$599**를 받습니다. Soul은 완전히 다른 접근법을 취합니다:
+
+```js
+// config.local.js — 이게 전부입니다
+module.exports = {
+    DATA_DIR: 'G:/내 드라이브/n2-soul',  // Google Drive
+};
+```
+
+**끝입니다.** AI의 기억이 이제 클라우드에 있습니다. 모든 세션, 인수인계, 원장 기록이 Google Drive가 자동으로 동기화합니다. OAuth도, API 키도, SDK도 필요 없습니다.
+
+### 작동 원리
+
+Soul은 모든 걸 **일반 JSON 파일**로 저장합니다. OS가 읽을 수 있는 모든 폴더 = Soul의 클라우드. 클라우드 서비스가 동기화를 처리하고 — Soul은 자기가 "클라우드에 있는지"조차 모릅니다.
+
+### 지원 저장소
+
+| 저장소 | `DATA_DIR` 예시 | 비용 |
+|--------|-----------------|:----:|
+| 📁 **로컬** (기본값) | `./data` | 무료 |
+| ☁️ **Google Drive** | `G:/내 드라이브/n2-soul` | 무료 (15GB) |
+| ☁️ **OneDrive** | `C:/Users/you/OneDrive/n2-soul` | 무료 (5GB) |
+| ☁️ **Dropbox** | `C:/Users/you/Dropbox/n2-soul` | 무료 (2GB) |
+| 🖥️ **NAS** | `Z:/n2-soul` | 자체 장비 |
+| 🏢 **회사 서버** | `\\\\server\\shared\\n2-soul` | 자체 인프라 |
+| 🔌 **USB 드라이브** | `E:/n2-soul` | $10 |
+| 🐧 **Linux (rclone)** | `~/gdrive/n2-soul` | 무료 |
+
+### 다른 AI 메모리 서비스와 비교
+
+| | Soul | mem0 | Zep AI |
+|---|:---:|:---:|:---:|
+| **클라우드 저장** | 설정 한 줄 | API 연동 | API 연동 |
+| **월 비용** | **$0** | $99/월 | $599/월 |
+| **설정 시간** | 10초 | 수 시간 | 수 시간 |
+| **벤더 종속** | 없음 — 당신의 파일 | API 종속 | API 종속 |
+| **데이터 소유권** | 100% 당신의 것 | 그들의 서버 | 그들의 서버 |
+| **오프라인 작동** | 가능 | 불가 | 불가 |
+| **자체 호스팅** | 아무 경로나 = 클라우드 | 엔터프라이즈 전용 | 엔터프라이즈 전용 |
+
+### 팀 공유
+
+여러 에이전트가 **같은 네트워크 경로**를 가리키면 = 즉석 공유 메모리:
+
+```js
+// 팀원 A                                // 팀원 B
+DATA_DIR: '\\\\server\\team\\n2-soul'    DATA_DIR: '\\\\server\\team\\n2-soul'
+// 같은 프로젝트 데이터, 공유 인수인계, 공유 두뇌!
+```
+
+### 왜 이게 되는가
+
+> *"최고의 클라우드 연동은 연동이 아예 없는 것이다."*
+
+Soul의 데이터는 **100% 일반 JSON 파일** — `soul-board.json`, 원장 기록, 두뇌 메모리. 폴더를 미러링하는 동기화 서비스(Google Drive, OneDrive, Dropbox, Syncthing, rsync)라면 뭐든 완벽하게 작동합니다. 데이터베이스 마이그레이션도, API 버전도, SDK 업데이트도 필요 없습니다. 그냥 파일입니다.
 
 ## Ark — 최후의 방패
 
@@ -246,6 +308,14 @@ module.exports = {
 };
 ```
 
+### 보안 철학
+
+**`.n2` 규칙의 투명성**: 안전 규칙은 **의도적으로 공개 + 감사 가능**하도록 설계되었습니다. 숨겨진 규칙, 난독화된 패턴, "우리를 믿어라" 블랙박스가 없습니다. 사용자가 직접 읽고 커스터마이즈하고 검증할 수 있어야 합니다.
+
+**시크릿은 로컬만**: `config.local.js`는 gitignore 처리되어 배포되지 않습니다. 사용자의 머신에만 존재합니다. Soul은 API 키, 비밀번호, 인증 정보를 전송/저장/처리하지 않습니다.
+
+**저장소 주권**: 모든 데이터(원장, 메모리, 감사 로그)는 **당신의 머신**에 남습니다. 백업 위치 선택은 자유 — 로컬 SQLite, Google Drive 폴더, 자체 클라우드 어디든. Soul은 외부로 통신하지 않습니다.
+
 ## 데이터 디렉토리
 
 모든 런타임 데이터는 `data/`에 저장됩니다 (gitignored, 자동 생성):

package/README.md

@@ -6,21 +6,20 @@
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](https://nodejs.org)
 [![npm downloads](https://img.shields.io/npm/dm/n2-soul.svg)](https://www.npmjs.com/package/n2-soul)
-[![NEW](https://img.shields.io/badge/v6.0-Ark:%20The%20Last%20Shield-ff4444?style=for-the-badge)](https://github.com/choihyunsus/soul#ark-firewall)
+[![NEW](https://img.shields.io/badge/v6.1-Cloud%20Storage-4488ff?style=for-the-badge)](https://github.com/choihyunsus/soul#️-cloud-storage--store-your-ai-memory-anywhere)
 
 **Your AI agent forgets everything when a session ends. Soul fixes that.**
 **Your AI agent might do something dangerous. Ark stops that.**
 
-> ### 🚀 What's New in v6.0 — Ark: The Last Shield
+> ### 🚀 What's New in v6.1 — Cloud Storage
 >
-> Soul v6.0 introduces **Ark**, a built-in AI safety system that intercepts every tool call and blocks dangerous actions **before they execute**. No LLM calls, no token cost, no latency — pure regex matching at the MCP server level.
+> Store your AI memory **anywhere** — Google Drive, OneDrive, NAS, company server, USB. Just one line:
+> ```js
+> DATA_DIR: 'G:/My Drive/n2-soul'
+> ```
+> **$0/month. Zero API keys. Zero new dependencies.** While others charge $99~$599/month, Soul uses your existing file sync. [Learn more →](#️-cloud-storage--store-your-ai-memory-anywhere)
 >
-> - Every tool call passes through `ark.check()` — **unconditionally**
-> - There is no `enabled: false` — Ark is always on by design
-> - Ships with 12 blacklist rules, 125 patterns, and 7 industry templates
-> - Self-protection: 4 layers prevent a rogue AI from disabling the firewall
->
-> This is why v6.0 is a **major version**: every tool call now has a guardian. [Learn more →](#ark-firewall)
+> Also includes **Ark** (v6.0) — built-in AI safety that blocks dangerous actions at zero token cost. [Learn more →](#ark--the-last-shield)
 
 Every time you start a new chat with Cursor, VS Code Copilot, or any MCP-compatible AI agent, it starts from zero — no memory of what it did before. Soul is an MCP server that gives your agents:
 
@@ -41,6 +40,7 @@ Every time you start a new chat with Cursor, VS Code Copilot, or any MCP-compati
 - [Token Efficiency](#token-efficiency)
 - [How It Works](#how-it-works)
 - [Features](#features)
+- [Cloud Storage](#️-cloud-storage--store-your-ai-memory-anywhere)
 - [Available Tools](#available-tools)
 - [Real-World Example](#real-world-example)
 - [Rust Compiler (n2c)](#rust-compiler-n2c)
@@ -185,6 +185,70 @@ n2_work_end(project, title, summary, todo, entities, insights)
 | **Semantic Search** | Optional Ollama embedding (nomic-embed-text) |
 | **Backup/Restore** | Incremental backups with configurable retention |
 | **Ark** | 🆕 Built-in AI safety — blocks dangerous actions at zero token cost |
+| **Cloud Storage** | 🆕 Store memory anywhere — Google Drive, NAS, network server, any path (v6.1) |
+
+## ☁️ Cloud Storage — Store Your AI Memory Anywhere
+
+![Cloud Storage](docs/cloud-storage.png)
+
+> **One line of config. Zero API keys. Zero monthly fees.**
+
+Other AI memory services charge **$99~$599/month** for cloud storage. Soul takes a radically different approach:
+
+```js
+// config.local.js — This is ALL you need
+module.exports = {
+    DATA_DIR: 'G:/My Drive/n2-soul',  // Google Drive
+};
+```
+
+**That's it.** Your AI memory is now in the cloud. Every session, every handoff, every ledger entry — automatically synced by Google Drive. No OAuth, no API keys, no SDK.
+
+### How It Works
+
+Soul stores everything as **plain JSON files**. Any folder that your OS can read = Soul's cloud. The cloud provider handles sync — Soul doesn't even know it's "in the cloud."
+
+### Supported Storage
+
+| Storage | Example `DATA_DIR` | Cost |
+|---------|-------------------|:----:|
+| 📁 **Local** (default) | `./data` | Free |
+| ☁️ **Google Drive** | `G:/My Drive/n2-soul` | Free (15GB) |
+| ☁️ **OneDrive** | `C:/Users/you/OneDrive/n2-soul` | Free (5GB) |
+| ☁️ **Dropbox** | `C:/Users/you/Dropbox/n2-soul` | Free (2GB) |
+| 🖥️ **NAS** | `Z:/n2-soul` | Your hardware |
+| 🏢 **Company Server** | `\\\\server\\shared\\n2-soul` | Your infra |
+| 🔌 **USB Drive** | `E:/n2-soul` | $10 |
+| 🐧 **Linux (rclone)** | `~/gdrive/n2-soul` | Free |
+
+### vs. Other AI Memory Services
+
+| | Soul | mem0 | Zep AI |
+|---|:---:|:---:|:---:|
+| **Cloud storage** | One line of config | API integration | API integration |
+| **Monthly cost** | **$0** | $99/mo | $599/mo |
+| **Setup time** | 10 seconds | Hours | Hours |
+| **Vendor lock-in** | None — it's your files | API dependent | API dependent |
+| **Data ownership** | 100% yours | Their servers | Their servers |
+| **Works offline** | Yes | No | No |
+| **Self-hosted option** | Any path = cloud | Enterprise only | Enterprise only |
+
+### Team Sharing
+
+Point multiple agents to the **same network path** = instant shared memory:
+
+```js
+// Team member A                         // Team member B
+DATA_DIR: '\\\\server\\team\\n2-soul'    DATA_DIR: '\\\\server\\team\\n2-soul'
+// Same project data, shared handoffs, shared brain!
+```
+
+### Why This Works
+
+> *"The best cloud integration is no integration at all."*
+
+Soul's data is **100% plain JSON files** — `soul-board.json`, ledger entries, brain memory. Any sync service that mirrors folders (Google Drive, OneDrive, Dropbox, Syncthing, rsync) works perfectly because there's nothing to integrate. No database migrations, no API versions, no SDK updates. Just files.
+
 
 ## Ark — The Last Shield
 
@@ -383,6 +447,14 @@ module.exports = {
 
 > **Note:** There is no `enabled: false` option. This is by design. The lock cannot unlock itself.
 
+### Security Philosophy
+
+**Transparency of `.n2` Rules**: Safety rules are **intentionally public and auditable**. This is by design — users should be able to read, customize, and verify exactly what is being blocked. There are no hidden rules, no obfuscated patterns, and no "trust us" black boxes. Open rules build trust.
+
+**Secrets stay local**: `config.local.js` is gitignored and never distributed. It exists only on the user's machine. Soul does not transmit, store, or process any API keys, passwords, or credentials.
+
+**Storage sovereignty**: All data (ledger, memory, audit logs) stays on **your machine**. You choose where backups go — local SQLite, Google Drive folder, or your own cloud. Soul never phones home.
+
 ## Available Tools
 
 | Tool | Description |

package/index.js

@@ -17,7 +17,7 @@ const { registerKVCacheTools } = require('./tools/kv-cache');
 
 const server = new McpServer({
     name: 'n2-soul',
-    version: '6.0.2',
+    version: '6.0.3',
 });
 
 // ═══════════════════════════════════════════════════════

package/lib/ark/audit.js

@@ -18,7 +18,7 @@ class AuditLogger {
     constructor(options = {}) {
         this.dir = options.dir || path.join(process.cwd(), 'data', 'audit');
         this.enabled = options.enabled !== false;
-        this.maxAgeDays = options.maxAgeDays || 30;
+        this.maxAgeDays = options.maxAgeDays || 7;
         this.logPasses = options.logPasses || false;
         this._buffer = [];
         this._flushInterval = null;
@@ -30,6 +30,9 @@ class AuditLogger {
             // Flush buffer every 5 seconds
             this._flushInterval = setInterval(() => this._flush(), 5000);
             this._flushInterval.unref();  // Don't keep process alive just for audit flush
+
+            // Auto-cleanup old logs on startup
+            try { this.cleanup(); } catch (e) { /* silent */ }
         }
     }
 

package/lib/config.default.js

@@ -4,6 +4,8 @@ const path = require('path');
 module.exports = {
     // All paths derived dynamically. No hardcoding.
     SOUL_ROOT: path.resolve(__dirname, '..'),
+    // Cloud Storage (v6.1): Change DATA_DIR in config.local.js to any cloud sync folder
+    // e.g., 'G:/My Drive/n2-soul' or '\\\\server\\shared\\n2-soul'
     DATA_DIR: path.resolve(__dirname, '..', 'data'),
     TIMEZONE: 'Asia/Seoul',  // Override with config.local.js for other timezones
     AGENTS_DIR: null, // Auto-detected by agent-registry.js

package/lib/soul-engine.js

@@ -134,6 +134,31 @@ class SoulEngine {
         return { id, path: path.join(dir, fileName) };
     }
 
+    // -- All Projects (sorted by recency) --
+
+    /**
+     * List all projects sorted by most recently updated.
+     * Safe: returns [] if no projects directory exists.
+     * @returns {{ name: string, updatedAt: string, board: object }[]}
+     */
+    listAllProjects() {
+        const projectsDir = path.join(this.dataDir, 'projects');
+        if (!fs.existsSync(projectsDir)) return [];
+        try {
+            return fs.readdirSync(projectsDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('_'))
+                .filter(d => fs.existsSync(this.boardPath(d.name)))
+                .map(d => {
+                    const board = this.readBoard(d.name);
+                    return { name: d.name, updatedAt: board.updatedAt || '', board };
+                })
+                .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        } catch (e) {
+            logError('soul-engine:listAllProjects', e);
+            return [];
+        }
+    }
+
     // -- File Index --
 
     readFileIndex(projectName) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n2-soul",
-    "version": "6.0.2",
+    "version": "6.1.0",
     "description": "Multi-agent session orchestrator with KV-Cache and Ark for MCP (Model Context Protocol)",
     "main": "index.js",
     "scripts": {

package/sequences/boot.js

@@ -1,4 +1,4 @@
-// Soul MCP v5.0 — Boot sequence. Handoff + Entity/Core Memory injection + KV-Cache restore.
+// Soul MCP v6.0 — Boot sequence. Handoff + Entity/Core Memory injection + KV-Cache restore.
 const path = require('path');
 const fs = require('fs');
 const { readJson, today, nowISO, logError } = require('../lib/utils');
@@ -46,10 +46,19 @@ function registerBootSequence(server, z, config) {
                 lines.push(`Ark: LOAD FAILED — ${e.message}`);
             }
 
-            // -- Soul Board: handoff + TODO --
-            if (project) {
-                const board = engine.readBoard(project);
-                lines.push(`\n--- ${project} | v${board.state.version || '?'} | ${board.state.health || '?'} ---`);
+            // -- Soul Board: handoff + TODO (auto-detect latest project) --
+            let targetProject = project;
+            if (!targetProject) {
+                const allProjects = engine.listAllProjects();
+                if (allProjects.length > 0) {
+                    targetProject = allProjects[0].name;
+                    lines.push(`\n📍 Auto-detected latest project: ${targetProject}`);
+                }
+            }
+
+            if (targetProject) {
+                const board = engine.readBoard(targetProject);
+                lines.push(`\n--- ${targetProject} | v${board.state.version || '?'} | ${board.state.health || '?'} ---`);
 
                 if (board.handoff && board.handoff.summary) {
                     lines.push(`Handoff(${board.handoff.from}): ${board.handoff.summary}`);
@@ -70,13 +79,13 @@ function registerBootSequence(server, z, config) {
             }
 
             // -- KV-Cache auto-load --
-            if (project && config.KV_CACHE?.enabled && config.KV_CACHE?.autoLoadOnBoot) {
+            if (targetProject && config.KV_CACHE?.enabled && config.KV_CACHE?.autoLoadOnBoot) {
                 try {
                     const { SoulKVCache } = require('../lib/kv-cache');
                     const kvCache = new SoulKVCache(config.DATA_DIR, config.KV_CACHE);
-                    const snap = kvCache.load(project);
+                    const snap = kvCache.load(targetProject);
                     if (snap) {
-                        setKvChainParent(project, snap.id);
+                        setKvChainParent(targetProject, snap.id);
                         const level = snap._level || 'auto';
                         const tokens = snap._promptTokens || '?';
                         lines.push(`\nKV-Cache: ${level} | ~${tokens}t | ${snap.id.slice(0, 8)}`);
@@ -105,7 +114,7 @@ function registerBootSequence(server, z, config) {
                 lines.push(`⚠️ Core Memory: ${e.message}`);
             }
 
-            lines.push(`\n--- Soul Boot v5.0 complete ---`);
+            lines.push(`\n--- Soul Boot v6.0 complete ---`);
             return { content: [{ type: 'text', text: lines.join('\n') }] };
         }
     );

package/sequences/work.js

@@ -7,6 +7,19 @@ const { SoulEngine } = require('../lib/soul-engine');
 // In-memory work session state per project
 const activeSessions = {};
 
+// TTL: auto-expire stale sessions (24 hours, checked every hour)
+const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+const _sessionGcTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [project, session] of Object.entries(activeSessions)) {
+        if (session._createdMs && (now - session._createdMs) > SESSION_TTL_MS) {
+            delete activeSessions[project];
+            logError('work:ttl', `Expired stale session: ${project} (agent: ${session.agent})`);
+        }
+    }
+}, 60 * 60 * 1000);
+_sessionGcTimer.unref(); // Don't prevent Node.js from exiting
+
 // ── Helper: recursively walk files in a directory ──
 function walkFiles(dir, callback, maxDepth, depth = 0) {
     if (depth > maxDepth) return;
@@ -45,6 +58,7 @@ function registerWorkSequence(server, z, config) {
                 agent,
                 task,
                 startedAt: nowISO(),
+                _createdMs: Date.now(),
                 filesCreated: [],
                 filesModified: [],
                 filesDeleted: [],

package/tests/README.md

@@ -0,0 +1,5 @@
+# tests/
+
+Integration and unit tests for n2-soul.
+
+Run: `node tests/test-ark-integration.js`

package/{test-ark-integration.js → tests/test-ark-integration.js}

@@ -1,10 +1,10 @@
 // n2-ark + n2-soul integration test — pure last shield
 const path = require('path');
-const { createArk } = require('./lib/ark');
+const { createArk } = require('../lib/ark');
 
 const ark = createArk({
-    rulesDir: path.join(__dirname, 'rules'),
-    auditDir: path.join(__dirname, 'data', 'ark-audit'),
+    rulesDir: path.join(__dirname, '..', 'rules'),
+    auditDir: path.join(__dirname, '..', 'data', 'ark-audit'),
 });
 
 let passed = 0;