@nogataka/claw-memory 0.2.0 → 0.3.0

package/.claude-plugin/marketplace.json

@@ -1,16 +1,18 @@
 {
   "name": "claw-memory-marketplace",
-  "owner": { "name": "nogataka" },
+  "owner": {
+    "name": "nogataka"
+  },
   "metadata": {
     "description": "claw-memory: local semantic memory + raw-log search for Claude Code",
-    "version": "0.1.3"
+    "version": "0.3.0"
   },
   "plugins": [
     {
       "name": "claw-memory",
       "source": "./",
       "description": "Local semantic memory: auto-distill, recall injection, and raw Claude Code + Codex transcript search.",
-      "version": "0.1.3"
+      "version": "0.3.0"
     }
   ]
 }

package/.claude-plugin/plugin.json

@@ -1,9 +1,17 @@
 {
   "name": "claw-memory",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Local semantic memory for Claude Code: auto-distills sessions, injects relevant past context, and searches raw Claude Code + Codex transcripts. sqlite-vec + local embeddings, no daemon, no Python.",
-  "author": { "name": "nogataka" },
+  "author": {
+    "name": "nogataka"
+  },
   "repository": "https://github.com/nogataka/claw-memory",
   "license": "MIT",
-  "keywords": ["memory", "mcp", "context", "search", "codex"]
+  "keywords": [
+    "memory",
+    "mcp",
+    "context",
+    "search",
+    "codex"
+  ]
 }

package/README.ja.md

@@ -14,7 +14,7 @@
 npm install -g @nogataka/claw-memory
 ```
 
-- **ストレージ**: `better-sqlite3` + `sqlite-vec` — ベクトルを 1 つの SQLite ファイル内に格納
+- **ストレージ**: `node:sqlite`（Node >= 24 組み込み・ネイティブ ABI なし）+ `sqlite-vec` — ベクトルを 1 つの SQLite ファイル内に格納
 - **埋め込み**: ローカルの `Xenova/multilingual-e5-small`（384次元・多言語・オフライン）
 - **2 つの記憶ソース**: 蒸留済みのセマンティック DB と、Claude Code / Codex の生ログ全文検索
 - **自動取り込み**: フックで終了済みセッションを蒸留し、新しいセッションへ関連記憶を注入
@@ -144,7 +144,8 @@ npm install -g @nogataka/claw-memory
 Claude Code を再起動してください。次が自動登録されます。
 
 - **MCP サーバー**（8 つの記憶ツール）
-- **フック**: `SessionStart` / `UserPromptSubmit` → recall 注入、`Stop` → 自動 distill
+- **フック**: `SessionStart` → コンパクトな recall 注入（Pull 型）、`Stop` → 自動 distill
+  フックのエラーは握り潰さず `~/.claw-memory/logs/hook-error.log` に記録されます
 
 手動設定は不要です。確認は `/mcp` で `claw-memory` が見えるかどうかで行えます。
 
@@ -165,7 +166,7 @@ codex
 プラグインは Codex が互換提供する `${CLAUDE_PLUGIN_ROOT}` を介して次を登録します。
 
 - `claw-memory` MCP サーバー（`.mcp.json`）
-- `SessionStart` / `UserPromptSubmit` → **recall 自動注入**（memory ブロックを developer context として）
+- `SessionStart` → **コンパクトな recall 自動注入**（設定＋1行要約。詳細は `memory_recall` でオンデマンド取得）
 - `Stop` → 最近の Codex セッションの**自動 distill**（watermark 重複回避・非同期）
 - `memory-recall` skill
 
@@ -197,7 +198,7 @@ claw-memory distill-codex --all        # 全件バックフィル
 ```bash
 git clone https://github.com/nogataka/claw-memory
 cd claw-memory
