obsidian-brain-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HikaruHonda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# obsidian-brain-mcp
+
+Turn your Obsidian vault into a domain-specific AI brain. An MCP (Model Context Protocol) server that enables dynamic agent creation, knowledge management, and cross-agent intelligence.
+
+## Features
+
+- **Dynamic Agent Creation** — Create specialized domain agents that accumulate knowledge over time
+- **Belief Evolution** — Track how understanding changes with confidence scoring and supersede chains
+- **Decision Recording** — Capture decisions with context, reasoning, and outcomes
+- **Pattern Recognition** — Promote recurring patterns from accumulated decisions
+- **Cross-Agent Search** — Search knowledge across all agents simultaneously
+- **Knowledge Linking** — Create typed relationships between knowledge nodes across agents
+- **Conflict Detection** — Surface contradictory beliefs within and across agents
+- **Memory Consolidation** — Automatically archive and summarize aging knowledge
+- **Agent Dialogue** — Generate structured dialogue material between two agents on a topic
+- **Note Import** — Import existing Obsidian notes into agent knowledge bases
+
+## Installation
+
+```bash
+npm install -g obsidian-brain-mcp
+```
+
+## Configuration
+
+Set the environment variable to point to your Obsidian vault directory where agent brains will be stored:
+
+```bash
+export OBSIDIAN_BRAIN_VAULT_PATH="/path/to/your/obsidian-vault/AI Brain"
+```
+
+## Usage with Claude Code
+
+Add to your `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "obsidian-brain": {
+      "command": "obsidian-brain-mcp",
+      "env": {
+        "OBSIDIAN_BRAIN_VAULT_PATH": "/path/to/your/obsidian-vault/AI Brain"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description | Key Parameters |
+|------|-------------|----------------|
+| `create_agent` | Create a new domain agent | `name`, `description`, `scope` |
+| `list_agents` | List all agents with statistics | _(none)_ |
+| `get_agent_context` | Get full knowledge context for an agent (for prompt injection) | `agent` |
+| `suggest_agents` | Suggest relevant agents for a given task | `task` |
+| `record_decision` | Record a decision with context and reasoning | `agent`, `title`, `context`, `decision`, `reasoning`, `tags` |
+| `query_agent` | Search an agent's knowledge base | `agent`, `question` |
+| `evolve_belief` | Record or evolve a belief with confidence tracking | `agent`, `title`, `content`, `reasoning`, `supersedes?` |
+| `promote_pattern` | Promote a recurring pattern from decisions | `agent`, `title`, `description`, `conditions`, `decision_refs`, `confidence` |
+| `search_across_agents` | Search knowledge across all agents | `query` |
+| `link_knowledge` | Create typed links between knowledge across agents | `source_agent`, `source_file`, `target_agent`, `target_file`, `relationship` |
+| `detect_conflicts` | Detect contradictory beliefs within/across agents | `agent?` |
+| `consolidate_memory` | Archive and summarize aging knowledge | `agent`, `before_date?`, `dry_run?` |
+| `agent_dialogue` | Generate dialogue material between two agents on a topic | `agents` (array of 2), `topic` |
+| `import_notes` | Import existing Obsidian notes into an agent's knowledge base | `agent`, `note_path`, `import_as`, `title?` |
+
+## Vault Structure
+
+```
+{OBSIDIAN_BRAIN_VAULT_PATH}/
+├── _registry.md              # Agent registry
+├── master/                   # Default root agent
+│   ├── _agent.md
+│   ├── beliefs/
+│   ├── decisions/
+│   ├── patterns/
+│   ├── knowledge-links/
+│   └── consolidations/
+├── {agent-name}/
+│   ├── _agent.md
+│   ├── beliefs/
+│   │   └── {slug}.md         # Frontmatter: confidence, formed, supersedes
+│   ├── decisions/
+│   │   └── {date}-{slug}.md  # Frontmatter: tags, outcome
+│   ├── patterns/
+│   │   └── {slug}.md         # Frontmatter: confidence, derived_from
+│   ├── knowledge-links/
+│   │   └── {slug}.md         # Cross-agent relationship links
+│   └── consolidations/
+│       └── {date}-consolidated-{timestamp}.md
+└── ...
+```
+
+## How It Works
+
+Each agent lives as a directory in your Obsidian vault. Knowledge is stored as Markdown files with YAML frontmatter for metadata (confidence scores, timestamps, relationships, tags).
+
+When you create an agent, it gets its own directory with subdirectories for beliefs, decisions, patterns, knowledge-links, and consolidations. As you record decisions and evolve beliefs, the agent accumulates structured knowledge that can be queried, searched, and linked across agents.
+
+The frontmatter-based metadata system enables features like belief evolution (tracking how understanding changes over time via supersede chains), pattern promotion (elevating recurring decision patterns), and conflict detection (surfacing contradictory beliefs by comparing content across agents).
+
+Because everything is plain Markdown, you can browse, edit, and link your agent knowledge directly in Obsidian — or any text editor.
+
+## Requirements
+
+- Node.js >= 18.0.0
+- An Obsidian vault (or any directory — Obsidian is optional but recommended for browsing)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { ensureBrainDir } from "./vault.js";
+import { createAgent } from "./tools/create-agent.js";
+import { listAgents } from "./tools/list-agents.js";
+import { getAgentContext } from "./tools/get-agent-context.js";
+import { suggestAgents } from "./tools/suggest-agents.js";
+import { recordDecision } from "./tools/record-decision.js";
+import { queryAgent } from "./tools/query-agent.js";
+import { evolveBelief } from "./tools/evolve-belief.js";
+import { promotePattern } from "./tools/promote-pattern.js";
+import { searchAcrossAgents } from "./tools/search-across-agents.js";
+import { linkKnowledge } from "./tools/link-knowledge.js";
+import { detectConflicts } from "./tools/detect-conflicts.js";
+import { consolidateMemory } from "./tools/consolidate-memory.js";
+import { agentDialogue } from "./tools/agent-dialogue.js";
+import { importNotes } from "./tools/import-notes.js";
+const server = new Server({ name: "obsidian-brain-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "create_agent",
+            description: "新しいドメインエージェントを作成",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "エージェント名" },
+                    description: { type: "string", description: "エージェントの説明" },
+                    scope: { type: "string", description: "担当スコープ" },
+                },
+                required: ["name", "description", "scope"],
+            },
+        },
+        {
+            name: "list_agents",
+            description: "全エージェント一覧と統計",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "get_agent_context",
+            description: "特定エージェントの全知識を取得（prompt注入用）",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", description: "エージェント名" },
+                },
+                required: ["agent"],
+            },
+        },
+        {
+            name: "suggest_agents",
+            description: "タスクに関連するエージェントを提案",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task: { type: "string", description: "タスクの説明" },
+                },
+                required: ["task"],
+            },
+        },
+        {
+            name: "record_decision",
+            description: "判断を記録",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", description: "エージェント名" },
+                    title: { type: "string", description: "判断のタイトル" },
+                    context: { type: "string", description: "状況・背景" },
+                    decision: { type: "string", description: "判断内容" },
+                    reasoning: { type: "string", description: "理由" },
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "タグ",
+                    },
+                },
+                required: ["agent", "title", "context", "decision", "reasoning", "tags"],
+            },
+        },
+        {
+            name: "query_agent",
+            description: "エージェントの知識を検索",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", description: "エージェント名" },
+                    question: { type: "string", description: "検索クエリ" },
+                },
+                required: ["agent", "question"],
+            },
+        },
+        {
+            name: "evolve_belief",
+            description: "信念を記録・進化",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", description: "エージェント名" },
+                    title: { type: "string", description: "信念のタイトル" },
+                    content: { type: "string", description: "信念の内容" },
+                    reasoning: { type: "string", description: "根拠" },
+                    supersedes: {
+                        type: "string",
+                        description: "置き換える信念のファイル名（任意）",
+                    },
+                },
+                required: ["agent", "title", "content", "reasoning"],
+            },
+        },
+        {
+            name: "promote_pattern",
+            description: "パターンを昇格",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", description: "エージェント名" },
+                    title: { type: "string", description: "パターンのタイトル" },
+                    description: { type: "string", description: "パターンの説明" },
+                    conditions: { type: "string", description: "適用条件" },
+                    decision_refs: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "根拠となる判断のファイル名",
+                    },
+                    confidence: { type: "number", description: "確信度（0-1）" },
+                },
+                required: ["agent", "title", "description", "conditions", "decision_refs", "confidence"],
+            },
+        },
+        {
+            name: "search_across_agents",
+            description: "全エージェントの知識を横断検索します",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "検索キーワード" },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "link_knowledge",
+            description: "エージェント間の知識をリンクで接続します",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    source_agent: { type: "string", description: "リンク元エージェント名" },
+                    source_file: { type: "string", description: "リンク元ファイル名" },
+                    target_agent: { type: "string", description: "リンク先エージェント名" },
+                    target_file: { type: "string", description: "リンク先ファイル名" },
+                    relationship: {
+                        type: "string",
+                        enum: ["supports", "contradicts", "extends", "related"],
+                        description: "リンクの関係性",
+                    },
+                },
+                required: ["source_agent", "source_file", "target_agent", "target_file", "relationship"],
+            },
+        },
+        {
+            name: "detect_conflicts",
+            description: "エージェント内・エージェント間の信念の矛盾候補を検出します",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", description: "対象エージェント（省略時は全エージェント）" },
+                },
+            },
+        },
+        {
+            name: "consolidate_memory",
+            description: "古い記憶を統合・整理します",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string" },
+                    before_date: { type: "string", description: "この日付以前の記憶を対象（YYYY-MM-DD、デフォルト30日前）" },
+                    dry_run: { type: "boolean", description: "trueなら対象一覧のみ返す（デフォルトtrue）" },
+                },
+                required: ["agent"],
+            },
+        },
+        {
+            name: "agent_dialogue",
+            description: "2つのエージェント間でトピックについての対話素材を生成します",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agents: {
+                        type: "array",
+                        items: { type: "string" },
+                        minItems: 2,
+                        maxItems: 2,
+                        description: "対話させる2つのエージェント名",
+                    },
+                    topic: { type: "string", description: "対話のトピック" },
+                },
+                required: ["agents", "topic"],
+            },
+        },
+        {
+            name: "import_notes",
+            description: "既存のObsidianノートをエージェントの知識として取り込みます",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string" },
+                    note_path: { type: "string", description: "ノートのパス（絶対パスまたはVault相対パス）" },
+                    import_as: {
+                        type: "string",
+                        enum: ["belief", "decision", "pattern"],
+                        description: "取り込む知識の種類",
+                    },
+                    title: { type: "string", description: "タイトル（省略時はファイル名）" },
+                },
+                required: ["agent", "note_path", "import_as"],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "create_agent": {
+                const result = await createAgent(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "list_agents": {
+                const result = await listAgents();
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "get_agent_context": {
+                const result = await getAgentContext(args.agent);
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "suggest_agents": {
+                const result = await suggestAgents(args);
+                return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+            }
+            case "record_decision": {
+                const result = await recordDecision(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "query_agent": {
+                const result = await queryAgent(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "evolve_belief": {
+                const result = await evolveBelief(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "promote_pattern": {
+                const result = await promotePattern(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "search_across_agents": {
+                const result = await searchAcrossAgents(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "link_knowledge": {
+                const result = await linkKnowledge(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "detect_conflicts": {
+                const result = await detectConflicts(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "consolidate_memory": {
+                const result = await consolidateMemory(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "agent_dialogue": {
+                const result = await agentDialogue(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "import_notes": {
+                const result = await importNotes(args);
+                return { content: [{ type: "text", text: result }] };
+            }
+            default:
+                return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: message }], isError: true };
+    }
+});
+async function main() {
+    await ensureBrainDir();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/tools/agent-dialogue.d.ts

@@ -0,0 +1,5 @@
+export interface AgentDialogueInput {
+    agents: string[];
+    topic: string;
+}
+export declare function agentDialogue(input: AgentDialogueInput): Promise<string>;

package/dist/tools/agent-dialogue.js

@@ -0,0 +1,121 @@
+import path from "node:path";
+import { agentDir, agentExists, readMarkdown, listFiles } from "../vault.js";
+export async function agentDialogue(input) {
+    const { agents, topic } = input;
+    if (agents.length !== 2) {
+        throw new Error(`agents must be exactly 2, got ${agents.length}.`);
+    }
+    for (const agent of agents) {
+        if (!(await agentExists(agent))) {
+            throw new Error(`Agent "${agent}" not found.`);
+        }
+    }
+    const keywords = topic
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length > 1);
+    function matchesKeywords(text) {
+        const lower = text.toLowerCase();
+        return keywords.some((kw) => lower.includes(kw));
+    }
+    const sections = [];
+    const allAgentBeliefs = [];
+    const allAgentDecisions = [];
+    const allAgentPatterns = [];
+    for (const agent of agents) {
+        const dir = agentDir(agent);
+        // Beliefs (exclude superseded)
+        const beliefFiles = await listFiles(path.join(dir, "beliefs"), ".md");
+        const relevantBeliefs = [];
+        for (const file of beliefFiles) {
+            const { data, content } = await readMarkdown(path.join(dir, "beliefs", file));
+            if (data.superseded_by)
+                continue;
+            const title = data.title ?? "";
+            if (matchesKeywords(title) || matchesKeywords(content)) {
+                relevantBeliefs.push({
+                    title,
+                    content: content.trim(),
+                    agent: data.agent ?? agent,
+                    confidence: data.confidence ?? 0,
+                    formed: data.formed ?? "",
+                    reasoning: data.reasoning ?? "",
+                    supersedes: data.supersedes,
+                    superseded_by: data.superseded_by,
+                    evidence_count: data.evidence_count ?? 0,
+                    filename: file,
+                });
+            }
+        }
+        // Decisions
+        const decisionFiles = await listFiles(path.join(dir, "decisions"), ".md");
+        const relevantDecisions = [];
+        for (const file of decisionFiles) {
+            const { data, content } = await readMarkdown(path.join(dir, "decisions", file));
+            const title = data.title ?? "";
+            if (matchesKeywords(title) || matchesKeywords(content)) {
+                relevantDecisions.push({
+                    title,
+                    agent: data.agent ?? agent,
+                    context: data.context ?? "",
+                    decision: data.decision ?? "",
+                    reasoning: data.reasoning ?? "",
+                    tags: data.tags ?? [],
+                    date: data.date ?? "",
+                    outcome: data.outcome ?? "",
+                    filename: file,
+                });
+            }
+        }
+        // Patterns
+        const patternFiles = await listFiles(path.join(dir, "patterns"), ".md");
+        const relevantPatterns = [];
+        for (const file of patternFiles) {
+            const { data, content } = await readMarkdown(path.join(dir, "patterns", file));
+            const title = data.title ?? "";
+            const description = data.description ?? "";
+            if (matchesKeywords(title) ||
+                matchesKeywords(description) ||
+                matchesKeywords(content)) {
+                relevantPatterns.push({
+                    title,
+                    agent: data.agent ?? agent,
+                    description,
+                    conditions: data.conditions ?? "",
+                    confidence: data.confidence ?? 0,
+                    derived_from: data.derived_from ?? [],
+                    min_evidence: data.min_evidence ?? 0,
+                    filename: file,
+                });
+            }
+        }
+        // Build section
+        const beliefLines = relevantBeliefs.map((b) => {
+            const snippet = b.content.slice(0, 80).replace(/\n/g, " ");
+            return `- ${b.title} (confidence: ${b.confidence}): ${snippet}`;
+        });
+        const decisionLines = relevantDecisions.map((d) => {
+            const snippet = (d.decision || d.context).slice(0, 80).replace(/\n/g, " ");
+            return `- ${d.title}: ${snippet}`;
+        });
+        const patternLines = relevantPatterns.map((p) => {
+            return `- ${p.title}: ${p.description}`;
+        });
+        allAgentBeliefs.push(beliefLines);
+        allAgentDecisions.push(decisionLines);
+        allAgentPatterns.push(patternLines);
+        let section = `## ${agent} の視点\n`;
+        section += `\n### 信念\n${beliefLines.length > 0 ? beliefLines.join("\n") : "該当なし"}\n`;
+        section += `\n### 意思決定\n${decisionLines.length > 0 ? decisionLines.join("\n") : "該当なし"}\n`;
+        section += `\n### パターン\n${patternLines.length > 0 ? patternLines.join("\n") : "該当なし"}\n`;
+        sections.push(section);
+    }
+    const totalItems = allAgentBeliefs.flat().length + allAgentDecisions.flat().length + allAgentPatterns.flat().length;
+    if (totalItems === 0) {
+        return `トピック「${topic}」に関連する信念・意思決定・パターンは両エージェントとも見つかりませんでした。`;
+    }
+    // Dialogue points
+    const hasShared = allAgentBeliefs[0].length > 0 && allAgentBeliefs[1].length > 0;
+    const dialoguePoints = `## 対話のための論点\n- 共通するテーマ: ${hasShared ? "両エージェントがこのトピックについて信念を持っています" : "一方のみがこのトピックに関連する信念を持っています"}\n- 異なる視点: 各エージェントのconfidence値や推論の違いを比較してください`;
+    return `# エージェント対話: ${topic}\n\n${sections.join("\n")}\n${dialoguePoints}`;
+}

