@nogataka/claw-memory 0.1.0

package/dist/core/vector-memory.js

@@ -0,0 +1,203 @@
+// src/core/vector-memory.ts
+//
+// Vector store (sqlite-vec) + keyword index (FTS5). Vectors and readable
+// metadata are split across vec_chunks (vec0) and conversation_chunks.
+// Chunks carry optional structured metadata (obs_type / concepts / files) and a
+// deleted_at tombstone; all reads exclude tombstoned rows.
+import { randomUUID } from "node:crypto";
+import { sqlite } from "./db.js";
+function jsonArr(v) {
+    return v && v.length ? JSON.stringify(v) : null;
+}
+function parseArr(v) {
+    if (typeof v !== "string" || !v)
+        return [];
+    try {
+        const a = JSON.parse(v);
+        return Array.isArray(a) ? a.map(String) : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** True if an identical (project, user, assistant) chunk already exists (live). */
+export function chunkExists(projectId, userText, assistantText) {
+    const row = sqlite
+        .prepare(`SELECT 1 FROM conversation_chunks
+       WHERE project_id = ? AND user_text = ? AND assistant_text = ? AND deleted_at IS NULL
+       LIMIT 1`)
+        .get(projectId, userText, assistantText);
+    return !!row;
+}
+/** Save conversation chunks: vec0 embedding + metadata row + FTS keyword row, atomically. */
+export function saveChunks(chunks) {
+    const insertVec = sqlite.prepare("INSERT INTO vec_chunks(embedding, project_id) VALUES (?, ?)");
+    const insertMeta = sqlite.prepare(`INSERT INTO conversation_chunks(
+        id, vec_rowid, project_id, session_id, user_text, assistant_text, created_at,
+        obs_type, concepts, files_read, files_modified)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const insertFts = sqlite.prepare("INSERT INTO chunks_fts(chunk_id, text) VALUES (?, ?)");
+    const ids = [];
+    const tx = sqlite.transaction(() => {
+        for (const chunk of chunks) {
+            const res = insertVec.run(Buffer.from(chunk.embedding.buffer), chunk.projectId);
+            const vecRowid = res.lastInsertRowid;
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            insertMeta.run(id, vecRowid, chunk.projectId, chunk.sessionId, chunk.userText, chunk.assistantText, now, chunk.obsType ?? null, jsonArr(chunk.concepts), jsonArr(chunk.filesRead), jsonArr(chunk.filesModified));
+            insertFts.run(id, `${chunk.userText}\n${chunk.assistantText}`);
+            ids.push(id);
+        }
+    });
+    tx();
+    return ids;
+}
+const CHUNK_COLS = `c.id, c.session_id, c.project_id, c.user_text, c.assistant_text,
+  c.created_at, c.obs_type, c.concepts, c.files_read, c.files_modified`;
+/** Build the metadata WHERE fragment (always excludes tombstones). */
+function metaWhere(filter) {
+    const clauses = ["c.deleted_at IS NULL"];
+    const params = [];
+    if (filter?.obsType) {
+        clauses.push("c.obs_type = ?");
+        params.push(filter.obsType);
+    }
+    if (filter?.concept) {
+        clauses.push("c.concepts LIKE ?");
+        params.push(`%${filter.concept}%`);
+    }
+    if (filter?.file) {
+        clauses.push("(c.files_read LIKE ? OR c.files_modified LIKE ?)");
+        params.push(`%${filter.file}%`, `%${filter.file}%`);
+    }
+    if (filter?.dateFrom) {
+        clauses.push("c.created_at >= ?");
+        params.push(filter.dateFrom);
+    }
+    if (filter?.dateTo) {
+        clauses.push("c.created_at <= ?");
+        params.push(filter.dateTo);
+    }
+    return { sql: clauses.join(" AND "), params };
+}
+/** KNN semantic search, filtered by project inside the MATCH query. */
+export function searchSimilar(queryEmbedding, projectId, topK = 5, maxDistance, filter) {
+    const meta = metaWhere(filter);
+    const distClause = maxDistance != null ? " AND v.distance <= ?" : "";
+    const stmt = sqlite.prepare(`
+    SELECT ${CHUNK_COLS}, v.distance
+    FROM (
+      SELECT rowid, distance FROM vec_chunks
+      WHERE embedding MATCH ? AND k = ? AND project_id = ?
+    ) v
+    INNER JOIN conversation_chunks c ON c.vec_rowid = v.rowid
+    WHERE ${meta.sql}${distClause}
+    ORDER BY v.distance
+  `);
+    const params = [
+        Buffer.from(queryEmbedding.buffer),
+        topK,
+        projectId,
+        ...meta.params,
+    ];
+    if (maxDistance != null)
+        params.push(maxDistance);
+    return stmt.all(...params).map(mapRow);
+}
+/** FTS5 keyword search (fallback / augmentation for keyword-ish queries). */
+export function searchKeyword(query, projectId, limit = 5, filter) {
+    const match = toFtsQuery(query);
+    if (!match)
+        return [];
+    const meta = metaWhere(filter);
+    const rows = sqlite
+        .prepare(`SELECT ${CHUNK_COLS}
+       FROM chunks_fts f
+       INNER JOIN conversation_chunks c ON c.id = f.chunk_id
+       WHERE f.text MATCH ? AND c.project_id = ? AND ${meta.sql}
+       LIMIT ?`)
+        .all(match, projectId, ...meta.params, limit);
+    return rows.map(mapRow);
+}
+export function getChunksByIds(ids) {
+    if (ids.length === 0)
+        return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = sqlite
+        .prepare(`SELECT ${CHUNK_COLS} FROM conversation_chunks c
+       WHERE c.id IN (${placeholders}) AND c.deleted_at IS NULL`)
+        .all(...ids);
+    return rows.map(mapRow);
+}
+export function listChunks(projectId, limit = 200) {
+    const rows = sqlite
+        .prepare(`SELECT ${CHUNK_COLS} FROM conversation_chunks c
+       WHERE c.project_id = ? AND c.deleted_at IS NULL
+       ORDER BY c.created_at DESC LIMIT ?`)
+        .all(projectId, limit);
+    return rows.map(mapRow);
+}
+export function deleteChunksBySession(sessionId) {
+    const rows = sqlite
+        .prepare("SELECT id, vec_rowid FROM conversation_chunks WHERE session_id = ?")
+        .all(sessionId);
+    if (rows.length === 0)
+        return;
+    const deleteVec = sqlite.prepare("DELETE FROM vec_chunks WHERE rowid = ?");
+    const deleteFts = sqlite.prepare("DELETE FROM chunks_fts WHERE chunk_id = ?");
+    const deleteMeta = sqlite.prepare("DELETE FROM conversation_chunks WHERE session_id = ?");
+    const tx = sqlite.transaction(() => {
+        for (const row of rows) {
+            deleteVec.run(row.vec_rowid);
+            deleteFts.run(row.id);
+        }
+        deleteMeta.run(sessionId);
+    });
+    tx();
+}
+/** Soft-delete chunks by id (memory_forget). Returns the number tombstoned. */
+export function forgetChunks(ids) {
+    if (ids.length === 0)
+        return 0;
+    const placeholders = ids.map(() => "?").join(",");
+    const res = sqlite
+        .prepare(`UPDATE conversation_chunks SET deleted_at = ?
+       WHERE id IN (${placeholders}) AND deleted_at IS NULL`)
+        .run(new Date().toISOString(), ...ids);
+    return res.changes;
+}
+export function getChunkCount(projectId) {
+    const row = sqlite
+        .prepare("SELECT COUNT(*) as count FROM conversation_chunks WHERE project_id = ? AND deleted_at IS NULL")
+        .get(projectId);
+    return row.count;
+}
+function mapRow(r) {
+    return {
+        id: r.id,
+        sessionId: r.session_id,
+        projectId: r.project_id,
+        userText: r.user_text,
+        assistantText: r.assistant_text,
+        createdAt: r.created_at,
+        obsType: r.obs_type ?? null,
+        concepts: parseArr(r.concepts),
+        filesRead: parseArr(r.files_read),
+        filesModified: parseArr(r.files_modified),
+        distance: r.distance ?? 0,
+    };
+}
+/**
+ * Turn a free-text query into a safe FTS5 OR-query of quoted terms. The trigram
+ * tokenizer needs terms of >=3 chars; shorter tokens are dropped.
+ */
+function toFtsQuery(query) {
+    const terms = query
+        .replace(/["()*:^]/g, " ")
+        .split(/\s+/)
+        .filter((t) => t.length >= 3)
+        .map((t) => `"${t.replace(/"/g, "")}"`);
+    if (terms.length === 0)
+        return null;
+    return terms.join(" OR ");
+}

package/dist/core/watermark.js

@@ -0,0 +1,19 @@
+// src/core/watermark.ts
+//
+// Incremental distill bookkeeping: remember the mtime of each transcript we've
+// already distilled so hooks can skip sessions with no new content.
+import { sqlite } from "./db.js";
+/** True if the transcript at `path` is newer than the last time we distilled it. */
+export function shouldDistill(path, mtimeMs) {
+    const row = sqlite
+        .prepare("SELECT mtime_ms FROM distill_watermarks WHERE path = ?")
+        .get(path);
+    return !row || mtimeMs > row.mtime_ms;
+}
+export function markDistilled(path, mtimeMs) {
+    sqlite
+        .prepare(`INSERT INTO distill_watermarks(path, mtime_ms, distilled_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(path) DO UPDATE SET mtime_ms = excluded.mtime_ms, distilled_at = excluded.distilled_at`)
+        .run(path, mtimeMs, new Date().toISOString());
+}

package/dist/mcp/server.js

@@ -0,0 +1,259 @@
+// src/mcp/server.ts
+//
+// stdio MCP server. The engine is imported in-process: the Xenova model loads
+// once at startup and is reused for every tool call within the agent session.
+// No daemon, no external services.
+import { basename } from "node:path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { getOrCreateProjectByPath } from "../core/projects.js";
+import { getPreferences } from "../core/memory.js";
+import { buildMemoryBlock } from "../core/recall.js";
+import { searchIndex } from "../core/search.js";
+import { getChunksByIds, forgetChunks } from "../core/vector-memory.js";
+import { distill, rememberText } from "../core/distill.js";
+import { resolveSessionJsonl } from "../core/transcript.js";
+import { searchLogs } from "../core/logsearch/search.js";
+import { isExcludedPath } from "../core/excludes.js";
+function projectFor(cwd) {
+    return getOrCreateProjectByPath(cwd && cwd.trim() ? cwd : process.cwd());
+}
+const TOOLS = [
+    {
+        name: "memory_recall",
+        description: "Retrieve relevant long-term memory for the current project as a ready-to-read context block: user preferences (always-apply) plus recent session summaries and semantically similar past conversations (reference-only). Call this at the start of a conversation, passing the user's request as `query`.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "The user's latest request / topic to find related memory for." },
+                cwd: { type: "string", description: "Project working directory. Defaults to the server's cwd." },
+                topK: { type: "number", description: "Max similar conversations (default 5)." },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "memory_search",
+        description: "Token-efficient memory search. Returns a light index (id + title + date + type) of matching past conversation chunks (hybrid semantic + keyword). Optional filters: type/concept/file/date. Use the returned ids with memory_get to fetch full bodies only for what you need.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string" },
+                cwd: { type: "string" },
+                limit: { type: "number", description: "Max hits (default 8)." },
+                type: { type: "string", description: "Filter by obs_type: discovery|bugfix|feature|decision|change|other." },
+                concept: { type: "string", description: "Filter to chunks tagged with this concept (substring)." },
+                file: { type: "string", description: "Filter to chunks touching this file path (substring)." },
+                dateFrom: { type: "string", description: "Only chunks created on/after this ISO date." },
+                dateTo: { type: "string", description: "Only chunks created on/before this ISO date." },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "memory_get",
+        description: "Fetch the full text of conversation chunks by their ids (from memory_search).",
+        inputSchema: {
+            type: "object",
+            properties: { ids: { type: "array", items: { type: "string" } } },
+            required: ["ids"],
+        },
+    },
+    {
+        name: "memory_remember",
+        description: "Store a single free-text note into long-term memory for later semantic recall.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string" },
+                cwd: { type: "string" },
+                sessionId: { type: "string", description: "Optional grouping id (default 'manual')." },
+            },
+            required: ["text"],
+        },
+    },
+    {
+        name: "memory_distill",
+        description: "Distill a finished session transcript into a summary + user preferences + embedded chunks. Provide a sessionId (resolved from the Claude Code transcript under the given cwd) or an explicit transcriptPath. Requires LLM credentials in the environment.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                cwd: { type: "string" },
+                sessionId: { type: "string" },
+                transcriptPath: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "memory_get_preferences",
+        description: "List the stored user preferences for the current project.",
+        inputSchema: {
+            type: "object",
+            properties: { cwd: { type: "string" } },
+        },
+    },
+    {
+        name: "memory_forget",
+        description: "Soft-delete conversation chunks by id (from memory_search). Tombstoned chunks are excluded from search, recall and the viewer. Irreversible via this tool.",
+        inputSchema: {
+            type: "object",
+            properties: { ids: { type: "array", items: { type: "string" } } },
+            required: ["ids"],
+        },
+    },
+    {
+        name: "memory_search_logs",
+        description: "Full-text search across RAW agent transcripts (Claude Code and Codex) under ~/.claude/projects and ~/.codex/sessions. A second memory source independent of the distilled DB: finds past conversations even if they were never distilled. Returns matches with surrounding context, source, project path, session id, role and timestamp.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Substring to search for (case-insensitive)." },
+                sources: {
+                    type: "array",
+                    items: { type: "string", enum: ["claude-code", "codex"] },
+                    description: "Which log sources to scan (default both).",
+                },
+                projectPath: { type: "string", description: "Restrict to a project by working-dir path (substring)." },
+                startDate: { type: "string", description: "ISO date lower bound (inclusive)." },
+                endDate: { type: "string", description: "ISO date upper bound (inclusive)." },
+                limit: { type: "number", description: "Max hits (default 20)." },
+                offset: { type: "number", description: "Skip N hits (default 0)." },
+            },
+            required: ["query"],
+        },
+    },
+];
+const server = new Server({ name: "claw-memory", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const name = req.params.name;
+    const args = (req.params.arguments ?? {});
+    try {
+        const text = await dispatch(name, args);
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `claw-memory error in ${name}: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+        };
+    }
+});
+async function dispatch(name, args) {
+    switch (name) {
+        case "memory_recall": {
+            const project = projectFor(args.cwd);
+            const block = await buildMemoryBlock(project.id, String(args.query ?? ""), args.topK ?? 5);
+            return block.fullText || "(記憶なし: このプロジェクトにはまだ保存された記憶がありません)";
+        }
+        case "memory_search": {
+            const project = projectFor(args.cwd);
+            const hits = await searchIndex(project.id, String(args.query ?? ""), args.limit ?? 8, {
+                obsType: args.type,
+                concept: args.concept,
+                file: args.file,
+                dateFrom: args.dateFrom,
+                dateTo: args.dateTo,
+            });
+            if (hits.length === 0)
+                return "(該当なし)";
+            return hits
+                .map((h) => `- id=${h.id} [${h.date}] (${h.source}${h.obsType ? `/${h.obsType}` : ""}${h.distance != null ? ` d=${h.distance.toFixed(3)}` : ""}) ${h.title}`)
+                .join("\n");
+        }
+        case "memory_get": {
+            const ids = args.ids ?? [];
+            const chunks = getChunksByIds(ids);
+            if (chunks.length === 0)
+                return "(該当なし)";
+            return chunks
+                .map((c) => {
+                const tags = [
+                    c.obsType ? `type=${c.obsType}` : "",
+                    c.concepts.length ? `concepts=${c.concepts.join(", ")}` : "",
+                    c.filesModified.length ? `modified=${c.filesModified.join(", ")}` : "",
+                    c.filesRead.length ? `read=${c.filesRead.join(", ")}` : "",
+                ].filter(Boolean);
+                const meta = tags.length ? `\n[${tags.join(" | ")}]` : "";
+                return `### ${c.id} [${c.createdAt.split("T")[0]}]${meta}\nUser: ${c.userText}\nAssistant: ${c.assistantText}`;
+            })
+                .join("\n\n");
+        }
+        case "memory_forget": {
+            const ids = args.ids ?? [];
+            const n = forgetChunks(ids);
+            return `忘却しました (${n}件を削除済みにしました)`;
+        }
+        case "memory_remember": {
+            const cwdArg = args.cwd ?? process.cwd();
+            if (isExcludedPath(cwdArg))
+                return "(除外プロジェクトのため保存しませんでした)";
+            const project = projectFor(args.cwd);
+            const id = await rememberText({
+                projectId: project.id,
+                sessionId: args.sessionId ?? "manual",
+                text: String(args.text ?? ""),
+            });
+            return `保存しました (id=${id})`;
+        }
+        case "memory_distill": {
+            const cwd = args.cwd ?? process.cwd();
+            if (isExcludedPath(cwd))
+                return JSON.stringify({ skipped: "excluded project" });
+            const project = getOrCreateProjectByPath(cwd);
+            const sessionId = args.sessionId ?? "";
+            const transcriptPath = args.transcriptPath ??
+                (sessionId ? resolveSessionJsonl(cwd, sessionId) : undefined);
+            if (!transcriptPath) {
+                throw new Error("memory_distill requires sessionId or transcriptPath");
+            }
+            const res = await distill({
+                projectId: project.id,
+                sessionId: sessionId || transcriptPath,
+                transcriptPath,
+            });
+            return JSON.stringify(res);
+        }
+        case "memory_get_preferences": {
+            const project = projectFor(args.cwd);
+            const prefs = getPreferences(project.id);
+            if (prefs.length === 0)
+                return "(好みは未保存)";
+            return prefs.map((p) => `- ${p.key}: ${p.value}`).join("\n");
+        }
+        case "memory_search_logs": {
+            const { results, total } = await searchLogs({
+                query: String(args.query ?? ""),
+                sources: args.sources,
+                projectPath: args.projectPath,
+                startDate: args.startDate,
+                endDate: args.endDate,
+                limit: args.limit ?? 20,
+                offset: args.offset ?? 0,
+            });
+            if (results.length === 0)
+                return "(該当なし)";
+            const lines = results.map((r) => {
+                const date = r.timestamp ? r.timestamp.split("T")[0] : "????-??-??";
+                const ctx = `${r.contextBefore}「${r.matchedText}」${r.contextAfter}`
+                    .replace(/\s+/g, " ")
+                    .trim();
+                return `- [${date}] (${r.source}/${r.role}) ${basename(r.projectPath)} #${r.sessionId.slice(0, 8)}\n  …${ctx}…`;
+            });
+            return `${total}件ヒット (上位${results.length}件表示):\n${lines.join("\n")}`;
+        }
+        default:
+            throw new Error(`unknown tool: ${name}`);
+    }
+}
+export async function runMcpServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[claw-memory] MCP server ready (stdio)");
+}