-npm install          # ネイティブの better-sqlite3 / sqlite-vec をビルド
+npm install          # ネイティブビルドなし（ストレージは Node 組み込みの node:sqlite）
 npm run build        # tsc -> dist/
 npm link             # 任意: `claw-memory` バイナリを公開
 ```
@@ -352,7 +353,9 @@ npm uninstall -g @nogataka/claw-memory
 
 ## 補足
 
-- `better-sqlite3` / `sqlite-vec` はネイティブモジュールです。Node の ABI 変更後は `npm rebuild` を実行してください。
+- ストレージは Node 組み込みの `node:sqlite` を使用します（Node >= 24 必須）。Node を更新してもネイティブ ABI 不一致で壊れることはありません。`sqlite-vec` 拡張はプリビルト配布で ABI 非依存です。
+- v0.3.0 で毎プロンプト注入を廃止しました（コンテキスト圧迫対策）。フックは `SessionStart` にコンパクトなブロックを1回注入するのみで、詳細は `memory_recall` / `memory_search`（MCP）または `memory-recall` スキルで明示的に取得します。
+- `claw-memory cleanse` で、生 JSON が混入した過去チャンクを検出（`--apply` でソフトデリート）できます。
 - MCP サーバーはエージェントセッションごとに常駐するため、埋め込みモデルは 1 回だけロードされます。
 - ビューアと MCP は同時実行できます（SQLite WAL が並行読み書きを処理）。
 - インストール時、依存は `legacy-peer-deps=true` で解決されます（同梱 SDK 間の zod の

package/README.md

@@ -14,7 +14,7 @@ session, which you control).
 npm install -g @nogataka/claw-memory
 ```
 
-- **Storage**: `better-sqlite3` + `sqlite-vec` — vectors live *inside* one SQLite file
+- **Storage**: `node:sqlite` (built into Node >= 24, no native ABI) + `sqlite-vec` — vectors live *inside* one SQLite file
 - **Embeddings**: local `Xenova/multilingual-e5-small` (384-dim, multilingual, offline)
 - **Two memory sources**: a distilled semantic DB **and** full-text search over raw
   Claude Code + Codex transcripts
@@ -153,7 +153,8 @@ plugin falls back to `npx -y @nogataka/claw-memory@latest`, which is slower on f
 Restart Claude Code. This auto-registers:
 
 - the **MCP server** (8 memory tools), and
-- the **hooks**: `SessionStart` / `UserPromptSubmit` → recall injection, `Stop` → auto-distill.
+- the **hooks**: `SessionStart` → compact recall injection (pull model), `Stop` → auto-distill.
+  Hook errors are logged to `~/.claw-memory/logs/hook-error.log` instead of being swallowed.
 
 No manual config. To verify, run `/mcp` and look for `claw-memory`.
 
@@ -174,7 +175,7 @@ codex
 The plugin registers, via Codex's `${CLAUDE_PLUGIN_ROOT}` (provided for compatibility):
 
 - the `claw-memory` MCP server (`.mcp.json`),
-- `SessionStart` / `UserPromptSubmit` → **auto recall injection** (memory block as developer context),
+- `SessionStart` → **compact recall injection** (preferences + one-line summaries; details are pulled on demand via `memory_recall`),
 - `Stop` → **auto distill** of recent Codex sessions (watermark-deduped, async), and
 - the `memory-recall` skill.
 
@@ -206,7 +207,7 @@ claw-memory distill-codex --all        # backfill everything
 ```bash
 git clone https://github.com/nogataka/claw-memory
 cd claw-memory
-npm install          # builds native better-sqlite3 / sqlite-vec
+npm install          # no native builds — storage is Node's built-in node:sqlite
 npm run build        # tsc -> dist/
 npm link             # optional: expose the `claw-memory` binary
 ```
@@ -362,7 +363,9 @@ Your memory database is left untouched; delete `~/.claw-memory` to wipe it.
 
 ## Notes
 