package/dist/tools/consolidate-memory.d.ts

@@ -0,0 +1,6 @@
+export interface ConsolidateMemoryInput {
+    agent: string;
+    before_date?: string;
+    dry_run?: boolean;
+}
+export declare function consolidateMemory(input: ConsolidateMemoryInput): Promise<string>;

package/dist/tools/consolidate-memory.js

@@ -0,0 +1,87 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { agentDir, agentExists, readMarkdown, writeMarkdown, listFiles, } from "../vault.js";
+export async function consolidateMemory(input) {
+    const { agent, dry_run = true } = input;
+    if (!(await agentExists(agent))) {
+        throw new Error(`Agent "${agent}" not found.`);
+    }
+    const today = new Date().toISOString().slice(0, 10);
+    const beforeDate = input.before_date ??
+        new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+    const dir = agentDir(agent);
+    // Collect beliefs before the date
+    const beliefFiles = await listFiles(path.join(dir, "beliefs"), ".md");
+    const targets = [];
+    for (const file of beliefFiles) {
+        const { data, content } = await readMarkdown(path.join(dir, "beliefs", file));
+        const formed = data.formed ?? "";
+        if (formed && formed < beforeDate) {
+            targets.push({
+                file: path.join(dir, "beliefs", file),
+                type: "belief",
+                title: data.title ?? file,
+                content: content.trim(),
+                date: formed,
+            });
+        }
+    }
+    // Collect decisions before the date
+    const decisionFiles = await listFiles(path.join(dir, "decisions"), ".md");
+    for (const file of decisionFiles) {
+        const { data, content } = await readMarkdown(path.join(dir, "decisions", file));
+        const date = data.date ?? "";
+        if (date && date < beforeDate) {
+            targets.push({
+                file: path.join(dir, "decisions", file),
+                type: "decision",
+                title: data.title ?? file,
+                content: content.trim(),
+                date,
+            });
+        }
+    }
+    if (targets.length === 0) {
+        return `対象なし: ${beforeDate} 以前のbelief/decisionはありません。`;
+    }
+    // dry_run: list only
+    if (dry_run) {
+        const lines = targets.map((t) => `- **${t.title}** (${t.type}, ${t.date})`);
+        return `## 統合候補 (dry_run)\n\nagent: ${agent}\nbefore: ${beforeDate}\n対象: ${targets.length}件\n\n${lines.join("\n")}`;
+    }
+    // Execute consolidation
+    const consolidationsDir = path.join(dir, "consolidations");
+    await fs.mkdir(consolidationsDir, { recursive: true });
+    const dates = targets.map((t) => t.date).sort();
+    const oldest = dates[0];
+    const newest = dates[dates.length - 1];
+    const dateRange = `${oldest}~${newest}`;
+    const entryLines = targets.map((t) => {
+        const snippet = t.content.slice(0, 100).replace(/\n/g, " ");
+        return `- **${t.title}** (${t.type}): ${snippet}`;
+    });
+    const body = `# 統合メモリ: ${agent}
+
+## 対象期間
+${dateRange}
+
+## エントリ一覧
+${entryLines.join("\n")}
+`;
+    const filename = `${today}-consolidated-${Date.now()}.md`;
+    const filePath = path.join(consolidationsDir, filename);
+    await writeMarkdown(filePath, {
+        type: "consolidation",
+        agent,
+        source_count: targets.length,
+        date_range: dateRange,
+        created: today,
+    }, body);
+    // Mark originals as archived
+    for (const t of targets) {
+        const { data, content } = await readMarkdown(t.file);
+        data.archived = true;
+        await writeMarkdown(t.file, data, content);
+    }
+    return `統合完了: ${targets.length}件を ${filename} に統合しました。元ファイルに archived: true を追記済み。`;
+}

package/dist/tools/create-agent.d.ts

@@ -0,0 +1,6 @@
+export interface CreateAgentInput {
+    name: string;
+    description: string;
+    scope: string;
+}
+export declare function createAgent(input: CreateAgentInput): Promise<string>;