oh-my-adhd 0.2.0

package/dist/mcp/lib/search.js

@@ -0,0 +1,99 @@
+import MiniSearch from "minisearch";
+// Korean-aware tokenizer: whitespace split + Korean bigrams for partial matching
+function tokenize(text) {
+    const normalized = text.normalize("NFC").toLowerCase();
+    const words = normalized
+        .replace(/[^가-힣a-zA-Z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 0);
+    const tokens = [];
+    for (const word of words) {
+        tokens.push(word);
+        // Korean bigrams: "운동했다" → ["운동", "동했", "했다"] — partial stem matching
+        if (/[가-힣]/.test(word) && word.length >= 2) {
+            for (let i = 0; i < word.length - 1; i++) {
+                tokens.push(word.slice(i, i + 2));
+            }
+        }
+    }
+    // Do NOT dedup — preserving duplicates keeps TF signal intact for BM25
+    return tokens;
+}
+// Parse `_aliases: ADHD, 주의력결핍_` from page content
+export function extractAliases(content) {
+    const match = content.match(/_aliases:\s*([^_\n]+)_/i);
+    return match ? match[1] : "";
+}
+// Cache keyed by slug:updatedAt:aliasHash — invalidates on alias edits
+function cacheKey(pages) {
+    return pages
+        .map((p) => `${p.slug}:${p.updatedAt}:${extractAliases(p.content).length}`)
+        .join("|");
+}
+let _indexCache = null;
+export function buildSearchIndex(pages) {
+    const key = cacheKey(pages);
+    if (_indexCache && _indexCache.key === key)
+        return _indexCache.index;
+    const index = new MiniSearch({
+        fields: ["title", "aliases", "content"],
+        storeFields: ["slug", "title"],
+        tokenize,
+        searchOptions: {
+            boost: { title: 3, aliases: 2, content: 1 },
+            // Only prefix-match tokens of 3+ chars — prevents bigram over-matching
+            prefix: (term) => term.length >= 3,
+            // Fuzzy only on longer tokens — 2-char bigrams need exact match
+            fuzzy: (term) => (term.length > 4 ? 0.15 : 0),
+        },
+    });
+    index.addAll(pages.map((p) => ({
+        id: p.slug,
+        slug: p.slug,
+        title: p.title,
+        aliases: extractAliases(p.content),
+        content: p.content,
+    })));
+    _indexCache = { key, index };
+    return index;
+}
+export function searchInDocs(docs, query) {
+    if (!query.trim() || docs.length === 0)
+        return [];
+    const ms = new MiniSearch({
+        fields: ["title", "content"],
+        storeFields: ["id"],
+        tokenize: (text) => {
+            const words = text.split(/\s+/).filter(Boolean);
+            const bigrams = [];
+            for (const w of words) {
+                if (/[가-힣]/.test(w)) {
+                    for (let i = 0; i < w.length - 1; i++)
+                        bigrams.push(w.slice(i, i + 2));
+                }
+                else {
+                    bigrams.push(w.toLowerCase());
+                }
+            }
+            return bigrams.length > 0 ? bigrams : words;
+        },
+    });
+    ms.addAll(docs);
+    try {
+        return ms.search(query, { prefix: true, fuzzy: 0.15 }).map(r => ({ id: r.id, score: r.score }));
+    }
+    catch {
+        return [];
+    }
+}
+export function searchPages(pages, query, limit = 5) {
+    if (!query.trim() || pages.length === 0)
+        return [];
+    const index = buildSearchIndex(pages);
+    try {
+        return index.search(query).slice(0, limit).map((r) => r.slug);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/mcp/mcp/server.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+// stdout is the JSON-RPC channel — redirect any accidental console.log to stderr
+console.log = console.error;
+import { registerWikiDump } from "./tools/wiki-dump.js";
+import { registerWikiRecall } from "./tools/wiki-recall.js";
+import { registerWikiSetup } from "./tools/wiki-setup.js";
+import { registerWikiUnstick } from "./tools/wiki-unstick.js";
+import { registerWikiQuery } from "./tools/wiki-query.js";
+import { registerWikiPages } from "./tools/wiki-pages.js";
+import { registerWikiLink } from "./tools/wiki-link.js";
+import { registerWikiGraph } from "./tools/wiki-graph.js";
+import { registerWikiStructure } from "./tools/wiki-structure.js";
+import { registerWikiSave } from "./tools/wiki-save.js";
+import { registerWikiDelete } from "./tools/wiki-delete.js";
+const server = new McpServer({
+    name: "oh-my-adhd",
+    version: "0.2.0",
+});
+registerWikiDump(server);
+registerWikiRecall(server);
+registerWikiSetup(server);
+registerWikiUnstick(server);
+registerWikiQuery(server);
+registerWikiPages(server);
+registerWikiLink(server);
+registerWikiGraph(server);
+registerWikiStructure(server);
+registerWikiSave(server);
+registerWikiDelete(server);
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch(console.error);

package/dist/mcp/mcp/tools/wiki-delete.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { deleteThread, deletePage } from "../../lib/brain.js";
+export function registerWikiDelete(server) {
+    server.tool("wiki_delete", "스레드 또는 위키 페이지를 삭제한다. 실수로 저장한 민감한 내용 제거용.", {
+        target: z.enum(["thread", "page"]),
+        id: z.string().max(200).describe("스레드 ID (UUID) 또는 페이지 슬러그"),
+    }, async ({ target, id }) => {
+        try {
+            if (target === "thread") {
+                await deleteThread(id);
+                return { content: [{ type: "text", text: `스레드 삭제됨: ${id}` }] };
+            }
+            else {
+                await deletePage(id);
+                return { content: [{ type: "text", text: `페이지 삭제됨: ${id}` }] };
+            }
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `오류: ${e.message}` }], isError: true };
+        }
+    });
+}