package/dist/ui/page.js

@@ -0,0 +1,182 @@
+// src/ui/page.ts
+// Single-file viewer (vanilla JS, no build step). Served as-is by the UI server.
+export const PAGE = /* html */ `<!doctype html>
+<html lang="ja">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>claw-memory viewer</title>
+<style>
+  :root { --bg:#0d1117; --panel:#161b22; --border:#30363d; --fg:#e6edf3; --muted:#8b949e;
+          --accent:#58a6ff; --chip:#21262d; }
+  * { box-sizing:border-box; }
+  body { margin:0; font:14px/1.55 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;
+         background:var(--bg); color:var(--fg);
+         height:100vh; overflow:hidden; display:flex; flex-direction:column; }
+  header { display:flex; align-items:center; gap:12px; padding:12px 18px;
+           border-bottom:1px solid var(--border); background:var(--panel); flex:0 0 auto; }
+  header h1 { font-size:15px; margin:0; font-weight:600; }
+  header .muted { color:var(--muted); font-size:12px; }
+  #search { margin-left:auto; background:var(--bg); border:1px solid var(--border); color:var(--fg);
+            border-radius:6px; padding:6px 10px; width:280px; }
+  .layout { display:flex; flex:1; min-height:0; }
+  nav { width:240px; border-right:1px solid var(--border); padding:10px; overflow-y:auto; min-height:0; }
+  nav button { display:block; width:100%; text-align:left; background:transparent; color:var(--fg);
+               border:0; border-radius:6px; padding:8px 10px; cursor:pointer; font-size:13px; }
+  nav button:hover { background:var(--chip); }
+  nav button.active { background:var(--chip); border:1px solid var(--border); }
+  nav .nm { font-weight:600; }
+  nav .pth { color:var(--muted); font-size:11px; word-break:break-all; }
+  main { flex:1; padding:18px; overflow-y:auto; min-height:0; }
+  .sect { margin-bottom:26px; }
+  .sect h2 { font-size:12px; text-transform:uppercase; letter-spacing:.08em; color:var(--muted);
+             margin:0 0 10px; }
+  .card { background:var(--panel); border:1px solid var(--border); border-radius:8px;
+          padding:12px 14px; margin-bottom:10px; }
+  .card .meta { color:var(--muted); font-size:11px; margin-bottom:6px; display:flex; gap:8px; }
+  .tag { background:var(--chip); border-radius:4px; padding:1px 6px; font-size:10px; }
+  .card .u { color:var(--accent); }
+  .card pre { white-space:pre-wrap; word-break:break-word; margin:4px 0 0; font:inherit; }
+  .pref { display:inline-flex; gap:6px; background:var(--panel); border:1px solid var(--border);
+          border-radius:6px; padding:6px 10px; margin:0 8px 8px 0; }
+  .pref b { color:var(--accent); }
+  .empty { color:var(--muted); padding:30px; text-align:center; }
+  .cmeta { color:var(--muted); font-size:11px; margin:2px 0; word-break:break-all; }
+  header button#logsBtn { background:var(--chip); color:var(--fg); border:1px solid var(--border);
+    border-radius:6px; padding:6px 10px; cursor:pointer; font-size:12px; }
+  header button#logsBtn.on { background:var(--accent); color:#0d1117; border-color:var(--accent); }
+  .src { color:var(--accent); font-size:10px; }
+  .hl { background:#9e6a03; color:#fff; border-radius:2px; padding:0 1px; }
+</style>
+</head>
+<body>
+<header>
+  <h1>🧠 claw-memory</h1>
+  <span class="muted" id="stats"></span>
+  <button id="logsBtn" title="生ログ全文検索 (Claude Code + Codex)">🔎 ログ検索</button>
+  <input id="search" placeholder="フィルタ (本文を絞り込み)" />
+</header>
+<div class="layout">
+  <nav id="nav"></nav>
+  <main id="main"><div class="empty">プロジェクトを選択してください</div></main>
+</div>
+<script>
+let projects = [], current = null, filter = "";
+const el = (id) => document.getElementById(id);
+
+async function boot() {
+  const s = await (await fetch("/api/stats")).json();
+  el("stats").textContent = s.projects + " projects · " + s.chunks + " chunks · " + s.summaries + " summaries";
+  projects = await (await fetch("/api/projects")).json();
+  renderNav();
+  if (projects.length && !current) select(projects[0].id);
+  else if (current) select(current);
+}
+
+// Live updates: the server pushes a "change" event whenever the DB is written
+// (e.g. the MCP server stores a new memory). Refresh in place — keep the
+// selected project and scroll position so the view doesn't jump.
+function connectEvents() {
+  const es = new EventSource("/api/events");
+  es.addEventListener("change", () => {
+    const main = el("main");
+    const y = main ? main.scrollTop : 0;
+    boot().then(() => { const m = el("main"); if (m) m.scrollTop = y; });
+  });
+  es.onerror = () => {}; // EventSource auto-reconnects
+}
+function renderNav() {
+  el("nav").innerHTML = projects.map(p =>
+    '<button data-id="'+p.id+'" class="'+(p.id===current?'active':'')+'">'
+    + '<div class="nm">'+esc(p.name)+'</div>'
+    + '<div class="pth">'+esc(p.path)+'</div>'
+    + '<div class="pth">'+p.counts.summaries+' sum · '+p.counts.chunks+' chunk · '+p.counts.preferences+' pref</div>'
+    + '</button>').join("");
+  el("nav").querySelectorAll("button").forEach(b =>
+    b.onclick = () => select(b.dataset.id));
+}
+async function select(id) {
+  current = id; renderNav();
+  const d = await (await fetch("/api/memory?project="+encodeURIComponent(id))).json();
+  render(d);
+}
+function render(d) {
+  const f = filter.toLowerCase();
+  const match = (t) => !f || (t||"").toLowerCase().includes(f);
+  const prefs = d.preferences.filter(p => match(p.key+" "+p.value));
+  const sums = d.summaries.filter(s => match(s.summary));
+  const chunks = d.chunks.filter(c => match(c.userText+" "+c.assistantText));
+  let h = "";
+  if (prefs.length) h += '<div class="sect"><h2>User Preferences (always-apply)</h2>'
+    + prefs.map(p => '<span class="pref"><b>'+esc(p.key)+'</b> '+esc(p.value)+'</span>').join("") + '</div>';
+  if (sums.length) h += '<div class="sect"><h2>Session Summaries</h2>'
+    + sums.map(s => '<div class="card"><div class="meta"><span class="tag">summary</span>'
+      + (s.created_at||"").split("T")[0]+'</div><pre>'+esc(s.summary)+'</pre></div>').join("") + '</div>';
+  if (chunks.length) h += '<div class="sect"><h2>Conversation Chunks</h2>'
+    + chunks.map(c => '<div class="card"><div class="meta"><span class="tag">chunk</span>'
+      + (c.obsType ? '<span class="tag">'+esc(c.obsType)+'</span>' : "")
+      + (c.createdAt||"").split("T")[0]+'</div>'
+      + chunkMeta(c)
+      + '<pre><span class="u">User:</span> '+esc(c.userText)
+      + (c.assistantText ? '\\n<span class="u">Assistant:</span> '+esc(c.assistantText) : "")
+      + '</pre></div>').join("") + '</div>';
+  el("main").innerHTML = h || '<div class="empty">記憶がありません</div>';
+}
+function chunkMeta(c) {
+  const parts = [];
+  if (c.concepts && c.concepts.length) parts.push('<div class="cmeta">🏷 '+c.concepts.map(esc).join(", ")+'</div>');
+  const files = [].concat(c.filesModified||[], c.filesRead||[]);
+  if (files.length) parts.push('<div class="cmeta">📄 '+files.map(esc).join(", ")+'</div>');
+  return parts.join("");
+}
+function esc(s){ return (s==null?"":String(s)).replace(/[&<>]/g, m => ({'&':'&amp;','<':'&lt;','>':'&gt;'}[m])); }
+let logMode = false, logTimer = null;
+function currentPath() { const p = projects.find(x => x.id === current); return p ? p.path : ""; }
+
+el("logsBtn").addEventListener("click", () => {
+  logMode = !logMode;
+  el("logsBtn").classList.toggle("on", logMode);
+  el("search").value = "";
+  el("search").placeholder = logMode
+    ? "生ログ全文検索 (このプロジェクトのCC+Codexログ)"
+    : "フィルタ (本文を絞り込み)";
+  if (logMode) el("main").innerHTML = '<div class="empty">検索語を入力してください (Claude Code + Codex の生ログを全文検索)</div>';
+  else if (current) select(current);
+});
+
+el("search").addEventListener("input", e => {
+  const v = e.target.value;
+  if (logMode) {
+    clearTimeout(logTimer);
+    logTimer = setTimeout(() => runLogSearch(v), 300);
+  } else {
+    filter = v;
+    if (current) select(current);
+  }
+});
+
+async function runLogSearch(q) {
+  if (!q.trim()) { el("main").innerHTML = '<div class="empty">検索語を入力してください</div>'; return; }
+  el("main").innerHTML = '<div class="empty">検索中…</div>';
+  const url = "/api/logs?q=" + encodeURIComponent(q) + "&project=" + encodeURIComponent(currentPath()) + "&limit=50";
+  let d;
+  try { d = await (await fetch(url)).json(); }
+  catch { el("main").innerHTML = '<div class="empty">検索に失敗しました</div>'; return; }
+  if (!d.results || d.results.length === 0) { el("main").innerHTML = '<div class="empty">該当なし</div>'; return; }
+  const cards = d.results.map(r => {
+    const date = r.timestamp ? r.timestamp.split("T")[0] : "????-??-??";
+    const ctx = esc(r.contextBefore) + '<span class="hl">' + esc(r.matchedText) + '</span>' + esc(r.contextAfter);
+    return '<div class="card"><div class="meta">'
+      + '<span class="tag">' + esc(r.source) + '</span>'
+      + '<span class="tag">' + esc(r.role) + '</span>' + date + '</div>'
+      + '<div class="cmeta">' + esc(r.projectPath) + ' · #' + esc((r.sessionId||"").slice(0,8)) + '</div>'
+      + '<pre>…' + ctx + '…</pre></div>';
+  }).join("");
+  el("main").innerHTML = '<div class="sect"><h2>Raw Log Search — ' + d.total + ' hits (showing ' + d.results.length + ')</h2>' + cards + '</div>';
+}
+
+boot();
+connectEvents();
+</script>
+</body>
+</html>`;