-- `better-sqlite3` / `sqlite-vec` are native modules; run `npm rebuild` after a Node ABI change.
+- Storage uses Node's built-in `node:sqlite` (Node >= 24 required), so Node upgrades can't break a native ABI. The `sqlite-vec` extension ships prebuilt and is version-independent.
+- Per-prompt injection was removed in v0.3.0 (context-bloat fix): hooks inject a compact block at `SessionStart` only; pull details on demand with `memory_recall` / `memory_search` or the `memory-recall` skill.
+- `claw-memory cleanse` finds (and with `--apply` tombstones) legacy chunks polluted by raw JSON payloads.
 - The MCP server is long-lived per agent session, so the embedding model loads once.
 - Viewer + MCP can run simultaneously — SQLite WAL handles concurrent read/write.
 - On install, dependencies resolve with `legacy-peer-deps=true` (a zod peer-range overlap

package/dist/cli.js

@@ -203,6 +203,38 @@ async function main() {
             console.log(JSON.stringify({ scanned: convos.length, distilled, skipped, failed }, null, 2));
             process.exit(0);
         }
+        case "cleanse": {
+            // Hygiene pass over stored chunks: find rows whose text is a raw JSON
+            // payload (e.g. old distill responses stored verbatim) and tombstone
+            // them via the existing soft-delete. Dry-run by default; --apply acts.
+            const { sqlite } = await import("./core/db.js");
+            const { isContaminatedChunkText } = await import("./core/distill.js");
+            const { forgetChunks } = await import("./core/vector-memory.js");
+            const rows = sqlite
+                .prepare("SELECT id, user_text, assistant_text FROM conversation_chunks WHERE deleted_at IS NULL")
+                .all();
+            const bad = rows.filter((r) => isContaminatedChunkText(r.user_text) ||
+                isContaminatedChunkText(r.assistant_text));
+            if (hasFlag(rest, "apply")) {
+                const n = forgetChunks(bad.map((b) => b.id));
+                console.log(JSON.stringify({ scanned: rows.length, contaminated: bad.length, tombstoned: n }, null, 2));
+            }
+            else {
+                for (const b of bad.slice(0, Number(getFlag(rest, "show") ?? 5))) {
+                    const t = isContaminatedChunkText(b.user_text)
+                        ? b.user_text
+                        : b.assistant_text;
+                    console.log(`${b.id}  ${t.slice(0, 120).replace(/\s+/g, " ")}`);
+                }
+                console.log(JSON.stringify({
+                    scanned: rows.length,
+                    contaminated: bad.length,
+                    dryRun: true,
+                    hint: "run with --apply to tombstone (soft-delete)",
+                }, null, 2));
+            }
+            process.exit(0);
+        }
         case "remember": {
             const { getOrCreateProjectByPath } = await import("./core/projects.js");
             const { rememberText } = await import("./core/distill.js");
@@ -388,6 +420,7 @@ async function main() {
                 "  distill-codex [--recent] [--limit N] [--all]   distill recent Codex sessions\n" +
                 "  distill-chatgpt [--limit N] [--all]            distill ChatGPT web export conversations\n" +
                 "  remember --cwd P \"text\"\n" +
+                "  cleanse [--apply] [--show N]   find (and with --apply tombstone) JSON-contaminated chunks\n" +
                 "  lessons <list|search|inject|extract|approve|reject|archive|supersede>\n" +
                 "  search-logs \"query\" [--source claude-code,codex,chatgpt-web] [--project P] [--start ISO] [--end ISO] [--limit N] [--offset N]\n" +
                 "  hook <distill|recall>     run a Claude Code lifecycle hook (reads JSON on stdin)\n" +

package/dist/core/db.js

@@ -1,16 +1,44 @@
 // src/core/db.ts
 //
-// Storage foundation: better-sqlite3 + sqlite-vec (in-process vector search) +
-// FTS5 keyword fallback. No ORM, no daemon, no Python.
-import Database from "better-sqlite3";
+// Storage foundation: node:sqlite (built into Node >= 24, no native ABI to
+// break on Node upgrades) + sqlite-vec (in-process vector search) + FTS5
+// keyword fallback. No ORM, no daemon, no Python.
+import { DatabaseSync } from "node:sqlite";
 import * as sqliteVec from "sqlite-vec";
 import { dbPath } from "./paths.js";
-export const sqlite = new Database(dbPath);
-sqlite.pragma("journal_mode = WAL");
-sqlite.pragma("busy_timeout = 5000");
-sqlite.pragma("foreign_keys = ON");
-// Load the sqlite-vec extension (provides the vec0 virtual table).
-sqliteVec.load(sqlite);
+// allowExtension can only be set at construction time (node:sqlite security
+// design) and is required to load sqlite-vec below.
+export const sqlite = new DatabaseSync(dbPath, { allowExtension: true });
+sqlite.exec("PRAGMA journal_mode = WAL");
+sqlite.exec("PRAGMA busy_timeout = 5000");
+sqlite.exec("PRAGMA foreign_keys = ON");
+// Load the sqlite-vec extension (provides the vec0 virtual table). sqlite-vec's
+// load() helper targets better-sqlite3; node:sqlite takes the raw path instead.
+sqlite.loadExtension(sqliteVec.getLoadablePath());
+/**
+ * Run fn inside BEGIN/COMMIT with ROLLBACK on throw — node:sqlite has no
+ * equivalent of better-sqlite3's db.transaction() helper. Callers never nest;
+ * if one ever does, the inner call joins the outer transaction.
+ */
+export function transaction(fn) {
+    if (sqlite.isTransaction)
+        return fn();
+    sqlite.exec("BEGIN");
+    try {
+        const result = fn();
+        sqlite.exec("COMMIT");
+        return result;
+    }
+    catch (err) {
+        try {
+            sqlite.exec("ROLLBACK");
+        }
+        catch {
+            // rollback failure is secondary; surface the original error
+        }
+        throw err;
+    }
+}
 sqlite.exec(`
   CREATE TABLE IF NOT EXISTS projects (
     id TEXT PRIMARY KEY,

package/dist/core/distill.js

@@ -14,6 +14,53 @@ import { saveCandidates, extractDedicated, dedicatedEnabled, } from "./lesson-ex
 const MIN_MESSAGES = 2;
 const MIN_TEXT_LENGTH = 100;
 const MAX_CHARS_PER_MESSAGE = 500;
+// --- Chunk hygiene -----------------------------------------------------------
+// Raw JSON payloads and code dumps stored as chunks poison recall: they get
+// embedded, matched, and re-injected as "past conversation" forever (a past
+// distill JSON response was once re-stored verbatim this way). Strip fenced
+// code and drop messages that are effectively raw JSON before chunking.
+/** Replace fenced code blocks (incl. an unterminated trailing fence) with a placeholder. */
+export function stripCodeFences(text) {
+    return text
+        .replace(/```[\s\S]*?```/g, "[code]")
+        .replace(/```[\s\S]*$/, "[code]")
+        .trim();
+}
+/**
+ * True when the text is a raw JSON payload rather than prose. Handles
+ * truncated JSON (sliced mid-document) via the `{"key":`-shape heuristic,
+ * which complete-parse alone would miss.
+ */
+export function isJsonPayload(text) {
+    const t = text.trim();
+    if (!/^[[{]/.test(t))
+        return false;
+    if (/^[[{]\s*"/.test(t))
+        return true;
+    try {
+        JSON.parse(t);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * True when stored chunk text is garbage for recall: a raw JSON payload, a
+ * fence-wrapped JSON payload (```json …), or nothing but code once fences are
+ * stripped. Used by the new distill filter and by `cleanse` on legacy rows.
+ */
+export function isContaminatedChunkText(text) {
+    const t = text.trim();
+    if (!t)
+        return false;
+    if (isJsonPayload(t))
+        return true;
+    const fenced = t.match(/^```[a-zA-Z]*\s*([\s\S]*?)(?:```|$)/);
+    if (fenced && isJsonPayload(fenced[1] ?? ""))
+        return true;
+    return stripCodeFences(t).replace(/\[code\]/g, "").trim().length === 0;
+}
 const OBS_TYPES = ["discovery", "bugfix", "feature", "decision", "change", "other"];
 const PROMPT = (transcript) => `以下の会話を分析して JSON で回答してください。
 
@@ -51,7 +98,7 @@ export async function distill(input) {
         return { skipped: true, reason: "too few messages" };
     }
     const transcript = messages
-        .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.text.slice(0, MAX_CHARS_PER_MESSAGE)}`)
+        .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${stripCodeFences(m.text).slice(0, MAX_CHARS_PER_MESSAGE)}`)
         .join("\n");
     if (transcript.length < MIN_TEXT_LENGTH) {
         return { skipped: true, reason: "too short" };
@@ -92,9 +139,20 @@ export async function distill(input) {
             const m = messages[i];
             if (m.role === "user" && m.text.trim()) {
                 const next = messages[i + 1];
+                // Hygiene: skip pairs whose user side is contaminated (raw/fenced JSON
+                // or code-only); blank a contaminated assistant side. The full text
+                // stays searchable in raw logs.
+                if (isContaminatedChunkText(m.text))
+                    continue;
+                const userText = stripCodeFences(m.text);
+                if (!userText)
+                    continue;
+                const assistantContaminated = !next || next.role !== "assistant" || isContaminatedChunkText(next.text);
                 pairs.push({
-                    userText: m.text.slice(0, 500),
-                    assistantText: next?.role === "assistant" ? next.text.slice(0, 500) : "",
+                    userText: userText.slice(0, 500),
+                    assistantText: assistantContaminated
+                        ? ""
+                        : stripCodeFences(next.text).slice(0, 500),
                 });
             }
         }

package/dist/core/hooks.js

@@ -8,7 +8,7 @@ import { statSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { getOrCreateProjectByPath } from "./projects.js";
-import { buildMemoryBlock } from "./recall.js";
+import { buildStartupBlock } from "./recall.js";
 import { shouldDistill } from "./watermark.js";
 import { isExcludedPath } from "./excludes.js";
 import { log } from "./logger.js";
@@ -61,16 +61,17 @@ export function runDistillHook(input) {
     child.unref();
 }
 /**
- * SessionStart / UserPromptSubmit: print the memory block to stdout. When the
- * event carries the user's prompt it also pulls semantically similar past
- * conversations; otherwise just preferences + recent summaries.
+ * SessionStart: print the compact startup block (preferences + one-line
+ * summaries + pull pointer) to stdout. Prompt-driven semantic recall is pull
+ * only — the memory_recall MCP tool / memory-recall skill — so hooks no longer
+ * re-inject a large memory block into every turn.
  */
 export async function runRecallHook(input) {
     const cwd = input.cwd ?? process.cwd();
     if (isExcludedPath(cwd))
         return;
     const project = getOrCreateProjectByPath(cwd);
-    const block = await buildMemoryBlock(project.id, input.prompt ?? "", 5);
-    if (block.fullText.trim())
-        process.stdout.write(block.fullText + "\n");
+    const block = buildStartupBlock(project.id);
+    if (block)
+        process.stdout.write(block + "\n");
 }

package/dist/core/installer/codex.js

@@ -16,12 +16,12 @@ const AGENTS = join(CODEX_DIR, "AGENTS.md");
 const HOOKS = join(CODEX_DIR, "hooks.json");
 const SKILL_DIR = join(CODEX_DIR, "skills", "memory-recall");
 // Codex lifecycle hooks for the manual (non-plugin) install path. Mirrors the
-// Claude Code hook wiring: recall on session start / prompt, distill on stop.
+// Claude Code hook wiring: compact recall on session start only (pull model —
+// per-prompt injection was removed to stop context bloat), distill on stop.
 // Codex Stop carries no Claude-format transcript, so distill scans recent Codex
 // session files (watermark-guarded) instead of a single transcript_path.
 const HOOK_EVENTS = [
     ["SessionStart", "hook recall", false],
-    ["UserPromptSubmit", "hook recall", false],
     ["Stop", "distill-codex --limit 5", true],
 ];
 const BEGIN = "# >>> claw-memory >>>";
@@ -75,8 +75,22 @@ function installHooks() {
     const cli = cliInvoker();
     const f = readHooks();
     f.hooks = f.hooks ?? {};
+    // Sweep our hooks from every event first so events we no longer wire (e.g.
+    // the removed per-prompt UserPromptSubmit recall) don't linger on upgrade.
+    // Filter at hook granularity (like removeHooks) so a user hook sharing a
+    // group with ours is preserved, not swept along.
+    for (const event of Object.keys(f.hooks)) {
+        f.hooks[event] = f.hooks[event]
+            .map((g) => ({
+            ...g,
+            hooks: (g.hooks ?? []).filter((h) => !isOurHook(h.command)),
+        }))
+            .filter((g) => g.hooks.length > 0);
+        if (f.hooks[event].length === 0)
+            delete f.hooks[event];
+    }
     for (const [event, sub, isAsync] of HOOK_EVENTS) {
-        const list = (f.hooks[event] ?? []).filter((g) => !g.hooks?.some((h) => isOurHook(h.command)));
+        const list = f.hooks[event] ?? [];
         list.push({ hooks: [{ type: "command", command: `${cli} ${sub}`, async: isAsync }] });
         f.hooks[event] = list;
     }
@@ -163,9 +177,9 @@ export function installCodex() {
     const agentsPrev = existsSync(AGENTS) ? readFileSync(AGENTS, "utf-8") : "";
     writeFileSync(AGENTS, upsertBlock(agentsPrev, A_BEGIN, A_END, agentsBlock));
     done.push("AGENTS.md: recall instruction");
-    // 4) lifecycle hooks: auto recall (SessionStart/UserPromptSubmit) + auto distill (Stop)
+    // 4) lifecycle hooks: compact recall on SessionStart + auto distill on Stop
     installHooks();
-    done.push("hooks.json: SessionStart/UserPromptSubmit→recall, Stop→distill-codex");
+    done.push("hooks.json: SessionStart→recall, Stop→distill-codex");
     return done;
 }
 export function uninstallCodex() {

package/dist/core/lessons.js

@@ -9,7 +9,7 @@
 // source_chunk_ids) are stored as TEXT, parsed on read — same convention as
 // conversation_chunks.concepts.
 import { randomUUID } from "node:crypto";
-import { sqlite } from "./db.js";
+import { sqlite, transaction } from "./db.js";
 function jsonArr(v) {
     return v && v.length ? JSON.stringify(v) : null;
 }
@@ -75,14 +75,13 @@ export function saveLesson(input) {
     const scope = input.scope ?? "repo";
     const status = input.status ?? "candidate";
     const confidence = input.confidence ?? 0.5;
-    const tx = sqlite.transaction(() => {
+    transaction(() => {
         const res = insertVec.run(Buffer.from(input.embedding.buffer), input.projectId ?? null, scope);
         const vecRowid = res.lastInsertRowid;
         insertMeta.run(id, vecRowid, input.projectId ?? null, input.repoId ?? null, input.sessionId ?? null, input.title, input.lesson, jsonArr(input.appliesWhen), jsonArr(input.avoidWhen), input.evidence ?? null, scope, input.obsType ?? null, jsonArr(input.concepts), jsonArr(input.files), confidence, jsonArr(input.sourceChunkIds), status, now, now);
         insertFts.run(id, `${input.title}\n${input.lesson}`);
         recordEvent(id, "created", { newStatus: status });
     });
-    tx();
     return id;
 }
 export function getLesson(id) {
@@ -230,7 +229,7 @@ export function supersede(oldId, newId) {
     if (!current)
         return false;
     const now = new Date().toISOString();
-    const tx = sqlite.transaction(() => {
+    transaction(() => {
         sqlite
             .prepare("UPDATE lessons SET status = 'superseded', superseded_by = ?, updated_at = ? WHERE id = ?")
             .run(newId, now, oldId);
@@ -241,7 +240,6 @@ export function supersede(oldId, newId) {
         });
         linkLessons(newId, oldId, "supersedes");
     });
-    tx();
     return true;
 }
 /** Update one or more editable fields (scope / confidence / valid_until). */
@@ -278,11 +276,10 @@ export function markUsed(ids) {
         return;
     const now = new Date().toISOString();
     const stmt = sqlite.prepare("UPDATE lessons SET last_used_at = ? WHERE id = ?");
-    const tx = sqlite.transaction(() => {
+    transaction(() => {
         for (const id of ids)
             stmt.run(now, id);
     });
-    tx();
 }
 export function linkLessons(lessonId, linkedLessonId, relation) {
     sqlite

package/dist/core/recall.js

@@ -11,6 +11,49 @@ const MEMORY_MAX_DISTANCE = Number(process.env.MEMORY_SIMILARITY_MAX_DISTANCE ??
 // Approved lessons injected into the recall block. Kept small to avoid context
 // bloat; 0 disables lesson injection entirely.
 const RECALL_LESSON_LIMIT = Number(process.env.LESSON_RECALL_LIMIT ?? 3);
+// SessionStart-only injection (pull model). Hooks used to push the full memory
+// block (~14KB measured) into every prompt; now hooks inject only this compact
+// block and detailed recall happens on demand via the memory_recall MCP tool /
+// memory-recall skill.
+const STARTUP_SUMMARY_LIMIT = Number(process.env.MEMORY_STARTUP_SUMMARIES ?? 3);
+const STARTUP_SUMMARY_CHARS = 160;
+/** Flatten a structured markdown summary to a single truncated line. */
+function oneLine(text, max = STARTUP_SUMMARY_CHARS) {
+    const flat = text
+        .replace(/^#{1,6}\s*/gm, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return flat.length <= max ? flat : `${flat.slice(0, max - 1)}…`;
+}
+/**
+ * Compact memory block for SessionStart: always-apply preferences + one-line
+ * recent summaries + a pointer to the pull tools. Target size: <1.5KB.
+ */
+export function buildStartupBlock(projectId) {
+    const prefs = getPreferences(projectId);
+    const summaries = getRecentSummaries(projectId, STARTUP_SUMMARY_LIMIT);
+    let text = "";
+    if (prefs.length > 0) {
+        text += '<user-preferences instruction="always-apply">\n';
+        text += "以下のユーザー設定は常に従ってください。\n";
+        for (const p of prefs)
+            text += `- ${p.key}: ${p.value}\n`;
+        text += "</user-preferences>\n";
+    }
+    if (summaries.length > 0) {
+        text += '\n<memory-context instruction="reference-only">\n';
+        text += "直近セッションの1行要約です。背景知識として参照する程度に留めてください。\n";
+        for (const s of summaries) {
+            text += `- [${s.created_at.split("T")[0]}] ${oneLine(s.summary)}\n`;
+        }
+        text += "</memory-context>\n";
+    }
+    if (text) {
+        text +=
+            "\n<memory-pull>\n過去の会話・決定・教訓の詳細が必要になったときは、memory_recall / memory_search（MCPツール）または memory-recall スキルで明示的に取得してください。\n</memory-pull>";
+    }
+    return text.trim();
+}
 export async function buildMemoryBlock(projectId, query, topK = 5) {
     const prefs = getPreferences(projectId);
     const summaries = getRecentSummaries(projectId, 5);

package/dist/core/vector-memory.js

@@ -5,7 +5,7 @@
 // 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";
+import { sqlite, transaction } from "./db.js";
 function jsonArr(v) {
     return v && v.length ? JSON.stringify(v) : null;
 }
@@ -38,7 +38,7 @@ export function saveChunks(chunks) {
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
     const insertFts = sqlite.prepare("INSERT INTO chunks_fts(chunk_id, text) VALUES (?, ?)");
     const ids = [];
-    const tx = sqlite.transaction(() => {
+    transaction(() => {
         for (const chunk of chunks) {
             const res = insertVec.run(Buffer.from(chunk.embedding.buffer), chunk.projectId);
             const vecRowid = res.lastInsertRowid;
@@ -49,7 +49,6 @@ export function saveChunks(chunks) {
             ids.push(id);
         }
     });
-    tx();
     return ids;
 }
 const CHUNK_COLS = `c.id, c.session_id, c.project_id, c.user_text, c.assistant_text,
@@ -146,25 +145,43 @@ export function deleteChunksBySession(sessionId) {
     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(() => {
+    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. */
+/**
+ * Soft-delete chunks by id (memory_forget / cleanse). Returns the number
+ * tombstoned. The metadata row keeps deleted_at (text stays recoverable), but
+ * the vec0 and FTS rows are removed outright: searchSimilar picks its top-k
+ * inside vec_chunks before the tombstone JOIN, so leftover vectors would eat
+ * k-slots and push live chunks out of the results.
+ */
 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 = ?
+    const rows = sqlite
+        .prepare(`SELECT id, vec_rowid FROM conversation_chunks
        WHERE id IN (${placeholders}) AND deleted_at IS NULL`)
-        .run(new Date().toISOString(), ...ids);
-    return res.changes;
+        .all(...ids);
+    if (rows.length === 0)
+        return 0;
+    const deleteVec = sqlite.prepare("DELETE FROM vec_chunks WHERE rowid = ?");
+    const deleteFts = sqlite.prepare("DELETE FROM chunks_fts WHERE chunk_id = ?");
+    const tombstone = sqlite.prepare("UPDATE conversation_chunks SET deleted_at = ? WHERE id = ?");
+    const now = new Date().toISOString();
+    transaction(() => {
+        for (const row of rows) {
+            deleteVec.run(row.vec_rowid);
+            deleteFts.run(row.id);
+            tombstone.run(now, row.id);
+        }
+    });
+    return rows.length;
 }
 export function getChunkCount(projectId) {
     const row = sqlite

package/dist/mcp/server.js

@@ -220,7 +220,7 @@ const TOOLS = [
         },
     },
 ];
-const server = new Server({ name: "claw-memory", version: "0.1.0" }, { capabilities: { tools: {} } });
+const server = new Server({ name: "claw-memory", version: "0.3.0" }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const name = req.params.name;

package/dist/ui/server.js

@@ -31,7 +31,7 @@ export function buildUiApp() {
     // cheap, I/O-free change signal — no client-side polling required.
     app.get("/api/events", (c) => {
         return streamSSE(c, async (stream) => {
-            const dataVersion = () => sqlite.pragma("data_version", { simple: true });
+            const dataVersion = () => sqlite.prepare("PRAGMA data_version").get().data_version;
             let last = dataVersion();
             await stream.writeSSE({ event: "ready", data: String(last) });
             while (!stream.closed && !stream.aborted) {

package/hooks/claw-hook.sh

@@ -4,18 +4,42 @@
 #   mcp:    claw-hook.sh mcp                      (stdio MCP server)
 # Prefers a globally installed `claw-memory`; falls back to npx. stdin/stdout are
 # inherited so hook input and MCP stdio pass through. Never blocks a session:
-# hook failures are swallowed, but `mcp` must exec directly (no error masking).
+# hook failures don't propagate, but they are LOGGED (not swallowed) — a silent
+# 2>/dev/null here once hid a 3-week total outage. `mcp` execs directly.
 set -euo pipefail
 
-run() {
-  if command -v claw-memory >/dev/null 2>&1; then
-    exec claw-memory "$@"
-  fi
-  exec npx -y @nogataka/claw-memory@latest "$@"
-}
+HOOK_ERR_LOG="${CLAW_MEMORY_DIR:-$HOME/.claw-memory}/logs/hook-error.log"
+
+# node:sqlite still carries an ExperimentalWarning on stderr; silence it so the
+# error log only contains real failures.
+export NODE_OPTIONS="${NODE_OPTIONS:+$NODE_OPTIONS }--disable-warning=ExperimentalWarning"
+
+# Resolve the binary into $CMD (array, npx form needs multiple words).
+if command -v claw-memory >/dev/null 2>&1; then
+  CMD=(claw-memory)
+else
+  CMD=(npx -y @nogataka/claw-memory@latest)
+fi
 
 if [ "${1:-}" = "mcp" ]; then
-  run "$@"
+  exec "${CMD[@]}" "$@"
+fi
+
+mkdir -p "$(dirname "$HOOK_ERR_LOG")" 2>/dev/null || true
+# Capture stderr synchronously to a temp file, then append it timestamped.
+# (An async process-substitution logger here raced script exit and dropped
+# lines — exactly the silent-failure mode this log exists to prevent.)
+ERR_TMP="$(mktemp "${TMPDIR:-/tmp}/claw-hook-err.XXXXXX" 2>/dev/null)" || ERR_TMP=""
+if [ -n "$ERR_TMP" ]; then
+  "${CMD[@]}" "$@" 2>"$ERR_TMP" || true
+  if [ -s "$ERR_TMP" ]; then
+    TS="$(date '+%Y-%m-%dT%H:%M:%S%z')"
+    while IFS= read -r line || [ -n "$line" ]; do
+      printf '%s %s\n' "$TS" "$line"
+    done < "$ERR_TMP" >> "$HOOK_ERR_LOG" || true
+  fi
+  rm -f "$ERR_TMP"
 else
-  run "$@" 2>/dev/null || true
+  # mktemp failed; still never silent — append raw stderr directly.
+  "${CMD[@]}" "$@" 2>>"$HOOK_ERR_LOG" || true
 fi

package/hooks/hooks.codex.json

@@ -11,17 +11,6 @@
         ]
       }
     ],
-    "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"$CLAUDE_PLUGIN_ROOT/hooks/run-hook.cmd\" claw-hook.sh hook recall",
-            "async": false
-          }
-        ]
-      }
-    ],
     "Stop": [
       {
         "hooks": [

package/hooks/hooks.json

@@ -11,17 +11,6 @@
         ]
       }
     ],
-    "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"$CLAUDE_PLUGIN_ROOT/hooks/run-hook.cmd\" claw-hook.sh hook recall",
-            "async": false
-          }
-        ]
-      }
-    ],
     "Stop": [
       {
         "hooks": [

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@nogataka/claw-memory",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
-  "description": "Independent, in-process semantic memory MCP server (sqlite-vec + local Xenova e5) with a lightweight web viewer. No daemon, no Python. Installable as a Claude Code plugin and a Codex MCP server.",
+  "description": "Independent, in-process semantic memory MCP server (node:sqlite + sqlite-vec + local Xenova e5) with a lightweight web viewer. No daemon, no Python, no native ABI. Installable as a Claude Code plugin and a Codex MCP server.",
   "license": "MIT",
   "author": "nogataka",
   "repository": {
@@ -32,7 +32,7 @@
     "README.ja.md"
   ],
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.0.0"
   },
   "publishConfig": {
     "access": "public"
@@ -53,14 +53,12 @@
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@openai/codex-sdk": "^0.135.0",
     "@xenova/transformers": "^2.17.2",
-    "better-sqlite3": "12.8.0",
     "hono": "^4.6.0",
     "sqlite-vec": "^0.1.7-alpha.2",
     "zod": "^3.24.0"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.11",
-    "@types/node": "^22.0.0",
+    "@types/node": "^24.0.0",
     "tsx": "^4.19.0",
     "typescript": "^5.6.0"
   }