package/dist/mcp/mcp/tools/wiki-dump.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { saveCapture, getThread, getThreads } from "../../lib/brain.js";
+import { findRelatedPages, upsertPageFromCapture } from "../../lib/linker.js";
+import { captureGitContext } from "../utils.js";
+export function registerWikiDump(server) {
+    server.tool("wiki_dump", "생각이나 메모를 세컨드 브레인에 저장한다. 같은 주제면 반드시 threadId를 재사용해서 이어 붙인다. 새 주제일 때만 threadId 없이 호출. 저장 후 반환된 threadId를 기억해 다음 캡처에 활용.\n\ncontent 형식 (구조화 권장):\n결정: [이번 대화에서 확정된 것]\n가설: [현재 시도 중인 방향]\n막힌것: [이미 시도해서 안 된 것 — 다음 세션 반복 방지]\n다음할것: [멈춘 시점의 다음 액션. 구체적으로]\n블로커: [해결 안 된 장애물]\n요약: [한 줄 컨텍스트]", {
+        content: z.string().max(64000).describe("저장할 내용"),
+        threadId: z.string().uuid().optional().describe("이어 붙일 스레드 ID (없으면 새 스레드)"),
+    }, async ({ content, threadId }) => {
+        try {
+            if (!content.trim()) {
+                return { content: [{ type: "text", text: "오류: 내용이 비어 있습니다. 저장할 내용을 입력해 주세요." }], isError: true };
+            }
+            const gitCtx = await captureGitContext();
+            const related = await findRelatedPages(content); // upsert 이전에 — self-link 방지
+            const result = await saveCapture(content + gitCtx, threadId);
+            if (result.skipped) {
+                return {
+                    content: [{ type: "text", text: `저장됨 ✓\n(중복 캡처 — 이미 저장된 내용)\nthread: ${result.threadId}` }],
+                };
+            }
+            const fullContent = await getThread(result.threadId);
+            if (fullContent)
+                await upsertPageFromCapture(result.title, fullContent).catch(() => { });
+            const sizeKB = Math.round((fullContent?.length ?? 0) / 1024);
+            const sizeWarn = sizeKB > 500 ? `\n⚠️ 스레드 크기 ${sizeKB}KB — 새 주제는 새 스레드(threadId 없이)로 분리하는 걸 권장` : "";
+            const respLines = ["저장됨 ✓"];
+            const nextMatch = content.match(/(?:^|\n)\s*다음할것\s*:\s*(.+)/im);
+            const blockerMatch = content.match(/(?:^|\n)\s*막힌것\s*:\s*(.+)/im);
+            if (nextMatch?.[1]?.trim())
+                respLines.push(`→ 다음 액션: ${nextMatch[1].trim().slice(0, 100)}`);
+            if (blockerMatch?.[1]?.trim())
+                respLines.push(`⛔ 막힌것 기록: ${blockerMatch[1].trim().slice(0, 100)}`);
+            respLines.push(`thread: ${result.threadId} (캡처 #${result.capture.id.slice(0, 8)})`);
+            if (related.length > 0)
+                respLines.push(`연결된 페이지: ${related.join(", ")}`);
+            if (sizeWarn)
+                respLines.push(sizeWarn.trim());
+            // Detect if content uses the structured schema
+            const FIELD_PATTERN = /(?:^|\n)\s*(?:결정|가설|막힌것|다음할것|블로커|요약)\s*:/i;
+            const isStructured = FIELD_PATTERN.test(content);
+            // Check if new content looks like a repeat of a known dead-end; also used for nag suppression
+            let allThreads = [];
+            if (!result.skipped) {
+                try {
+                    allThreads = await getThreads();
+                    const contentLower = content.toLowerCase().replace(/\s+/g, " ");
+                    for (const t of allThreads) {
+                        if (!t.is_open || t.id === result.threadId || !t.blocker)
+                            continue;
+                        const blockerWords = t.blocker.toLowerCase().replace(/\s+/g, " ").split(/\s+/).filter(w => w.length > 2);
+                        if (blockerWords.length === 0)
+                            continue;
+                        const matchCount = blockerWords.filter(w => contentLower.includes(w)).length;
+                        if (matchCount >= 3 || matchCount / blockerWords.length > 0.5) {
+                            respLines.unshift("");
+                            respLines.unshift(`   같은 길 다시 가는 거 맞아? 막혔으면 \`wiki_unstick\` 해볼래?`);
+                            respLines.unshift(`   → "${t.blocker.slice(0, 80)}" (${(t.title ?? "").slice(0, 20)}, thread \`${t.id.slice(0, 8)}...\`)`);
+                            respLines.unshift(`⚠️ 이거 전에 막혔던 거랑 비슷해:`);
+                            break;
+                        }
+                    }
+                }
+                catch { /* dead-end check is best-effort, never crash */ }
+            }
+            // Only nag if user has NEVER successfully used structured schema — avoids repeated noise
+            const hasEverStructured = allThreads.some(t => t.next_action || t.blocker);
+            if (!isStructured && !result.skipped && !hasEverStructured) {
+                respLines.push("");
+                respLines.push("💡 다음번엔 이 형식으로 쓰면 다음 세션에서 더 잘 복원돼:");
+                respLines.push("```");
+                respLines.push("다음할것: [지금 멈춘 시점의 다음 액션]");
+                respLines.push("막힌것: [이미 시도해서 안 된 것]");
+                respLines.push("요약: [한 줄 컨텍스트]");
+                respLines.push("```");
+            }
+            return {
+                content: [{ type: "text", text: respLines.join("\n") }],
+            };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `오류: ${e.message ?? String(e)}` }], isError: true };
+        }
+    });
+}

