agent-recall-mcp 3.2.3 → 3.3.1

package/dist/index.js

@@ -1,32 +1,30 @@
 #!/usr/bin/env node
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import * as z from "zod/v4";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const VERSION = "3.2.2";
-const JOURNAL_ROOT = process.env.AGENT_RECALL_ROOT ||
-    path.join(os.homedir(), ".agent-recall");
-const LEGACY_ROOT = path.join(os.homedir(), ".claude", "projects");
-const SECTION_HEADERS = {
-    brief: "## Brief",
-    qa: "## Q&A Log",
-    completed: "## Completed",
-    status: "## Status",
-    blockers: "## Blockers",
-    next: "## Next",
-    decisions: "## Decisions",
-    reflection: "## Reflection",
-    files: "## Files Changed",
-    observations: "## Observations",
-};
+import { VERSION, JOURNAL_ROOT, LEGACY_ROOT } from "./types.js";
+import { server } from "./server.js";
+// Import all tool registrations
+import { register as registerJournalRead } from "./tools/journal-read.js";
+import { register as registerJournalWrite } from "./tools/journal-write.js";
+import { register as registerJournalCapture } from "./tools/journal-capture.js";
+import { register as registerJournalList } from "./tools/journal-list.js";
+import { register as registerJournalProjects } from "./tools/journal-projects.js";
+import { register as registerJournalSearch } from "./tools/journal-search.js";
+import { register as registerJournalState } from "./tools/journal-state.js";
+import { register as registerJournalColdStart } from "./tools/journal-cold-start.js";
+import { register as registerJournalArchive } from "./tools/journal-archive.js";
+import { register as registerAlignmentCheck } from "./tools/alignment-check.js";
+import { register as registerNudge } from "./tools/nudge.js";
+import { register as registerContextSynthesize } from "./tools/context-synthesize.js";
+import { register as registerKnowledgeWrite } from "./tools/knowledge-write.js";
+import { register as registerKnowledgeRead } from "./tools/knowledge-read.js";
+import { register as registerPalaceRead } from "./tools/palace-read.js";
+import { register as registerPalaceWrite } from "./tools/palace-write.js";
+import { register as registerPalaceWalk } from "./tools/palace-walk.js";
+import { register as registerPalaceLint } from "./tools/palace-lint.js";
+import { register as registerPalaceSearch } from "./tools/palace-search.js";
+import { register as registerAwarenessUpdate } from "./tools/awareness-update.js";
+import { register as registerRecallInsight } from "./tools/recall-insight.js";
+import { register as registerJournalResources } from "./resources/journal-resources.js";
 // ---------------------------------------------------------------------------
 // CLI flags (handle before MCP starts)
 // ---------------------------------------------------------------------------
@@ -62,1183 +60,45 @@ if (args.includes("--list-tools")) {
         { name: "journal_state", description: "Layer 1 JSON state: read/write structured session data (v3)" },
         { name: "journal_cold_start", description: "Cache-aware cold start: hot/warm/cold entries (v3)" },
         { name: "journal_archive", description: "Archive old entries to cold storage (v3)" },
+        { name: "knowledge_write", description: "Write a structured lesson to a category-specific knowledge file" },
+        { name: "knowledge_read", description: "Read lessons from knowledge files, optionally filtered by project/category/query" },
+        { name: "palace_read", description: "Read a room or list all rooms in the Memory Palace" },
+        { name: "palace_write", description: "Write memory to a palace room with fan-out cross-referencing" },
+        { name: "palace_walk", description: "Progressive context loading: identity → active → relevant → full" },
+        { name: "palace_lint", description: "Health check: stale, orphans, low salience, missing refs" },
+        { name: "palace_search", description: "Search across palace rooms, ranked by salience" },
+        { name: "awareness_update", description: "Update awareness with new insights (call at session end)" },
+        { name: "recall_insight", description: "Recall cross-project insights relevant to current task" },
     ];
     process.stdout.write(JSON.stringify(tools, null, 2) + "\n");
     process.exit(0);
 }
 // ---------------------------------------------------------------------------
