oh-my-adhd 0.2.0

package/dist/mcp/lib/brain.js

@@ -0,0 +1,396 @@
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { randomUUID } from "crypto";
+export const BRAIN_DIR = process.env.OH_MY_ADHD_DIR ?? path.join(os.homedir(), ".oh-my-adhd");
+const THREADS_DIR = path.join(BRAIN_DIR, "threads");
+const PAGES_DIR = path.join(BRAIN_DIR, "pages");
+const MANIFEST_FILE = path.join(THREADS_DIR, ".manifest.json");
+const MANIFEST_LOCK_FILE = path.join(THREADS_DIR, ".manifest.lock");
+const MANIFEST_LOCK_TTL_MS = 10000;
+const LOG_FILE = path.join(BRAIN_DIR, "logs", "brain.log");
+const VERSION_FILE = path.join(BRAIN_DIR, "VERSION");
+export const SCHEMA_VERSION = 1;
+async function appendLog(level, msg) {
+    try {
+        const entry = `${new Date().toISOString()} [${level}] ${msg}\n`;
+        await fs.appendFile(LOG_FILE, entry, "utf-8");
+    }
+    catch { /* logging failures must never crash the server */ }
+}
+export async function ensureBrainDirs() {
+    await fs.mkdir(THREADS_DIR, { recursive: true });
+    await fs.mkdir(PAGES_DIR, { recursive: true });
+    await fs.mkdir(path.join(BRAIN_DIR, "logs"), { recursive: true });
+    try {
+        await fs.access(VERSION_FILE);
+    }
+    catch {
+        await fs.writeFile(VERSION_FILE, String(SCHEMA_VERSION), "utf-8");
+    }
+}
+async function acquireManifestFileLock() {
+    const content = JSON.stringify({ pid: process.pid, ts: Date.now() });
+    for (let attempt = 0; attempt < 500; attempt++) {
+        try {
+            const fh = await fs.open(MANIFEST_LOCK_FILE, "wx");
+            await fh.writeFile(content, "utf-8");
+            await fh.close();
+            return true;
+        }
+        catch (e) {
+            const code = e?.code;
+            if (code === "ENOENT") {
+                await fs.mkdir(path.dirname(MANIFEST_LOCK_FILE), { recursive: true }).catch(() => { });
+                continue;
+            }
+            if (code !== "EEXIST")
+                throw e;
+            // Lock exists — check if stale
+            try {
+                const raw = await fs.readFile(MANIFEST_LOCK_FILE, "utf-8");
+                const { ts } = JSON.parse(raw);
+                if (Date.now() - ts > MANIFEST_LOCK_TTL_MS) {
+                    await fs.unlink(MANIFEST_LOCK_FILE).catch(() => { });
+                    continue; // retry immediately
+                }
+            }
+            catch {
+                // Lock file disappeared or is unreadable — retry
+                continue;
+            }
+            await new Promise((r) => setTimeout(r, 25));
+        }
+    }
+    return false; // timed out
+}
+async function releaseManifestFileLock() {
+    await fs.unlink(MANIFEST_LOCK_FILE).catch(() => { });
+}
+// Two-tier lock: in-process promise chain (fast) + cross-process file lock (safe)
+let manifestLock = Promise.resolve();
+function withManifestLock(fn) {
+    const run = async () => {
+        const acquired = await acquireManifestFileLock();
+        if (!acquired) {
+            await appendLog("WARN", "withManifestLock: cross-process lock timeout, proceeding with in-process lock only");
+            // Proceed with in-process serialization only — better than losing the capture
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            if (acquired)
+                await releaseManifestFileLock();
+        }
+    };
+    const result = manifestLock.then(run, run);
+    manifestLock = result.then(() => undefined, () => undefined);
+    return result;
+}
+export function withBrainLock(fn) {
+    return withManifestLock(fn);
+}
+async function readManifest() {
+    try {
+        const raw = await fs.readFile(MANIFEST_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        if (e?.code !== "ENOENT") {
+            process.stderr.write(`[oh-my-adhd] manifest parse error — rebuilding: ${e}\n`);
+            try {
+                await fs.copyFile(MANIFEST_FILE, `${MANIFEST_FILE}.corrupt.${Date.now()}`);
+            }
+            catch { /* ignore backup failure */ }
+        }
+        return [];
+    }
+}
+async function writeManifest(threads) {
+    const tmp = path.join(THREADS_DIR, `.tmp-manifest-${randomUUID()}`);
+    await fs.writeFile(tmp, JSON.stringify(threads, null, 2), "utf-8");
+    await fs.rename(tmp, MANIFEST_FILE);
+}
+export function extractFieldBrain(text, field) {
+    const lines = text.split("\n");
+    const fieldRe = new RegExp(`^\\s*${field}\\s*:`, "i");
+    const delimRe = /^\s*(?:결정|가설|막힌것|다음할것|블로커|요약|상태)\s*:/i;
+    let capturing = false;
+    const parts = [];
+    for (const line of lines) {
+        if (!capturing) {
+            if (fieldRe.test(line)) {
+                capturing = true;
+                const val = line.replace(fieldRe, "").trim();
+                if (val)
+                    parts.push(val);
+            }
+        }
+        else {
+            if (delimRe.test(line) || /^\[git:/i.test(line.trim()))
+                break;
+            const trimmed = line.trim();
+            if (trimmed)
+                parts.push(trimmed);
+            else if (parts.length > 0)
+                break;
+        }
+    }
+    return parts.join(" ").trim();
+}
+// Strip git suffix appended by wiki_dump before title/dedup operations
+export function stripGitSuffix(content) {
+    return content.trimEnd().replace(/\n\[git:.*\]$/, "").trimEnd();
+}
+export const OPEN_SIGNAL = /(?:^|\n)\s*(?:다음할것|블로커|막힌것|가설|next|blocked|todo|wip)\s*:\s*\S/i;
+export const DONE_SIGNAL = /(?:^|\n)\s*상태:\s*[^\n]*(완료|해결됨|배포됨|종료|done|shipped|closed)/i;
+export function extractTitle(content) {
+    const raw = stripGitSuffix(content);
+    const lines = raw.split("\n").map(l => l.trim()).filter(l => l.length > 0);
+    // 구조화 dump: 요약 필드를 제목으로 — "결정: ..." 같은 첫 줄보다 의미있음
+    const summary = lines.find(l => /^요약\s*:/i.test(l));
+    const pick = summary ?? lines[0] ?? "";
+    const clean = pick
+        .replace(/^#+\s*/, "")
+        .replace(/^(?:요약|결정|가설|막힌것|다음할것|블로커)\s*:\s*/i, "");
+    return clean.trim().slice(0, 40) || raw.trim().slice(0, 40);
+}
+export async function saveCapture(content, threadId) {
+    await ensureBrainDirs();
+    const captureId = randomUUID();
+    const timestamp = new Date().toISOString();
+    const tid = threadId ?? captureId;
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(tid)) {
+        throw new Error(`Invalid threadId: ${tid}`);
+    }
+    const threadFile = path.join(THREADS_DIR, `${tid}.md`);
+    const capture = { id: captureId, content, timestamp, threadId: tid };
+    // Thread read→write AND manifest update serialized together
+    // 같은 threadId로 동시 dump가 와도 append가 유실되지 않음
+    let title = "";
+    let skipped = false;
+    await withManifestLock(async () => {
+        let existingContent = "";
+        try {
+            existingContent = await fs.readFile(threadFile, "utf-8");
+        }
+        catch (e) {
+            if (e?.code !== "ENOENT")
+                throw e;
+        }
+        title = existingContent
+            ? (existingContent.match(/^# (.+)/m)?.[1]?.trim() || extractTitle(content))
+            : extractTitle(content);
+        if (existingContent) {
+            const blocks = existingContent.split(/\n---\n/);
+            const lastBlock = blocks[blocks.length - 1] ?? "";
+            const lastText = stripGitSuffix(lastBlock.trim().replace(/^\*\*[^*\n]+\*\*\s*\n*/, "").trim());
+            if (stripGitSuffix(content.trim()) === lastText) {
+                skipped = true;
+                return;
+            }
+        }
+        const entry = `\n---\n**${timestamp}**\n\n${content}\n`;
+        const header = existingContent
+            ? existingContent
+            : `# ${title}\n\n_created: ${timestamp}_\n`;
+        const tmpThread = path.join(THREADS_DIR, `.tmp-${randomUUID()}`);
+        await fs.writeFile(tmpThread, header + entry, "utf-8");
+        await fs.rename(tmpThread, threadFile);
+        const manifest = await readManifest();
+        const idx = manifest.findIndex((m) => m.id === tid);
+        // Compute signal cache fields from new content
+        const stripped = stripGitSuffix(content).trim();
+        const is_open = OPEN_SIGNAL.test(stripped);
+        const is_done = DONE_SIGNAL.test(stripped) && !is_open;
+        const last_action = stripped.replace(/\n+/g, " ").slice(0, 160);
+        const next_action = extractFieldBrain(stripped, "다음할것").slice(0, 120);
+        const blocker = extractFieldBrain(stripped, "막힌것").slice(0, 120);
+        const existingCount = existingContent
+            ? existingContent.split(/\n---\n/).slice(1).filter((p) => p.trim()).length
+            : 0;
+        const capture_count = existingCount + 1;
+        const meta = { id: tid, title, updatedAt: timestamp, is_open, last_action, capture_count, is_done, next_action, blocker };
+        if (idx >= 0)
+            manifest[idx] = meta;
+        else
+            manifest.push(meta);
+        await writeManifest(manifest.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()));
+    });
+    return { capture, threadId: tid, title, skipped };
+}
+export async function getThreads() {
+    await ensureBrainDirs();
+    const manifest = await readManifest();
+    if (manifest.length > 0) {
+        return manifest.map((m) => ({ ...m, captures: [] }));
+    }
+    // Fallback: directory scan (first run or manifest missing)
+    const files = await fs.readdir(THREADS_DIR);
+    const mdFiles = files.filter((f) => f.endsWith(".md") && !f.startsWith(".") && !f.endsWith(".summary.md"));
+    const results = await Promise.allSettled(mdFiles.map(async (file) => {
+        const filePath = path.join(THREADS_DIR, file);
+        const [content, stat] = await Promise.all([
+            fs.readFile(filePath, "utf-8"),
+            fs.stat(filePath),
+        ]);
+        const tid = file.replace(".md", "");
+        const title = content.match(/^# (.+)/m)?.[1]?.trim() || tid;
+        const scanCaptures = content.split(/\n---\n/).slice(1).filter((p) => p.trim());
+        const lastCapture = scanCaptures.at(-1) ?? "";
+        const fullText = lastCapture.replace(/^(?:_[^_\n]+_|\*\*[^*\n]+\*\*)\s*/m, "").trim();
+        const is_open = OPEN_SIGNAL.test(fullText);
+        return {
+            id: tid,
+            title,
+            captures: [],
+            updatedAt: stat.mtime.toISOString(),
+            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: scanCaptures.length,
+            is_done: DONE_SIGNAL.test(fullText) && !OPEN_SIGNAL.test(fullText),
+        };
+    }));
+    results
+        .filter((r) => r.status === "rejected")
+        .forEach((r, i) => appendLog("WARN", `getThreads: failed to read ${mdFiles[i]}: ${r.reason}`));
+    const threads = results
+        .filter((r) => r.status === "fulfilled")
+        .map((r) => r.value);
+    const sorted = threads.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    // 락 안에서 재확인 — 동시 saveCapture가 이미 manifest를 썼을 경우 merge
+    await withManifestLock(async () => {
+        const current = await readManifest();
+        const currentIds = new Set(current.map(m => m.id));
+        const toAdd = sorted
+            .filter(t => !currentIds.has(t.id))
+            .map(({ id, title, updatedAt, is_open, last_action, next_action, blocker, capture_count, is_done }) => ({ id, title, updatedAt, is_open, last_action, next_action, blocker, capture_count, is_done }));
+        if (toAdd.length === 0)
+            return;
+        await writeManifest([...current, ...toAdd].sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()));
+    });
+    return sorted;
+}
+export async function getThread(threadId) {
+    if (!threadId || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(threadId))
+        return null;
+    try {
+        return await fs.readFile(path.join(THREADS_DIR, `${threadId}.md`), "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+export async function getPages() {
+    await ensureBrainDirs();
+    const files = await fs.readdir(PAGES_DIR);
+    const mdFiles = files.filter((f) => f.endsWith(".md") && !f.startsWith("."));
+    const results = await Promise.allSettled(mdFiles.map(async (file) => {
+        const filePath = path.join(PAGES_DIR, file);
+        const [content, stat] = await Promise.all([
+            fs.readFile(filePath, "utf-8"),
+            fs.stat(filePath),
+        ]);
+        const slug = file.replace(".md", "");
+        const titleMatch = content.match(/^# (.+)/m);
+        const title = titleMatch?.[1] ?? slug;
+        const linkMatches = [...content.matchAll(/\[\[([^\]]+)\]\]/g)];
+        const links = linkMatches.map((m) => m[1]);
+        return { slug, title, content, links, updatedAt: stat.mtime.toISOString() };
+    }));
+    results
+        .filter((r) => r.status === "rejected")
+        .forEach((r, i) => appendLog("WARN", `getPages: failed to read ${mdFiles[i]}: ${r.reason}`));
+    return results
+        .filter((r) => r.status === "fulfilled")
+        .map((r) => r.value);
+}
+export async function getPage(slug) {
+    const s = slug?.toLowerCase() ?? "";
+    if (!s || s.includes("/") || s.includes("\\") || s.includes("..") || s.includes("\0") || !/^[a-z0-9가-힣-]+$/.test(s))
+        return null;
+    try {
+        const filePath = path.join(PAGES_DIR, `${s}.md`);
+        const [content, stat] = await Promise.all([
+            fs.readFile(filePath, "utf-8"),
+            fs.stat(filePath),
+        ]);
+        const titleMatch = content.match(/^# (.+)/m);
+        const title = titleMatch?.[1] ?? slug;
+        const linkMatches = [...content.matchAll(/\[\[([^\]]+)\]\]/g)];
+        const links = linkMatches.map((m) => m[1]);
+        return { slug, title, content, links, updatedAt: stat.mtime.toISOString() };
+    }
+    catch {
+        return null;
+    }
+}
+export async function savePage(slug, content) {
+    const s = slug?.toLowerCase() ?? "";
+    if (!s || s.includes("/") || s.includes("\\") || s.includes("..") || s.includes("\0") || !/^[a-z0-9가-힣-]+$/.test(s) || !/[a-z0-9가-힣]/.test(s)) {
+        throw new Error(`Invalid slug: ${slug}`);
+    }
+    await ensureBrainDirs();
+    const pageFile = path.join(PAGES_DIR, `${s}.md`);
+    const tmpPage = path.join(PAGES_DIR, `.tmp-${randomUUID()}`);
+    await fs.writeFile(tmpPage, content, "utf-8");
+    await fs.rename(tmpPage, pageFile);
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TRASH_DIR = path.join(BRAIN_DIR, ".trash");
+export async function deleteThread(threadId) {
+    if (!UUID_RE.test(threadId)) {
+        throw new Error(`Invalid threadId format: ${threadId}`);
+    }
+    await ensureBrainDirs();
+    await fs.mkdir(TRASH_DIR, { recursive: true });
+    const threadFile = path.join(THREADS_DIR, `${threadId}.md`);
+    // Move to trash before deleting (backup)
+    const trashFile = path.join(TRASH_DIR, `${threadId}-${Date.now()}.md`);
+    try {
+        await fs.rename(threadFile, trashFile);
+    }
+    catch (e) {
+        if (e?.code !== "ENOENT")
+            throw e;
+        // File didn't exist — still remove from manifest
+    }
+    await withManifestLock(async () => {
+        const manifest = await readManifest();
+        const filtered = manifest.filter((m) => m.id !== threadId);
+        if (filtered.length !== manifest.length) {
+            await writeManifest(filtered);
+        }
+    });
+}
+export async function deletePage(slug) {
+    const s = slug?.toLowerCase() ?? "";
+    if (!s || s.includes("/") || s.includes("\\") || s.includes("..") || s.includes("\0") || !/^[a-z0-9가-힣-]+$/.test(s)) {
+        throw new Error(`Invalid slug: ${slug}`);
+    }
+    await ensureBrainDirs();
+    const pageFile = path.join(PAGES_DIR, `${s}.md`);
+    try {
+        await fs.unlink(pageFile);
+    }
+    catch (e) {
+        if (e?.code !== "ENOENT")
+            throw e;
+        throw new Error(`Page not found: ${slug}`);
+    }
+}
+// Exported for consolidate.ts to update manifest entries after trimming
+export async function updateManifestEntry(id, fields) {
+    await ensureBrainDirs();
+    await withManifestLock(async () => {
+        const manifest = await readManifest();
+        const idx = manifest.findIndex((m) => m.id === id);
+        if (idx >= 0) {
+            manifest[idx] = { ...manifest[idx], ...fields };
+            await writeManifest(manifest.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()));
+        }
+    });
+}

package/dist/mcp/lib/consolidate.js

@@ -0,0 +1,190 @@
+import fs from "fs/promises";
+import path from "path";
+import { randomUUID } from "crypto";
+import { BRAIN_DIR, updateManifestEntry, getThreads, withBrainLock, extractFieldBrain } from "./brain.js";
+const THREADS_DIR = path.join(BRAIN_DIR, "threads");
+const CONSOLIDATION_STATE = path.join(THREADS_DIR, ".consolidation.json");
+const LOCK_FILE = path.join(THREADS_DIR, ".consolidation.lock");
+const LOCK_TTL_MS = 10 * 60 * 1000; // 10 min — stale lock threshold
+async function acquireFileLock() {
+    try {
+        await fs.writeFile(LOCK_FILE, String(process.pid), { flag: "wx" });
+        return true;
+    }
+    catch (e) {
+        if (e?.code !== "EEXIST")
+            return false;
+        // Stale lock check
+        try {
+            const stat = await fs.stat(LOCK_FILE);
+            if (Date.now() - stat.mtimeMs > LOCK_TTL_MS) {
+                await fs.unlink(LOCK_FILE);
+                await fs.writeFile(LOCK_FILE, String(process.pid), { flag: "wx" });
+                return true;
+            }
+        }
+        catch { /* ignore */ }
+        return false;
+    }
+}
+async function releaseFileLock() {
+    try {
+        const content = await fs.readFile(LOCK_FILE, "utf-8");
+        if (content.trim() === String(process.pid)) {
+            await fs.unlink(LOCK_FILE);
+        }
+    }
+    catch { /* ignore — lock already gone or unreadable */ }
+}
+// Korean/English stopwords that add no meaning to keyword extraction
+const STOPWORDS = new Set([
+    "이", "의", "가", "을", "를", "은", "는", "에", "도", "로", "과", "와",
+    "이다", "있다", "없다", "하다", "된다", "한다", "그", "그리고", "그래서",
+    "the", "a", "an", "is", "are", "was", "were", "and", "or", "to", "of",
+    "in", "on", "at", "for", "with", "it", "this", "that",
+]);
+async function readState() {
+    try {
+        return JSON.parse(await fs.readFile(CONSOLIDATION_STATE, "utf-8"));
+    }
+    catch {
+        return { lastRun: new Date(0).toISOString(), archivedCount: 0 };
+    }
+}
+function extractKeywords(text) {
+    // Strip markdown header, timestamps, git context, separators before tokenizing
+    const cleaned = text
+        .replace(/^#[^\n]*/gm, "") // headings
+        .replace(/_[^_\n]+_/g, "") // _italic_
+        .replace(/\*\*[^*\n]+\*\*/g, "") // **bold** (timestamps)
+        .replace(/\[git:[^\]]*\]/g, "") // git context
+        .replace(/^---+$/gm, "") // separators
+        .replace(/\[consolidated:[^\]]*\]/g, "") // already-compressed marker
+        .replace(/\d{4}-\d{2}-\d{2}T[^\s]*/g, "") // ISO timestamps
+        .replace(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/gi, "") // UUIDs
+        .toLowerCase();
+    const freq = new Map();
+    cleaned
+        .replace(/[^\w가-힣\s]/g, " ")
+        .split(/\s+/)
+        .filter(w => w.length > 1 && !STOPWORDS.has(w))
+        .forEach(w => freq.set(w, (freq.get(w) ?? 0) + 1));
+    // Top-20 by frequency
+    return new Set([...freq.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 20)
+        .map(([w]) => w));
+}
+const STALE_DAYS = 30;
+async function consolidateThread(threadId, threadFile, cutoff) {
+    return withBrainLock(async () => {
+        let content;
+        try {
+            content = await fs.readFile(threadFile, "utf-8");
+        }
+        catch {
+            return false;
+        }
+        // Already consolidated — check for the marker at end of file
+        if (/\[consolidated:/i.test(content)) {
+            return false;
+        }
+        // Extract key structured fields from the last few captures for sidecar
+        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();
+        const fields = ["결정", "가설", "막힌것", "다음할것", "블로커", "요약"];
+        const extracted = fields
+            .map(f => {
+            const val = extractFieldBrain(fullText, f).slice(0, 200);
+            return val ? `${f}: ${val}` : "";
+        })
+            .filter(Boolean);
+        const ts = new Date().toISOString();
+        const marker = `\n\n[consolidated: ${ts}]\n`;
+        const tmpFile = path.join(path.dirname(threadFile), `.tmp-${randomUUID()}`);
+        await fs.writeFile(tmpFile, content + marker, "utf-8");
+        await fs.rename(tmpFile, threadFile);
+        const sidecarFile = threadFile.replace(/\.md$/, ".summary.md");
+        const titleMatch = content.match(/^#\s+(.+)$/m);
+        const title = titleMatch?.[1]?.trim() ?? threadId;
+        const sidecarContent = [
+            `# Summary: ${title}`,
+            `_consolidated: ${ts}_`,
+            `_captures: ${captures.length}_`,
+            ``,
+            extracted.length > 0 ? extracted.join("\n") : "(구조화된 필드 없음)",
+            ``,
+            `→ 원문: ${path.basename(threadFile)}`,
+        ].join("\n");
+        const tmpSidecar = path.join(path.dirname(sidecarFile), `.tmp-${randomUUID()}`);
+        await fs.writeFile(tmpSidecar, sidecarContent, "utf-8");
+        await fs.rename(tmpSidecar, sidecarFile);
+        return true;
+    });
+}
+// Stage A: non-destructively consolidate threads not accessed in 30+ days
+// 매번 최신 manifest를 읽어서 직전 wiki_dump가 updatedAt을 갱신했는지 재확인
+async function ageBasedTrim() {
+    const threads = await getThreads();
+    const cutoff = Date.now() - STALE_DAYS * 24 * 3600 * 1000;
+    const stale = threads.filter(t => new Date(t.updatedAt).getTime() < cutoff);
+    let trimmed = 0;
+    await Promise.allSettled(stale.map(async (t) => {
+        const threadFile = path.join(THREADS_DIR, `${t.id}.md`);
+        const consolidated = await consolidateThread(t.id, threadFile, cutoff);
+        if (consolidated) {
+            // Update manifest: mark as consolidated, preserve updatedAt
+            const originalMs = new Date(t.updatedAt).getTime();
+            await updateManifestEntry(t.id, {
+                updatedAt: new Date(Math.min(originalMs, cutoff - 1)).toISOString(),
+            });
+            trimmed++;
+        }
+    }));
+    return trimmed;
+}
+// 동시 consolidation 방지 — parallel wiki_recall 호출이 두 번 트리거하는 것 방지
+// flag은 첫 await 이전에 set — TOCTOU 방지
+let _consolidating = false;
+export async function runConsolidationIfDue(threads) {
+    if (_consolidating)
+        return;
+    _consolidating = true;
+    let state;
+    try {
+        state = await readState();
+        const hoursSince = (Date.now() - new Date(state.lastRun).getTime()) / 3600000;
+        if (hoursSince < 24 || threads.length < 50) {
+            _consolidating = false;
+            return;
+        }
+    }
+    catch {
+        _consolidating = false;
+        return;
+    }
+    setImmediate(async () => {
+        const locked = await acquireFileLock();
+        if (!locked) {
+            _consolidating = false;
+            return;
+        }
+        try {
+            const trimmed = await ageBasedTrim();
+            const tmp = path.join(THREADS_DIR, `.tmp-consolidation-${randomUUID()}`);
+            await fs.writeFile(tmp, JSON.stringify({
+                lastRun: new Date().toISOString(),
+                archivedCount: state.archivedCount + trimmed,
+            }, null, 2));
+            await fs.rename(tmp, CONSOLIDATION_STATE);
+        }
+        catch (e) {
+            process.stderr.write(`[oh-my-adhd consolidation error] ${e}\n`);
+        }
+        finally {
+            await releaseFileLock();
+            _consolidating = false;
+        }
+    });
+}

package/dist/mcp/lib/linker.js

@@ -0,0 +1,98 @@
+import { getPages, savePage, getThreads, getThread } from "./brain.js";
+import { buildSearchIndex, searchPages } from "./search.js";
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// 기존 페이지와 키워드 매칭으로 자동 링크 생성
+export async function autoLinkContent(content) {
+    const pages = await getPages();
+    // 긴 제목 먼저 매칭 — "Next" 페이지가 "Next.js 라우팅" 내부를 오염시키는 것 방지
+    const sortedPages = [...pages].sort((a, b) => b.title.length - a.title.length);
+    // Protect fenced code blocks and inline code from link injection
+    const placeholders = [];
+    let linked = content.replace(/```[\s\S]*?```|`[^`\n]+`/g, (m) => {
+        const ph = `\x00C${placeholders.length}\x00`;
+        placeholders.push(m);
+        return ph;
+    });
+    for (const page of sortedPages) {
+        const title = page.title;
+        // Case-insensitive check to prevent double-wrapping [[[[title]]]]
+        if (linked.toLowerCase().includes(`[[${title.toLowerCase()}]]`))
+            continue;
+        const boundary = "(?<![\\p{L}\\p{N}])";
+        const regex = new RegExp(`${boundary}${escapeRegex(title)}(?![\\p{L}\\p{N}])`, "giu");
+        linked = linked.replace(regex, `[[${title}]]`);
+    }
+    // Restore protected code segments
+    return linked.replace(/\x00C(\d+)\x00/g, (_, i) => placeholders[parseInt(i, 10)]);
+}
+// BM25 기반 관련 페이지 탐색 — 첫 의미있는 줄만 쿼리로 사용 (full content는 노이즈)
+export async function findRelatedPages(content) {
+    const pages = await getPages();
+    if (pages.length === 0)
+        return [];
+    const queryHint = content
+        .split("\n")
+        .find(l => l.trim().length > 3 && !l.startsWith("[") && !l.startsWith("#") && !l.startsWith("_"))
+        ?.slice(0, 120) ?? content.slice(0, 120);
+    return searchPages(pages, queryHint, 5);
+}
+// 캡처에서 위키 페이지 자동 생성/업데이트
+export async function upsertPageFromCapture(title, content) {
+    const slug = title
+        .toLowerCase()
+        .replace(/[^가-힣a-zA-Z0-9]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+    if (!slug)
+        return; // title이 전부 특수문자면 slug가 비어 있음 — 저장 불가
+    const capturesOnly = content.includes("\n---\n")
+        ? content.slice(content.indexOf("\n---\n"))
+        : content;
+    const linkedContent = await autoLinkContent(capturesOnly);
+    const pageContent = `# ${title}\n\n_updated: ${new Date().toISOString()}_\n${linkedContent}\n`;
+    await savePage(slug, pageContent);
+}
+// BM25 기반 그래프 엣지 생성
+export async function buildGraphData() {
+    const MAX_NODES = 200;
+    const [threads, pages] = await Promise.all([getThreads(), getPages()]);
+    const nodes = [];
+    const edges = [];
+    const edgeSet = new Set();
+    const addEdge = (source, target) => {
+        const key = `${source}→${target}`;
+        if (!edgeSet.has(key) && source !== target) {
+            edgeSet.add(key);
+            edges.push({ source, target });
+        }
+    };
+    const index = buildSearchIndex(pages);
+    const pageSlugSet = new Set(pages.map((p) => p.slug));
+    const threadContents = await Promise.all(threads.slice(0, MAX_NODES).map((t) => getThread(t.id)));
+    for (let i = 0; i < Math.min(threads.length, MAX_NODES); i++) {
+        const t = threads[i];
+        const content = threadContents[i];
+        nodes.push({ id: `thread-${t.id}`, label: t.title, type: "thread" });
+        if (!content)
+            continue;
+        // Use only meaningful body content, not frontmatter/timestamps
+        const body = content.split(/\n---\n/).slice(1).join(" ").slice(0, 300);
+        const related = index.search(body).slice(0, 3);
+        for (const r of related) {
+            if (pageSlugSet.has(r.slug)) {
+                addEdge(`thread-${t.id}`, `page-${r.slug}`);
+            }
+        }
+    }
+    for (const p of pages.slice(0, MAX_NODES)) {
+        nodes.push({ id: `page-${p.slug}`, label: p.title, type: "page" });
+        for (const link of p.links) {
+            const targetSlug = pages.find((pg) => pg.title.toLowerCase() === link.toLowerCase())?.slug;
+            if (targetSlug)
+                addEdge(`page-${p.slug}`, `page-${targetSlug}`);
+        }
+    }
+    return { nodes, edges };
+}