package/dist/mcp/mcp/tools/wiki-graph.js

@@ -0,0 +1,19 @@
+import { buildGraphData } from "../../lib/linker.js";
+export function registerWikiGraph(server) {
+    server.tool("wiki_graph", "세컨드 브레인의 노드/엣지 그래프 데이터를 반환한다.", {}, async () => {
+        try {
+            const data = await buildGraphData();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `nodes: ${data.nodes.length}, edges: ${data.edges.length}\n${JSON.stringify(data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `오류: ${e.message ?? String(e)}` }], isError: true };
+        }
+    });
+}

package/dist/mcp/mcp/tools/wiki-link.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { findRelatedPages, upsertPageFromCapture } from "../../lib/linker.js";
+export function registerWikiLink(server) {
+    server.tool("wiki_link", "내용에서 관련 위키 페이지를 찾고, 필요하면 새 페이지를 생성한다.", {
+        content: z.string().max(64000).describe("분석할 내용"),
+        createPage: z.boolean().optional().describe("위키 페이지로 저장할지 여부"),
+        title: z.string().max(200).optional().describe("페이지 제목 (createPage가 true일 때 필요)"),
+    }, async ({ content, createPage, title }) => {
+        if (createPage && !title) {
+            return { content: [{ type: "text", text: "오류: createPage가 true이면 title이 필요합니다" }], isError: true };
+        }
+        try {
+            const related = await findRelatedPages(content);
+            if (createPage && title) {
+                await upsertPageFromCapture(title, content).catch(() => { });
+            }
+            const lines = [];
+            if (related.length > 0) {
+                lines.push(`관련 페이지: ${related.map((s) => `[[${s}]]`).join(", ")}`);
+            }
+            else {
+                lines.push("관련 페이지 없음");
+            }
+            if (createPage && title) {
+                lines.push(`페이지 생성됨: [[${title}]]`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `오류: ${e.message ?? String(e)}` }], isError: true };
+        }
+    });
+}

package/dist/mcp/mcp/tools/wiki-pages.js

@@ -0,0 +1,20 @@
+import { getPages } from "../../lib/brain.js";
+export function registerWikiPages(server) {
+    server.tool("wiki_pages", "생성된 위키 페이지 목록을 반환한다.", {}, async () => {
+        try {
+            const pages = await getPages();
+            const list = pages.map((p) => `[[${p.title}]] — ${p.updatedAt.slice(0, 10)}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: list.length > 0 ? list.join("\n") : "페이지 없음",
+                    },
+                ],
+            };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `오류: ${e.message ?? String(e)}` }], isError: true };
+        }
+    });
+}