-// Utility functions
-// ---------------------------------------------------------------------------
-function ensureDir(dir) {
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-}
-function todayISO() {
-    return new Date().toISOString().slice(0, 10);
-}
-/**
- * Auto-detect project slug from environment, git, or cwd.
- * Async to avoid blocking the event loop.
- */
-let _cachedProject = null;
-async function detectProject() {
-    if (_cachedProject)
-        return _cachedProject;
-    // 1. Env var
-    if (process.env.AGENT_RECALL_PROJECT) {
-        _cachedProject = process.env.AGENT_RECALL_PROJECT;
-        return _cachedProject;
-    }
-    // 2. Git repo name (async)
-    try {
-        const { stdout } = await execFileAsync("git", ["config", "--get", "remote.origin.url"], { timeout: 3000 });
-        const remote = stdout.trim();
-        if (remote) {
-            const name = path.basename(remote, ".git");
-            if (name) {
-                _cachedProject = name;
-                return name;
-            }
-        }
-    }
-    catch {
-        try {
-            const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { timeout: 3000 });
-            const root = stdout.trim();
-            if (root) {
-                _cachedProject = path.basename(root);
-                return _cachedProject;
-            }
-        }
-        catch {
-            // fall through
-        }
-    }
-    // 3. package.json name
-    const cwd = process.cwd();
-    const pkgPath = path.join(cwd, "package.json");
-    if (fs.existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-            if (pkg.name) {
-                _cachedProject = pkg.name.replace(/^@[^/]+\//, "");
-                return _cachedProject;
-            }
-        }
-        catch {
-            // fall through
-        }
-    }
-    // 4. Basename of cwd
-    _cachedProject = path.basename(cwd);
-    return _cachedProject;
-}
-/**
- * Resolve the journal directory for a project, checking both new and legacy locations.
- * For writes, always use the new location.
- */
-function journalDir(project) {
-    // Sanitize: prevent path traversal (e.g. "../../etc")
-    const safe = project.replace(/[^a-zA-Z0-9_\-\.]/g, "-");
-    const resolved = path.join(JOURNAL_ROOT, "projects", safe, "journal");
-    if (!resolved.startsWith(JOURNAL_ROOT)) {
-        throw new Error(`Invalid project name: ${project}`);
-    }
-    return resolved;
-}
-/**
- * Find all journal directories for a project (new + legacy fallback).
- */
-function journalDirs(project) {
-    const dirs = [];
-    const primary = journalDir(project);
-    if (fs.existsSync(primary))
-        dirs.push(primary);
-    // Legacy: ~/.claude/projects/*/memory/journal/
-    // We try to match project slug in the directory name
-    if (fs.existsSync(LEGACY_ROOT)) {
-        try {
-            const entries = fs.readdirSync(LEGACY_ROOT);
-            for (const entry of entries) {
-                if (entry.includes(project)) {
-                    const legacyJournal = path.join(LEGACY_ROOT, entry, "memory", "journal");
-                    if (fs.existsSync(legacyJournal)) {
-                        dirs.push(legacyJournal);
-                    }
-                }
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    return dirs;
-}
-/**
- * List all .md journal files across all directories for a project.
- * Returns sorted array of { date, file, dir } with most recent first.
- */
-function listJournalFiles(project) {
-    const dirs = journalDirs(project);
-    const entries = [];
-    const seen = new Set();
-    for (const dir of dirs) {
-        if (!fs.existsSync(dir))
-            continue;
-        const files = fs.readdirSync(dir);
-        for (const file of files) {
-            // Match YYYY-MM-DD.md (not log files)
-            const match = file.match(/^(\d{4}-\d{2}-\d{2})\.md$/);
-            if (match && !seen.has(match[1])) {
-                seen.add(match[1]);
-                entries.push({ date: match[1], file, dir });
-            }
-        }
-    }
-    entries.sort((a, b) => b.date.localeCompare(a.date));
-    return entries;
-}
-/**
- * Read a journal file. Checks primary dir first, then legacy.
- */
-function readJournalFile(project, date) {
-    const filename = `${date}.md`;
-    const dirs = journalDirs(project);
-    // Also check primary dir even if it wasn't in journalDirs (might not exist yet)
-    const primaryDir = journalDir(project);
-    const allDirs = [primaryDir, ...dirs.filter((d) => d !== primaryDir)];
-    for (const dir of allDirs) {
-        const filePath = path.join(dir, filename);
-        if (fs.existsSync(filePath)) {
-            return fs.readFileSync(filePath, "utf-8");
-        }
-    }
-    return null;
-}
-/**
- * Extract a section from a markdown journal entry.
- */
-function extractSection(content, section) {
-    if (section === "all")
-        return content;
-    if (section === "brief") {
-        // Brief = first 3 non-empty lines after the title + momentum line if present
-        const lines = content.split("\n");
-        const nonEmpty = [];
-        let pastTitle = false;
-        for (const line of lines) {
-            if (line.startsWith("# ")) {
-                pastTitle = true;
-                continue;
-            }
-            if (!pastTitle)
-                continue;
-            const trimmed = line.trim();
-            if (trimmed === "")
-                continue;
-            nonEmpty.push(trimmed);
-            if (nonEmpty.length >= 4)
-                break; // 3 sentences + momentum
-        }
-        return nonEmpty.join("\n") || null;
-    }
-    const header = SECTION_HEADERS[section];
-    if (!header)
-        return null;
-    const idx = content.indexOf(header);
-    if (idx === -1)
-        return null;
-    // Find the next ## header (respecting code fences)
-    const afterHeader = content.slice(idx);
-    const lines = afterHeader.split("\n");
-    const result = [lines[0]];
-    let inCodeFence = false;
-    for (let i = 1; i < lines.length; i++) {
-        if (lines[i].startsWith("```"))
-            inCodeFence = !inCodeFence;
-        if (!inCodeFence && lines[i].startsWith("## "))
-            break;
-        result.push(lines[i]);
-    }
-    return result.join("\n").trimEnd();
-}
-/**
- * Extract title from journal file content.
- */
-function extractTitle(content) {
-    const match = content.match(/^# (.+)$/m);
-    return match ? match[1].trim() : "(untitled)";
-}
-/**
- * Extract momentum indicator from journal content.
- */
-function extractMomentum(content) {
-    // Look for momentum patterns like 🟢 加速, 🟡 稳定, 🔴 减速
-    const patterns = [/[🟢🟡🔴⚪]\s*\S+/];
-    for (const pattern of patterns) {
-        const match = content.match(pattern);
-        if (match)
-            return match[0];
-    }
-    return "";
-}
-/**
- * Append content to a specific section in a journal file, or to end of file.
- */
-function appendToSection(existingContent, newContent, section) {
-    if (section === "replace_all") {
-        return newContent;
-    }
-    if (!section) {
-        // Append to end
-        return existingContent.trimEnd() + "\n\n" + newContent + "\n";
-    }
-    const header = SECTION_HEADERS[section];
-    if (!header) {
-        // Unknown section — append to end
-        return existingContent.trimEnd() + "\n\n" + newContent + "\n";
-    }
-    const idx = existingContent.indexOf(header);
-    if (idx === -1) {
-        // Section doesn't exist — append it
-        return (existingContent.trimEnd() + "\n\n" + header + "\n\n" + newContent + "\n");
-    }
-    // Find the end of this section (next ## header or EOF, respecting code fences)
-    const afterHeader = existingContent.slice(idx);
-    const lines = afterHeader.split("\n");
-    let insertAt = lines.length;
-    let inCodeFence = false;
-    for (let i = 1; i < lines.length; i++) {
-        if (lines[i].startsWith("```"))
-            inCodeFence = !inCodeFence;
-        if (!inCodeFence && lines[i].startsWith("## ")) {
-            insertAt = i;
-            break;
-        }
-    }
-    // Insert before the next section
-    const before = existingContent.slice(0, idx + lines.slice(0, insertAt).join("\n").length);
-    const after = existingContent.slice(idx + lines.slice(0, insertAt).join("\n").length);
-    return before.trimEnd() + "\n\n" + newContent + "\n" + after;
-}
-/**
- * Update the index.md for a project.
- */
-function updateIndex(project) {
-    const dir = journalDir(project);
-    ensureDir(dir);
-    const indexPath = path.join(dir, "index.md");
-    const entries = listJournalFiles(project);
-    let index = `# ${project} — Journal Index\n\n`;
-    index += `> Auto-generated. ${entries.length} entries.\n\n`;
-    index += `| Date | Title | Momentum |\n`;
-    index += `|------|-------|----------|\n`;
-    for (const entry of entries) {
-        const content = fs.readFileSync(path.join(entry.dir, entry.file), "utf-8");
-        const title = extractTitle(content);
-        const momentum = extractMomentum(content);
-        index += `| ${entry.date} | ${title} | ${momentum} |\n`;
-    }
-    fs.writeFileSync(indexPath, index, "utf-8");
-}
-/**
- * Count entries in a log file (for journal_capture entry numbering).
- */
-function countLogEntries(logPath) {
-    if (!fs.existsSync(logPath))
-        return 0;
-    const content = fs.readFileSync(logPath, "utf-8");
-    const matches = content.match(/^### Q\d+/gm);
-    return matches ? matches.length : 0;
-}
-/**
- * List all projects (from both new and legacy locations).
- */
-function listAllProjects() {
-    const projects = new Map();
-    // New location
-    const projectsDir = path.join(JOURNAL_ROOT, "projects");
-    if (fs.existsSync(projectsDir)) {
-        const dirs = fs.readdirSync(projectsDir);
-        for (const slug of dirs) {
-            const jDir = path.join(projectsDir, slug, "journal");
-            if (fs.existsSync(jDir)) {
-                const files = fs.readdirSync(jDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f));
-                if (files.length > 0) {
-                    files.sort().reverse();
-                    projects.set(slug, {
-                        slug,
-                        lastEntry: files[0].replace(".md", ""),
-                        entryCount: files.length,
-                    });
-                }
-            }
-        }
-    }
-    // Legacy location
-    if (fs.existsSync(LEGACY_ROOT)) {
-        try {
-            const entries = fs.readdirSync(LEGACY_ROOT);
-            for (const entry of entries) {
-                const journalPath = path.join(LEGACY_ROOT, entry, "memory", "journal");
-                if (fs.existsSync(journalPath)) {
-                    // Derive slug from directory name (e.g., "-Users-tongwu-some-project" -> "some-project")
-                    const parts = entry.split("-").filter(Boolean);
-                    const slug = parts[parts.length - 1] || entry;
-                    if (!projects.has(slug)) {
-                        const files = fs.readdirSync(journalPath).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f));
-                        if (files.length > 0) {
-                            files.sort().reverse();
-                            projects.set(slug, {
-                                slug,
-                                lastEntry: files[0].replace(".md", ""),
-                                entryCount: files.length,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    const result = Array.from(projects.values());
-    result.sort((a, b) => b.lastEntry.localeCompare(a.lastEntry));
-    return result;
-}
-/**
- * Resolve "auto" project to actual slug.
- */
-async function resolveProject(project) {
-    if (!project || project === "auto") {
-        return await detectProject();
-    }
-    return project;
-}
-// ---------------------------------------------------------------------------
-// MCP Server
-// ---------------------------------------------------------------------------
-const server = new McpServer({
-    name: "agent-recall",
-    version: VERSION,
-});
-// ---------------------------------------------------------------------------
-// Tool: journal_read
-// ---------------------------------------------------------------------------
-server.registerTool("journal_read", {
-    title: "Read Journal Entry",
-    description: "Read a journal entry. Returns the full file content for agent cold-start. Use date='latest' for the most recent entry.",
-    inputSchema: {
-        date: z
-            .string()
-            .default("latest")
-            .describe("ISO date string YYYY-MM-DD. Defaults to 'latest'. Use 'latest' for most recent entry."),
-        project: z
-            .string()
-            .default("auto")
-            .describe("Project slug (directory name under ~/.agent-recall/projects/). Defaults to current git repo name."),
-        section: z
-            .enum([
-            "all",
-            "brief",
-            "qa",
-            "completed",
-            "status",
-            "blockers",
-            "next",
-            "decisions",
-            "reflection",
-            "files",
-            "observations",
-        ])
-            .default("all")
-            .describe("Which section to return. 'brief' returns only the cold-start summary. 'all' returns full file."),
-    },
-}, async ({ date, project, section }) => {
-    const slug = await resolveProject(project);
-    let targetDate = date;
-    if (targetDate === "latest") {
-        const entries = listJournalFiles(slug);
-        if (entries.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: `No journal entries found for project '${slug}'`,
-                            project: slug,
-                        }),
-                    },
-                ],
-                isError: true,
-            };
-        }
-        targetDate = entries[0].date;
-    }
-    const fileContent = readJournalFile(slug, targetDate);
-    if (!fileContent) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: `No journal entry found for ${targetDate} in project '${slug}'`,
-                        project: slug,
-                        date: targetDate,
-                    }),
-                },
-            ],
-            isError: true,
-        };
-    }
-    const extracted = extractSection(fileContent, section);
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    content: extracted || "",
-                    date: targetDate,
-                    project: slug,
-                }),
-            },
-        ],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: journal_write
-// ---------------------------------------------------------------------------
-server.registerTool("journal_write", {
-    title: "Write Journal Entry",
-    description: "Append content to the current journal entry (creates today's file if absent). Use section='replace_all' to overwrite entire file.",
-    inputSchema: {
-        content: z.string().describe("Markdown content to append or write."),
-        section: z
-            .enum([
-            "qa",
-            "completed",
-            "blockers",
-            "next",
-            "decisions",
-            "observations",
-            "replace_all",
-        ])
-            .optional()
-            .describe("Target section. If omitted, appends to end of file. 'replace_all' overwrites entire file."),
-        project: z
-            .string()
-            .default("auto")
-            .describe("Project slug. Defaults to auto-detect."),
-    },
-}, async ({ content, section, project }) => {
-    const slug = await resolveProject(project);
-    const date = todayISO();
-    const dir = journalDir(slug);
-    ensureDir(dir);
-    const filePath = path.join(dir, `${date}.md`);
-    let existing = "";
-    if (fs.existsSync(filePath)) {
-        existing = fs.readFileSync(filePath, "utf-8");
-    }
-    else if (!section || section !== "replace_all") {
-        // Create a new file with a title
-        existing = `# ${date} — ${slug}\n`;
-    }
-    const sectionArg = section ?? null;
-    const updated = appendToSection(existing, content, sectionArg);
-    fs.writeFileSync(filePath, updated, "utf-8");
-    // Update index
-    updateIndex(slug);
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    success: true,
-                    date,
-                    file: filePath,
-                }),
-            },
-        ],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: journal_capture
-// ---------------------------------------------------------------------------
-server.registerTool("journal_capture", {
-    title: "Capture Q&A",
-    description: "Layer 1: lightweight Q&A capture. Appends to today's log file without loading the full journal.",
-    inputSchema: {
-        question: z
-            .string()
-            .describe("The human's question or request (summarized, 1 sentence)"),
-        answer: z
-            .string()
-            .describe("The agent's key answer or decision (summarized, 1-2 sentences)"),
-        tags: z
-            .array(z.string())
-            .optional()
-            .describe("Optional tags for this entry (e.g. ['decision', 'bug-fix', 'architecture'])"),
-        project: z
-            .string()
-            .default("auto")
-            .describe("Project slug. Defaults to auto-detect."),
-    },
-}, async ({ question, answer, tags, project }) => {
-    const slug = await resolveProject(project);
-    const date = todayISO();
-    const dir = journalDir(slug);
-    ensureDir(dir);
-    const logPath = path.join(dir, `${date}-log.md`);
-    const entryNum = countLogEntries(logPath) + 1;
-    const tagStr = tags && tags.length > 0 ? ` [${tags.join(", ")}]` : "";
-    const timestamp = new Date().toISOString().slice(11, 19);
-    let entry = `### Q${entryNum} (${timestamp})${tagStr}\n\n`;
-    entry += `**Q:** ${question}\n\n`;
-    entry += `**A:** ${answer}\n\n`;
-    if (!fs.existsSync(logPath)) {
-        const header = `# ${date} — ${slug} — Session Log\n\n`;
-        fs.writeFileSync(logPath, header + entry, "utf-8");
-    }
-    else {
-        fs.appendFileSync(logPath, entry, "utf-8");
-    }
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    success: true,
-                    entry_number: entryNum,
-                }),
-            },
-        ],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: journal_list
-// ---------------------------------------------------------------------------
-server.registerTool("journal_list", {
-    title: "List Journal Entries",
-    description: "List available journal entries for a project.",
-    inputSchema: {
-        project: z
-            .string()
-            .default("auto")
-            .describe("Project slug. Defaults to auto-detect."),
-        limit: z
-            .number()
-            .int()
-            .default(10)
-            .describe("Return the N most recent entries. 0 = all."),
-    },
-}, async ({ project, limit }) => {
-    const slug = await resolveProject(project);
-    let entries = listJournalFiles(slug);
-    if (limit > 0) {
-        entries = entries.slice(0, limit);
-    }
-    const result = entries.map((e) => {
-        const content = fs.readFileSync(path.join(e.dir, e.file), "utf-8");
-        return {
-            date: e.date,
-            title: extractTitle(content),
-            momentum: extractMomentum(content),
-        };
-    });
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    project: slug,
-                    entries: result,
-                }),
-            },
-        ],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: journal_projects
-// ---------------------------------------------------------------------------
-server.registerTool("journal_projects", {
-    title: "List Projects",
-    description: "List all projects tracked by agent-recall on this machine.",
-    inputSchema: {},
-}, async () => {
-    const projects = listAllProjects();
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    projects: projects.map((p) => ({
-                        slug: p.slug,
-                        last_entry: p.lastEntry,
-                        entry_count: p.entryCount,
-                    })),
-                    journal_root: JOURNAL_ROOT,
-                }),
-            },
-        ],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: journal_search
-// ---------------------------------------------------------------------------
-server.registerTool("journal_search", {
-    title: "Search Journals",
-    description: "Full-text search across all journal entries for a project.",
-    inputSchema: {
-        query: z.string().describe("Search term (plain text, case-insensitive)"),
-        project: z
-            .string()
-            .default("auto")
-            .describe("Project slug. Defaults to auto-detect."),
-        section: z
-            .string()
-            .optional()
-            .describe("Limit search to a specific section type."),
-    },
-}, async ({ query, project, section }) => {
-    const slug = await resolveProject(project);
-    const dirs = journalDirs(slug);
-    const queryLower = query.toLowerCase();
-    const results = [];
-    for (const dir of dirs) {
-        if (!fs.existsSync(dir))
-            continue;
-        const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
-        for (const file of files) {
-            const filePath = path.join(dir, file);
-            const content = fs.readFileSync(filePath, "utf-8");
-            const lines = content.split("\n");
-            let currentSection = "top";
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i];
-                // Track current section
-                if (line.startsWith("## ")) {
-                    currentSection = line
-                        .slice(3)
-                        .trim()
-                        .toLowerCase()
-                        .replace(/\s+/g, "_");
-                }
-                // Filter by section if specified
-                if (section && currentSection !== section.toLowerCase()) {
-                    continue;
-                }
-                if (line.toLowerCase().includes(queryLower)) {
-                    const dateMatch = file.match(/^(\d{4}-\d{2}-\d{2})/);
-                    const date = dateMatch ? dateMatch[1] : file;
-                    // Build excerpt: line with surrounding context
-                    const start = Math.max(0, line.toLowerCase().indexOf(queryLower) - 40);
-                    const end = Math.min(line.length, line.toLowerCase().indexOf(queryLower) + query.length + 40);
-                    let excerpt = line.slice(start, end).trim();
-                    if (start > 0)
-                        excerpt = "..." + excerpt;
-                    if (end < line.length)
-                        excerpt = excerpt + "...";
-                    results.push({
-                        date,
-                        section: currentSection,
-                        excerpt,
-                        line: i + 1,
-                    });
-                }
-            }
-        }
-    }
-    // Sort by date descending
-    results.sort((a, b) => b.date.localeCompare(a.date));
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({ results }),
-            },
-        ],
-    };
-});
-// ---------------------------------------------------------------------------
-// Resources
-// ---------------------------------------------------------------------------
-// Resource: project index
-server.registerResource("Journal Index", new ResourceTemplate("agent-recall://{project}/index", {
-    list: async () => {
-        const projects = listAllProjects();
-        return {
-            resources: projects.map((p) => ({
-                uri: `agent-recall://${p.slug}/index`,
-                name: `${p.slug} — Journal Index`,
-                mimeType: "text/markdown",
-            })),
-        };
-    },
-}), { description: "Journal index for a project", mimeType: "text/markdown" }, async (uri, { project }) => {
-    const slug = Array.isArray(project) ? project[0] : (project || "unknown");
-    const indexPath = path.join(journalDir(slug), "index.md");
-    let content = "";
-    if (fs.existsSync(indexPath)) {
-        content = fs.readFileSync(indexPath, "utf-8");
-    }
-    else {
-        content = `# ${slug} — No journal index found\n`;
-    }
-    return {
-        contents: [
-            {
-                uri: uri.href,
-                text: content,
-                mimeType: "text/markdown",
-            },
-        ],
-    };
-});
-// Resource: specific date entry
-server.registerResource("Journal Entry", new ResourceTemplate("agent-recall://{project}/{date}", {
-    list: async () => {
-        const projects = listAllProjects();
-        const resources = [];
-        for (const p of projects) {
-            const entries = listJournalFiles(p.slug).slice(0, 5);
-            for (const e of entries) {
-                resources.push({
-                    uri: `agent-recall://${p.slug}/${e.date}`,
-                    name: `${p.slug} — ${e.date}`,
-                    mimeType: "text/markdown",
-                });
-            }
-        }
-        return { resources };
-    },
-}), {
-    description: "A specific journal entry by date",
-    mimeType: "text/markdown",
-}, async (uri, { project, date }) => {
-    const slug = Array.isArray(project) ? project[0] : (project || "unknown");
-    const entryDate = Array.isArray(date) ? date[0] : (date || todayISO());
-    const content = readJournalFile(slug, entryDate);
-    return {
-        contents: [
-            {
-                uri: uri.href,
-                text: content || `# No entry for ${entryDate}\n`,
-                mimeType: "text/markdown",
-            },
-        ],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: alignment_check (Intelligent Distance measurement)
-// ---------------------------------------------------------------------------
-server.registerTool("alignment_check", {
-    title: "Alignment Check",
-    description: "Record what the agent understood, its confidence, and any human correction. Measures the Intelligent Distance gap.",
-    inputSchema: {
-        goal: z.string().describe("Agent's understanding of the goal"),
-        confidence: z.enum(["high", "medium", "low"]).describe("Agent's confidence"),
-        assumptions: z.array(z.string()).optional().describe("What agent assumed"),
-        unclear: z.string().optional().describe("What agent is unsure about"),
-        human_correction: z.string().optional().describe("Human's correction or 'confirmed'"),
-        delta: z.string().optional().describe("The gap, or 'none'"),
-        category: z.enum(["goal", "scope", "priority", "technical", "aesthetic"]).default("goal"),
-        project: z.string().default("auto"),
-    },
-}, async ({ goal, confidence, assumptions, unclear, human_correction, delta, category, project }) => {
-    const slug = await resolveProject(project);
-    const date = todayISO();
-    const dir = journalDir(slug);
-    ensureDir(dir);
-    const time = new Date().toISOString().slice(11, 19);
-    const assumeStr = assumptions?.length ? assumptions.map(a => `  - ${a}`).join("\n") : "  (none)";
-    let entry = `### 🎯 Alignment (${time})\n`;
-    entry += `**Goal**: ${goal}\n**Confidence**: ${confidence}\n**Category**: ${category}\n`;
-    entry += `**Assumptions**:\n${assumeStr}\n`;
-    if (unclear)
-        entry += `**Unclear**: ${unclear}\n`;
-    if (human_correction)
-        entry += `**Human**: ${human_correction}\n**Delta**: ${delta || "not specified"}\n`;
-    entry += "\n";
-    const logPath = path.join(dir, `${date}-alignment.md`);
-    if (!fs.existsSync(logPath)) {
-        fs.writeFileSync(logPath, `# ${date} — Alignment Records\n\n---\n\n${entry}`, "utf-8");
-    }
-    else {
-        fs.appendFileSync(logPath, entry, "utf-8");
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ success: true, date, confidence, delta: delta || "pending", file: logPath }) }],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: nudge (surface human inconsistency)
-// ---------------------------------------------------------------------------
-server.registerTool("nudge", {
-    title: "Nudge",
-    description: "Surface a contradiction between the human's current input and a prior statement/decision. Helps the human clarify their own thinking.",
-    inputSchema: {
-        past_statement: z.string().describe("What the human said/decided before (with date if known)"),
-        current_statement: z.string().describe("What the human is saying now"),
-        question: z.string().describe("The clarifying question to ask"),
-        category: z.enum(["goal", "scope", "priority", "technical", "aesthetic"]).default("goal"),
-        project: z.string().default("auto"),
-    },
-}, async ({ past_statement, current_statement, question, category, project }) => {
-    const slug = await resolveProject(project);
-    const date = todayISO();
-    const dir = journalDir(slug);
-    ensureDir(dir);
-    const time = new Date().toISOString().slice(11, 19);
-    let entry = `### 🔔 Nudge (${time})\n`;
-    entry += `**Past**: ${past_statement}\n`;
-    entry += `**Now**: ${current_statement}\n`;
-    entry += `**Question**: ${question}\n`;
-    entry += `**Category**: ${category}\n\n`;
-    // Append to alignment log (nudges and alignment checks live together)
-    const logPath = path.join(dir, `${date}-alignment.md`);
-    if (!fs.existsSync(logPath)) {
-        fs.writeFileSync(logPath, `# ${date} — Alignment Records\n\n---\n\n${entry}`, "utf-8");
-    }
-    else {
-        fs.appendFileSync(logPath, entry, "utf-8");
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ success: true, date, category, file: logPath }) }],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: context_synthesize (L3 semantic memory)
-// ---------------------------------------------------------------------------
-server.registerTool("context_synthesize", {
-    title: "Synthesize Context",
-    description: "Generate L3 semantic synthesis from recent journals. Extracts decisions, blockers, goal evolution, and detects contradictions across sessions.",
-    inputSchema: {
-        entries: z.number().int().default(5).describe("Number of recent entries to analyze"),
-        focus: z.enum(["full", "decisions", "blockers", "goals"]).default("full"),
-        project: z.string().default("auto"),
-    },
-}, async ({ entries: count, focus, project }) => {
-    const slug = await resolveProject(project);
-    const journalEntries = listJournalFiles(slug);
-    if (journalEntries.length === 0) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: `No entries for '${slug}'` }) }], isError: true };
-    }
-    const toRead = journalEntries.slice(0, count);
-    const data = [];
-    for (const entry of toRead) {
-        const content = fs.readFileSync(path.join(entry.dir, entry.file), "utf-8");
-        data.push({
-            date: entry.date,
-            brief: extractSection(content, "brief"),
-            decisions: extractSection(content, "decisions"),
-            blockers: extractSection(content, "blockers"),
-            next: extractSection(content, "next"),
-            observations: extractSection(content, "observations"),
-        });
-    }
-    let syn = `# L3 Synthesis — ${slug}\n`;
-    syn += `> ${toRead.length} entries: ${toRead[toRead.length - 1]?.date} → ${toRead[0]?.date}\n\n`;
-    // Goal evolution
-    if (focus === "full" || focus === "goals") {
-        syn += `## Goal Evolution\n\n`;
-        for (const e of data) {
-            if (e.brief)
-                syn += `**${e.date}**: ${e.brief.split("\n")[0]}\n`;
-        }
-        syn += "\n";
-    }
-    // Decisions with contradiction detection
-    if (focus === "full" || focus === "decisions") {
-        syn += `## Decisions\n\n`;
-        const allDecisions = [];
-        for (const e of data) {
-            if (e.decisions)
-                allDecisions.push(`**${e.date}**:\n${e.decisions}\n`);
-        }
-        syn += allDecisions.length > 0 ? allDecisions.join("\n") : "(none recorded)\n";
-        // Simple contradiction check: find topics mentioned in multiple entries with different content
-        if (allDecisions.length >= 2) {
-            syn += "\n### Potential Contradictions\n\n";
-            syn += "Review the decisions above. Flag if:\n";
-            syn += "- A decision from an earlier date was reversed without explanation\n";
-            syn += "- The same topic has conflicting approaches across dates\n";
-            syn += "- A goal stated in one entry differs from another\n\n";
-        }
-    }
-    // Current blockers
-    if (focus === "full" || focus === "blockers") {
-        syn += `## Active Blockers\n\n`;
-        const latest = data.find(e => e.blockers);
-        syn += latest ? `**${latest.date}**:\n${latest.blockers}\n\n` : "(none)\n\n";
-        // Check if old blockers are still present
-        const oldBlockers = data.filter(e => e.blockers && e !== latest);
-        if (oldBlockers.length > 0) {
-            syn += "### Recurring Blockers (appeared in older entries too)\n\n";
-            for (const ob of oldBlockers.slice(0, 2)) {
-                syn += `**${ob.date}**: ${ob.blockers?.split("\n")[0] || ""}\n`;
-            }
-            syn += "\n";
-        }
-    }
-    // Cross-session observations
-    if (focus === "full") {
-        const obs = data.filter(e => e.observations);
-        if (obs.length > 0) {
-            syn += `## Patterns from Agent Observations\n\n`;
-            for (const o of obs.slice(0, 3)) {
-                syn += `**${o.date}**: ${o.observations?.split("\n").slice(0, 2).join(" ") || ""}\n`;
-            }
-            syn += "\n";
-        }
-    }
-    // Alignment patterns (if alignment log exists for today)
-    const alignPath = path.join(journalDir(slug), `${todayISO()}-alignment.md`);
-    if (fs.existsSync(alignPath)) {
-        const alignContent = fs.readFileSync(alignPath, "utf-8");
-        const checks = (alignContent.match(/### 🎯/g) || []).length;
-        const nudges = (alignContent.match(/### 🔔/g) || []).length;
-        const low = (alignContent.match(/Confidence: low/g) || []).length;
-        if (checks > 0 || nudges > 0) {
-            syn += `## Today's Alignment\n\n`;
-            syn += `- Alignment checks: ${checks}\n- Nudges: ${nudges}\n- Low confidence: ${low}\n\n`;
-        }
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ project: slug, entries_analyzed: toRead.length, synthesis: syn }) }],
-    };
-});
-function stateFilePath(project, date) {
-    return path.join(journalDir(project), `${date}.state.json`);
-}
-function readState(project, date) {
-    const fp = stateFilePath(project, date);
-    if (!fs.existsSync(fp))
-        return null;
-    try {
-        return JSON.parse(fs.readFileSync(fp, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-server.registerTool("journal_state", {
-    title: "Read/Write Session State (JSON)",
-    description: "Layer 1: structured JSON session state. Faster than markdown for cold-start. " +
-        "Read mode: returns today's state as JSON. Write mode: merges new data into state. " +
-        "Use this for agent-to-agent handoffs — no prose parsing needed.",
-    inputSchema: {
-        action: z.enum(["read", "write"]).describe("'read' returns state, 'write' merges new data"),
-        data: z.string().optional().describe("JSON string to merge into state (write mode only)"),
-        date: z.string().default("latest").describe("ISO date or 'latest'"),
-        project: z.string().default("auto"),
-    },
-}, async ({ action, data, date, project }) => {
-    const slug = await resolveProject(project);
-    let targetDate = date;
-    if (targetDate === "latest") {
-        // Find most recent state file
-        const dir = journalDir(slug);
-        if (fs.existsSync(dir)) {
-            const files = fs.readdirSync(dir)
-                .filter(f => f.endsWith(".state.json"))
-                .sort()
-                .reverse();
-            targetDate = files.length > 0 ? files[0].replace(".state.json", "") : todayISO();
-        }
-        else {
-            targetDate = todayISO();
-        }
-    }
-    if (action === "read") {
-        const state = readState(slug, targetDate);
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify(state ?? { empty: true, date: targetDate, project: slug }),
-                }],
-        };
-    }
-    // Write: merge into existing state
-    const existing = readState(slug, todayISO()) ?? {
-        version: VERSION,
-        date: todayISO(),
-        project: slug,
-        timestamp: new Date().toISOString(),
-        completed: [],
-        failures: [],
-        state: {},
-        next_actions: [],
-        insights: [],
-        counts: {},
-    };
-    if (data) {
-        try {
-            const incoming = JSON.parse(data);
-            // Merge arrays by appending, objects by spreading
-            if (incoming.completed)
-                existing.completed.push(...incoming.completed);
-            if (incoming.failures)
-                existing.failures.push(...incoming.failures);
-            if (incoming.next_actions)
-                existing.next_actions = incoming.next_actions; // replace, not append
-            if (incoming.insights)
-                existing.insights.push(...incoming.insights);
-            if (incoming.state)
-                Object.assign(existing.state, incoming.state);
-            if (incoming.counts)
-                Object.assign(existing.counts, incoming.counts);
-            existing.timestamp = new Date().toISOString();
-        }
-        catch (e) {
-            return {
-                content: [{ type: "text", text: JSON.stringify({ error: `Invalid JSON: ${e}` }) }],
-                isError: true,
-            };
-        }
-    }
-    const fp = stateFilePath(slug, todayISO());
-    ensureDir(path.dirname(fp));
-    fs.writeFileSync(fp, JSON.stringify(existing, null, 2), "utf-8");
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({ success: true, date: todayISO(), entries: {
-                        completed: existing.completed.length,
-                        failures: existing.failures.length,
-                        insights: existing.insights.length,
-                    } }),
-            }],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: journal_cold_start — Cache-aware cold start (v3 architecture)
-// ---------------------------------------------------------------------------
-server.registerTool("journal_cold_start", {
-    title: "Cold Start Brief (Cache-Aware)",
-    description: "Returns a cache-aware cold-start package. HOT: today + yesterday (full). " +
-        "WARM: 2-7 days (summaries only). COLD: older (count only). " +
-        "Designed for minimal context consumption on session start.",
-    inputSchema: {
-        project: z.string().default("auto"),
-    },
-}, async ({ project }) => {
-    const slug = await resolveProject(project);
-    const entries = listJournalFiles(slug);
-    const today = todayISO();
-    const hot = [];
-    const warm = [];
-    let coldCount = 0;
-    for (const entry of entries) {
-        const ageMs = Date.now() - new Date(entry.date).getTime();
-        const ageDays = ageMs / (1000 * 60 * 60 * 24);
-        if (ageDays <= 1.5) {
-            // HOT: state JSON (fast) + brief from markdown (capped at 5KB to save context)
-            const state = readState(slug, entry.date);
-            const fullPath = path.join(entry.dir, entry.file);
-            const stats = fs.statSync(fullPath);
-            const content = stats.size > 5120
-                ? fs.readFileSync(fullPath, "utf-8").slice(0, 5120) + "\n...(truncated, use journal_read for full)"
-                : fs.readFileSync(fullPath, "utf-8");
-            hot.push({
-                date: entry.date,
-                state,
-                brief: extractSection(content, "brief"),
-            });
-        }
-        else if (ageDays <= 7) {
-            // WARM: brief only (first 2KB of file to extract brief section)
-            const fullPath = path.join(entry.dir, entry.file);
-            const content = fs.readFileSync(fullPath, "utf-8").slice(0, 2048);
-            warm.push({
-                date: entry.date,
-                brief: extractSection(content, "brief"),
-            });
-        }
-        else {
-            // COLD: just count
-            coldCount++;
-        }
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    project: slug,
-                    cache: {
-                        hot: { count: hot.length, entries: hot },
-                        warm: { count: warm.length, entries: warm },
-                        cold: { count: coldCount },
-                    },
-                    total_entries: entries.length,
-                    tip: "HOT entries have full state. WARM have briefs only. Use journal_read for COLD entries.",
-                }),
-            }],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: journal_archive — Move completed sessions to cold storage
-// ---------------------------------------------------------------------------
-server.registerTool("journal_archive", {
-    title: "Archive Old Entries",
-    description: "Move entries older than N days to cold archive. Keeps a one-line summary per archived entry. " +
-        "Use after a project milestone or when journal count gets too high.",
-    inputSchema: {
-        older_than_days: z.number().int().default(7).describe("Archive entries older than this many days"),
-        project: z.string().default("auto"),
-    },
-}, async ({ older_than_days, project }) => {
-    const slug = await resolveProject(project);
-    const entries = listJournalFiles(slug);
-    const dir = journalDir(slug);
-    const archiveDir = path.join(dir, "archive");
-    ensureDir(archiveDir);
-    let archived = 0;
-    const summaries = [];
-    for (const entry of entries) {
-        const ageMs = Date.now() - new Date(entry.date).getTime();
-        const ageDays = ageMs / (1000 * 60 * 60 * 24);
-        if (ageDays > older_than_days) {
-            const srcPath = path.join(entry.dir, entry.file);
-            const content = fs.readFileSync(srcPath, "utf-8");
-            const brief = extractSection(content, "brief");
-            const firstLine = brief?.split("\n").find(l => l.trim().length > 0) ?? "(no brief)";
-            // Move to archive (copy+delete for cross-device safety)
-            const destPath = path.join(archiveDir, entry.file);
-            fs.copyFileSync(srcPath, destPath);
-            fs.unlinkSync(srcPath);
-            // Also move state file if exists
-            const stateSrc = stateFilePath(slug, entry.date);
-            if (fs.existsSync(stateSrc)) {
-                const stateDest = path.join(archiveDir, `${entry.date}.state.json`);
-                fs.copyFileSync(stateSrc, stateDest);
-                fs.unlinkSync(stateSrc);
-            }
-            summaries.push(`${entry.date}: ${firstLine}`);
-            archived++;
-        }
-    }
-    // Write archive index
-    if (summaries.length > 0) {
-        const indexPath = path.join(archiveDir, "index.md");
-        const existing = fs.existsSync(indexPath) ? fs.readFileSync(indexPath, "utf-8") : "# Archive\n\n";
-        fs.writeFileSync(indexPath, existing + summaries.join("\n") + "\n", "utf-8");
-    }
-    // Update main index
-    updateIndex(slug);
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    archived,
-                    summaries,
-                    archive_dir: archiveDir,
-                }),
-            }],
-    };
-});
+// Register all tools
+// ---------------------------------------------------------------------------
+registerJournalRead(server);
+registerJournalWrite(server);
+registerJournalCapture(server);
+registerJournalList(server);
+registerJournalProjects(server);
+registerJournalSearch(server);
+registerJournalState(server);
+registerJournalColdStart(server);
+registerJournalArchive(server);
+registerAlignmentCheck(server);
+registerNudge(server);
+registerContextSynthesize(server);
+registerKnowledgeWrite(server);
+registerKnowledgeRead(server);
+registerPalaceRead(server);
+registerPalaceWrite(server);
+registerPalaceWalk(server);
+registerPalaceLint(server);
+registerPalaceSearch(server);
+registerAwarenessUpdate(server);
+registerRecallInsight(server);
+// Register resources
+registerJournalResources(server);
 // ---------------------------------------------------------------------------
 // Start
 // ---------------------------------------------------------------------------