package/dist/mcp/mcp/tools/wiki-query.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { getThreads, getPages, getThread } from "../../lib/brain.js";
+import { searchPages, searchInDocs } from "../../lib/search.js";
+export function registerWikiQuery(server) {
+    server.tool("wiki_query", "세컨드 브레인에서 키워드로 검색한다. '전에 이 문제 겪어본 적 있나?', '비슷한 결정 했던 게 기억나는데' 같은 상황에서 호출. 과거의 나를 찾는 도구.", {
+        query: z.string().max(1000).trim().describe("검색할 키워드"),
+    }, async ({ query }) => {
+        try {
+            if (!query.trim()) {
+                return { content: [{ type: "text", text: "검색어를 입력하세요. 예: wiki_query({ query: \"React\" })" }], isError: true };
+            }
+            const [allThreads, pages] = await Promise.all([getThreads(), getPages()]);
+            const lq = query.toLowerCase();
+            const results = [];
+            // BM25 page search
+            const slugs = searchPages(pages, query, 5);
+            for (const slug of slugs) {
+                const p = pages.find((x) => x.slug === slug);
+                if (!p)
+                    continue;
+                const snippet = p.content.split("\n").find((line) => line.toLowerCase().includes(lq))?.slice(0, 200) ??
+                    p.content.slice(0, 200);
+                results.push(`[PAGE] [[${p.title}]]\n${snippet}`);
+            }
+            // Thread search: BM25 on manifest title + last_action (fast, no file I/O per thread)
+            const threadDocs = allThreads.slice(0, 200).map(t => ({
+                id: t.id,
+                title: t.title,
+                content: [t.last_action, t.next_action, t.blocker].filter(Boolean).join(" "),
+            }));
+            const threadScores = searchInDocs(threadDocs, query);
+            const threadResults = threadScores
+                .slice(0, 10)
+                .map(r => allThreads.find(t => t.id === r.id))
+                .filter((t) => t !== undefined);
+            for (const t of threadResults.slice(0, 5)) {
+                const content = await getThread(t.id);
+                const titleMatch = content?.match(/^#\s+(.+)$/m);
+                const title = titleMatch?.[1] ?? t.id;
+                const blocks = content?.split(/\n---\n/) ?? [];
+                const matched = blocks.find((b) => b.toLowerCase().includes(lq));
+                const snippet = matched
+                    ?.trim()
+                    .replace(/^(?:_[^_\n]+_|\*\*[^*\n]+\*\*)\s*/m, "")
+                    .slice(0, 200) ??
+                    (t.last_action?.slice(0, 200) ?? "");
+                results.push(`[THREAD] ${title} (id: ${t.id})\n${snippet}`);
+            }
+            if (allThreads.length > 200) {
+                results.push(`\n(최근 200개 스레드만 검색됨 — 전체 ${allThreads.length}개 중 ${allThreads.length - 200}개 미검색)`);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: results.length > 0
+                            ? results.join("\n\n---\n\n")
+                            : `"${query}"에 해당하는 내용 없음${allThreads.length > 200 ? ` (최근 200개 스레드만 검색됨)` : ""}`,
+                    },
+                ],
+            };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `오류: ${e.message ?? String(e)}` }], isError: true };
+        }
+    });
+}

package/dist/mcp/mcp/tools/wiki-recall.js

@@ -0,0 +1,205 @@
+import { z } from "zod";
+import { getThreads, getThread, OPEN_SIGNAL, DONE_SIGNAL, extractFieldBrain } from "../../lib/brain.js";
+import { runConsolidationIfDue } from "../../lib/consolidate.js";
+import { git } from "../utils.js";
+export function registerWikiRecall(server) {
+    server.tool("wiki_recall", "새 대화가 시작되면 반드시 첫 번째로 호출. 미완료 스레드를 우선 표면화해 '어제 X 작업 중이었는데 이어서 할까요?' 형태로 컨텍스트를 복원한다. 마크다운 텍스트 반환.", {
+        limit: z.number().int().min(1).max(20).optional().default(5).describe("반환할 스레드 수"),
+    }, async ({ limit }) => {
+        try {
+            const threads = await getThreads();
+            runConsolidationIfDue(threads).catch(() => { }); // fire-and-forget, unhandled rejection 방지
+            const candidates = threads.slice(0, Math.max(limit * 10, 50));
+            // Use manifest-cached signal fields where available; fall back to file reads only for uncached
+            const uncachedIdx = candidates
+                .map((t, i) => (t.is_open === undefined ? i : -1))
+                .filter((i) => i >= 0);
+            const fileContents = new Map();
+            if (uncachedIdx.length > 0) {
+                const reads = await Promise.all(uncachedIdx.map((i) => getThread(candidates[i].id)));
+                uncachedIdx.forEach((candIdx, readIdx) => {
+                    const c = reads[readIdx];
+                    if (c)
+                        fileContents.set(candidates[candIdx].id, c);
+                });
+            }
+            const enriched = candidates
+                .map((t) => {
+                let is_open;
+                let last_action;
+                let capture_count;
+                let next_action;
+                let blocker;
+                if (t.is_open !== undefined && t.last_action !== undefined && t.capture_count !== undefined) {
+                    // Fast path: use manifest cache
+                    is_open = t.is_open;
+                    last_action = t.last_action;
+                    capture_count = t.capture_count;
+                    // Use stored next_action/blocker from manifest if available
+                    next_action = t.next_action ?? "";
+                    blocker = t.blocker ?? "";
+                    const is_done = t.is_done !== undefined ? t.is_done : (DONE_SIGNAL.test(last_action) && !is_open);
+                    const gapHours = isNaN(new Date(t.updatedAt).getTime())
+                        ? null
+                        : Math.round((Date.now() - new Date(t.updatedAt).getTime()) / 3600000);
+                    return {
+                        threadId: t.id,
+                        title: t.title,
+                        status: (is_done ? "done" : (gapHours === null || gapHours > 48) ? "stale" : "active"),
+                        gap_hours: gapHours,
+                        capture_count,
+                        last_action,
+                        is_open,
+                        next_action,
+                        blocker,
+                    };
+                }
+                // Slow path: file read fallback (legacy manifest entries)
+                const content = fileContents.get(t.id);
+                if (!content)
+                    return null;
+                const titleMatch = content.match(/^#\s+(.+)$/m);
+                const title = (titleMatch?.[1] ?? t.id).trim();
+                const captures = content.split(/\n---\n/).slice(1).filter((p) => p.trim());
+                const lastCapture = captures.at(-1) ?? "";
+                const fullText = lastCapture.replace(/^(?:_[^_\n]+_|\*\*[^*\n]+\*\*)\s*/m, "").trim();
+                is_open = OPEN_SIGNAL.test(fullText);
+                const isDone = DONE_SIGNAL.test(fullText) && !is_open;
+                last_action = fullText.replace(/\n+/g, " ").slice(0, 160);
+                next_action = extractFieldBrain(fullText, "다음할것").slice(0, 120);
+                blocker = extractFieldBrain(fullText, "막힌것").slice(0, 120);
+                capture_count = captures.length;
+                const gapHours = isNaN(new Date(t.updatedAt).getTime())
+                    ? null
+                    : Math.round((Date.now() - new Date(t.updatedAt).getTime()) / 3600000);
+                return {
+                    threadId: t.id,
+                    title,
+                    status: (isDone ? "done" : (gapHours === null || gapHours > 48) ? "stale" : "active"),
+                    gap_hours: gapHours,
+                    capture_count,
+                    last_action,
+                    is_open,
+                    next_action,
+                    blocker,
+                };
+            })
+                .filter((x) => x !== null)
+                .filter((x) => x.capture_count > 0);
+            // 순차 게이트: 중복 없이 정렬 (Set으로 추적)
+            const seen = new Set();
+            const addUniq = (entries) => entries.filter((t) => { if (seen.has(t.threadId))
+                return false; seen.add(t.threadId); return true; });
+            // open이 stale보다 중요 — 잊고 있던 미완료 태스크가 최우선
+            const sorted = [
+                ...addUniq(enriched.filter((t) => t.is_open && t.status === "active")),
+                ...addUniq(enriched.filter((t) => t.is_open && t.status === "stale")),
+                ...addUniq(enriched.filter((t) => !t.is_open && t.status === "active")),
+                ...addUniq(enriched.filter((t) => !t.is_open && t.status === "stale")),
+                ...addUniq(enriched.filter((t) => t.status === "done")),
+            ].slice(0, limit);
+            // 콜드 스타트: 스레드 없으면 git 히스토리에서 컨텍스트 시드
+            if (sorted.length === 0) {
+                try {
+                    const [log, status, branch] = await Promise.all([
+                        git("log", "--oneline", "-8", "--format=%h %s (%ar)"),
+                        git("status", "--short"),
+                        git("branch", "--show-current"),
+                    ]);
+                    const gitContext = [
+                        branch ? `브랜치: ${branch}` : "",
+                        log ? `최근 커밋:\n${log}` : "",
+                        status ? `미완성 파일:\n${status}` : "",
+                    ].filter(Boolean).join("\n\n");
+                    if (gitContext) {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `## Second Brain 복원\n저장된 스레드 없음. Git 히스토리에서 컨텍스트를 가져왔어.\n\n${gitContext}\n\n---\nwiki_setup으로 지금 작업을 등록하거나, wiki_dump로 바로 던져봐.`,
+                                }],
+                        };
+                    }
+                }
+                catch {
+                    // git 없는 환경
+                }
+            }
+            if (sorted.length === 0) {
+                const hint = threads.length === 0
+                    ? "저장된 스레드 없음. wiki_setup이나 wiki_dump로 첫 생각을 던져봐."
+                    : "최근 활동 없음. 모든 스레드가 완료되었거나 오래됨.";
+                return { content: [{ type: "text", text: hint }] };
+            }
+            const statusIcon = (t) => t.status === "done" ? "✅" : t.is_open ? "🔴" : t.status === "active" ? "🟡" : "⬜";
+            const gapLabel = (h) => h === null ? "" : h < 1 ? "방금 전" : h < 18 ? `${h}시간 전` : h < 36 ? "어제" : `${Math.floor(h / 24)}일 전`;
+            const lines = [];
+            // Lead entry — the most important thread, formatted as a direct question
+            const top = sorted[0];
+            const others = sorted.slice(1);
+            // Lead section header
+            if (top.is_open) {
+                lines.push("## 어제 멈춘 곳\n");
+            }
+            else {
+                lines.push("## Second Brain 복원\n");
+            }
+            // Top thread — blockquote style for visual prominence
+            const topGap = gapLabel(top.gap_hours);
+            lines.push(`> ${statusIcon(top)} **${top.title}**${topGap ? ` — ${topGap}` : ""}`);
+            // Show 다음할것 if available, otherwise last_action
+            const topNext = top.next_action || (top.last_action ? top.last_action.replace(/^(?:결정|가설|막힌것|다음할것|블로커|요약)\s*:\s*/i, "").slice(0, 100) : "");
+            if (topNext)
+                lines.push(`> → 다음: ${topNext}`);
+            // Show 막힌것 prominently if present
+            if (top.blocker)
+                lines.push(`> ⛔ 막힌것: ${top.blocker}`);
+            // Call to action
+            if (top.is_open) {
+                lines.push(`>`);
+                lines.push(`> 이어서 갈까? (thread: \`${top.threadId}\`)`);
+            }
+            else {
+                lines.push(`>`);
+                lines.push(`> thread: \`${top.threadId}\``);
+            }
+            // Stale-open threads the user has forgotten — flag them separately
+            const forgottenThreads = others.filter(t => t.is_open && t.status === "stale");
+            const activeOthers = others.filter(t => !(t.is_open && t.status === "stale"));
+            if (forgottenThreads.length > 0) {
+                lines.push("\n---");
+                lines.push("## 📌 잊고 있던 거 (열려있는데 오랫동안 못 봄)");
+                for (const t of forgottenThreads) {
+                    const gap = gapLabel(t.gap_hours);
+                    const preview = t.next_action || t.last_action?.replace(/^(?:결정|가설|막힌것|다음할것|블로커|요약)\s*:\s*/i, "").slice(0, 80) || "";
+                    const blockerHint = t.blocker ? ` ⛔ ${t.blocker.slice(0, 60)}` : "";
+                    lines.push(`🔴 **${t.title}**${gap ? ` (${gap})` : ""}${blockerHint}`);
+                    if (preview)
+                        lines.push(`   → ${preview}`);
+                    lines.push(`   thread: \`${t.threadId}\``);
+                }
+            }
+            if (activeOthers.length > 0) {
+                lines.push("\n---");
+                lines.push("다른 작업:");
+                for (const t of activeOthers) {
+                    const gap = gapLabel(t.gap_hours);
+                    const preview = t.next_action || t.last_action?.replace(/^(?:결정|가설|막힌것|다음할것|블로커|요약)\s*:\s*/i, "").slice(0, 80) || "";
+                    const blockerHint = t.blocker ? ` ⛔` : "";
+                    lines.push(`${statusIcon(t)} **${t.title}**${gap ? ` (${gap})` : ""}${blockerHint}${preview ? ` → ${preview}` : ""}`);
+                    lines.push(`   thread: \`${t.threadId}\``);
+                }
+            }
+            lines.push("\n---");
+            if (top.is_open) {
+                lines.push(`이어서 가려면: "ㅇㅇ" 또는 \`wiki_dump({ threadId: "${top.threadId}", content: "..." })\``);
+            }
+            else {
+                lines.push("이어붙이기: `wiki_dump({ threadId: \"...\", content: \"...\" })`");
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `오류: ${e.message ?? String(e)}` }], isError: true };
+        }
+    });
+}

package/dist/mcp/mcp/tools/wiki-save.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { savePage } from "../../lib/brain.js";
+export function registerWikiSave(server) {
+    server.tool("wiki_save", "구조화된 마크다운 내용을 위키 페이지로 저장한다.", {
+        slug: z.string().max(100).regex(/^[a-z0-9가-힣-]+$/).describe("저장할 페이지 슬러그"),
+        content: z.string().max(64000).describe("저장할 마크다운 내용 (# 제목\\n\\n## 섹션...)"),
+    }, async ({ slug, content }) => {
+        const normalSlug = slug.toLowerCase();
+        if (!normalSlug || normalSlug.includes("/") || normalSlug.includes("\\") || normalSlug.includes("..") || normalSlug.includes("\0") || !/^[a-z0-9가-힣-]+$/.test(normalSlug)) {
+            return { content: [{ type: "text", text: `오류: 유효하지 않은 슬러그 "${slug}"` }], isError: true };
+        }
+        try {
+            await savePage(normalSlug, content);
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `오류: 저장 실패 — ${e.message}` }], isError: true };
+        }
+        return {
+            content: [{ type: "text", text: `저장됨: [[${normalSlug}]]` }],
+        };
+    });
+}

package/dist/mcp/mcp/tools/wiki-setup.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { saveCapture, getThread } from "../../lib/brain.js";
+import { upsertPageFromCapture } from "../../lib/linker.js";
+export function registerWikiSetup(server) {
+    server.tool("wiki_setup", "선택적 뇌 스냅샷. 지금 작업 중인 것들을 입력하면 첫 스레드를 생성해 wiki_recall이 즉시 의미있는 내용을 반환한다. 설치 직후 또는 컨텍스트를 새로 심고 싶을 때 호출.", {
+        tasks: z.array(z.string().max(500)).min(1).max(5).describe("지금 하고 있는 것들 (1-5개)"),
+    }, async ({ tasks }) => {
+        try {
+            const content = `현재 작업 스냅샷:\n${tasks.map((t, i) => `${i + 1}. ${t}`).join("\n")}`;
+            const result = await saveCapture(content);
+            const fullContent = await getThread(result.threadId);
+            if (fullContent)
+                await upsertPageFromCapture(result.title, fullContent).catch(() => { });
+            return {
+                content: [{
+                        type: "text",
+                        text: `뇌 스냅샷 저장됨 ✓\nthread: ${result.threadId}\n\n이제 wiki_recall을 호출하면 이 컨텍스트가 복원돼.`,
+                    }],
+            };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `오류: ${e.message ?? String(e)}` }], isError: true };
+        }
+    });
+}