@nogataka/claw-memory 0.1.0

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "claw-memory",
+  "version": "0.1.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" },
+  "repository": "https://github.com/nogataka/claw-memory",
+  "license": "MIT",
+  "keywords": ["memory", "mcp", "context", "search", "codex"]
+}

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "claw-memory": {
+      "command": "${CLAUDE_PLUGIN_ROOT}/hooks/claw-hook.sh",
+      "args": ["mcp"]
+    }
+  }
+}

package/README.md

@@ -0,0 +1,168 @@
+# claw-memory
+
+Independent, **in-process** semantic memory for any MCP-capable agent (Claude Code, Codex, …).
+No daemon, no Python, no external vector DB.
+
+- **Storage**: `better-sqlite3` + `sqlite-vec` (vectors live *inside* the SQLite file)
+- **Embeddings**: local `Xenova/multilingual-e5-small` (384-dim, multilingual, offline)
+- **Search**: semantic (cosine KNN, per-project metadata filter) + FTS5 keyword fallback
+- **Write**: LLM distillation of session transcripts → summary + preferences + chunks
+- **Viewer**: optional, on-demand lightweight web UI (no framework, no build)
+
+Data lives at `~/.claw-memory/memory.db` (override with `CLAW_MEMORY_DIR`). Completely
+separate from any other app.
+
+## Install
+
+Published as `@nogataka/claw-memory`. Install once globally so hooks/MCP resolve fast
+(otherwise they fall back to `npx`):
+
+```bash
+npm install -g @nogataka/claw-memory
+```
+
+First run downloads the e5 model (~100 MB, cached in `~/.cache`).
+
+### Claude Code (plugin)
+
+```
+/plugin marketplace add nogataka/claw-memory
+/plugin install claw-memory
+```
+
+Restart Claude Code. This auto-registers the MCP server and the hooks
+(SessionStart/UserPromptSubmit → recall injection, Stop → auto-distill).
+No manual setup. (Not using the plugin? Run `claw-memory install --claude-code`
+to merge the MCP server + hooks into `~/.claude/settings.json`.)
+
+### Codex (installer)
+
+Codex has no third-party plugin marketplace, so register via the installer:
+
+```bash
+claw-memory install --codex      # adds [mcp_servers.claw-memory] to ~/.codex/config.toml
+                                 # + memory-recall skill + AGENTS.md recall instruction
+```
+
+Restart Codex. Recall is available via the `memory_recall` MCP tool (the AGENTS.md
+note tells the agent to call it at session start). **Auto-distill is manual on Codex**
+(no notify hook); run periodically:
+
+```bash
+claw-memory distill-codex --recent     # distill recent Codex sessions (watermark-deduped)
+claw-memory distill-codex --all        # backfill everything
+```
+
+Remove with `claw-memory uninstall --codex` (or `--claude-code`).
+
+### From source
+
+```bash
+cd claw-memory
+npm install      # builds native better-sqlite3 / sqlite-vec
+npm run build    # tsc -> dist/
+```
+
+## MCP tools
+
+| Tool | Purpose |
+|------|---------|
+| `memory_recall(query, cwd?, topK?)` | Ready-to-read context block: preferences + summaries + similar past conversations |
+| `memory_search(query, cwd?, limit?)` | Token-efficient hit index (id + title + date) |
+| `memory_get(ids)` | Full text for given chunk ids |
+| `memory_remember(text, cwd?, sessionId?)` | Store a free-text note |
+| `memory_distill(cwd, sessionId? \| transcriptPath?)` | Summarize a session into memory (needs LLM creds) |
+| `memory_get_preferences(cwd?)` | List stored preferences |
+| `memory_search_logs(query, sources?, projectPath?, startDate?, endDate?, limit?, offset?)` | Full-text search over RAW Claude Code + Codex transcripts (second memory source; finds undistilled history) |
+| `memory_forget(ids)` | Soft-delete chunks (hidden from search/recall/viewer) |
+
+`memory_distill` uses an LLM (see *LLM backend* below). `memory_search_logs` reads
+`~/.claude/projects` and `~/.codex/sessions` directly. All other tools are fully local.
+
+## LLM backend (distill only)
+
+distill needs a single tool-less completion, selectable via `CLAW_MEMORY_LLM_BACKEND`:
+
+| Backend | Auth | Notes |
+|---------|------|-------|
+| `agent-sdk` (default) | Claude Code CLI login (Claude Pro/Max/Team/Enterprise) | zero-config, no API key |
+| `codex-sdk` | Codex CLI login (ChatGPT/Codex plan) | `@openai/codex-sdk`, no API key; requires Codex CLI. Model via `CLAW_MEMORY_CODEX_MODEL` |
+| `anthropic` | `ANTHROPIC_API_KEY` (`ANTHROPIC_BASE_URL` optional) | plain Messages API |
+| `openai-compatible` | `CLAW_MEMORY_OPENAI_API_KEY` + `CLAW_MEMORY_OPENAI_BASE_URL` | Gemini / OpenRouter / LM Studio (set `CLAW_MEMORY_MODEL`) |
+
+```bash
+export CLAW_MEMORY_LLM_BACKEND=codex-sdk    # use the Codex subscription for distill
+```
+
+Both SDK backends reuse a subscription login (no API key). Tier routing (cheap models for
+simple work): `CLAW_MEMORY_TIER_SMART` / `_SUMMARY` / `_SIMPLE`, else `AGENT_SDK_MODEL` /
+`CLAW_MEMORY_MODEL` (agent-sdk/anthropic default `claude-sonnet-4-5`; codex-sdk uses the Codex default).
+
+## Automatic capture & recall (Claude Code hooks)
+
+No daemon — hooks spawn the CLI per event. Register in `~/.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "SessionStart":     [{ "hooks": [{ "type": "command", "command": "/Volumes/Data/dev/claw-memory/hooks/claw-hook.sh recall" }] }],
+    "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "/Volumes/Data/dev/claw-memory/hooks/claw-hook.sh recall" }] }],
+    "Stop":             [{ "hooks": [{ "type": "command", "command": "/Volumes/Data/dev/claw-memory/hooks/claw-hook.sh distill" }] }]
+  }
+}
+```
+
+- **recall** (SessionStart / UserPromptSubmit): prints the memory block to stdout → injected into context. Preferences + recent summaries, plus semantically similar past conversations when the prompt is present.
+- **distill** (Stop): detached, fire-and-forget. Incremental via a watermark (skips sessions with no new content). Honors `CLAW_MEMORY_EXCLUDED_PROJECTS` and `<private>…</private>`.
+
+## Register with an agent
+
+### Claude Code — `.mcp.json` (project root) or `~/.claude.json`
+
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "node",
+      "args": ["/Volumes/Data/dev/claw-memory/dist/cli.js", "mcp"]
+    }
+  }
+}
+```
+
+### Codex — `~/.codex/config.toml`
+
+```toml
+[mcp_servers.memory]
+command = "node"
+args = ["/Volumes/Data/dev/claw-memory/dist/cli.js", "mcp"]
+```
+
+Then add to your `CLAUDE.md` / `AGENTS.md`:
+> 会話の冒頭で `memory_recall` を呼び、過去の文脈と好みを取得すること。
+
+## Memory viewer
+
+```bash
+npm run ui            # http://localhost:4319 , opens browser
+# or
+node dist/cli.js ui --port 4319 --open
+```
+
+Read-only. Browse projects, session summaries, conversation chunks and preferences.
+Start it only when you want to inspect; nothing runs in the background otherwise.
+
+## CLI
+
+```bash
+node dist/cli.js mcp                                   # stdio MCP server
+node dist/cli.js ui [--port N] [--open]                # viewer
+node dist/cli.js distill --cwd <dir> --session <id>    # distill a CC session
+node dist/cli.js remember --cwd <dir> "a note"         # store a note
+```
+
+## Notes
+
+- `better-sqlite3` / `sqlite-vec` are native; rebuild on Node ABI changes (`npm rebuild`).
+- 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).

package/dist/cli.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+// src/cli.ts
+//
+// claw-memory CLI. Subcommands:
+//   mcp                       start the stdio MCP server (what agents spawn)
+//   ui [--port N] [--open]    start the on-demand memory viewer
+//   distill --cwd P --session ID [--path FILE]
+//   remember --cwd P "text"
+function getFlag(args, name) {
+    const i = args.indexOf(`--${name}`);
+    return i >= 0 ? args[i + 1] : undefined;
+}
+function hasFlag(args, name) {
+    return args.includes(`--${name}`);
+}
+async function main() {
+    const [cmd, ...rest] = process.argv.slice(2);
+    switch (cmd) {
+        case "mcp": {
+            const { runMcpServer } = await import("./mcp/server.js");
+            await runMcpServer();
+            return; // stays alive on stdio
+        }
+        case "ui": {
+            const { runUiServer } = await import("./ui/server.js");
+            const port = Number(getFlag(rest, "port") ?? process.env.CLAW_MEMORY_UI_PORT ?? 4319);
+            runUiServer(port, hasFlag(rest, "open"));
+            return;
+        }
+        case "distill": {
+            const { getOrCreateProjectByPath } = await import("./core/projects.js");
+            const { distill } = await import("./core/distill.js");
+            const { resolveSessionJsonl } = await import("./core/transcript.js");
+            const cwd = getFlag(rest, "cwd") ?? process.cwd();
+            const session = getFlag(rest, "session") ?? "";
+            const path = getFlag(rest, "path") ?? (session ? resolveSessionJsonl(cwd, session) : undefined);
+            if (!path)
+                throw new Error("distill requires --session or --path");
+            const project = getOrCreateProjectByPath(cwd);
+            if (hasFlag(rest, "if-stale")) {
+                // Incremental mode (used by hooks): skip if the transcript hasn't grown
+                // since last distill; stamp the watermark on success.
+                const { statSync } = await import("node:fs");
+                const { shouldDistill, markDistilled } = await import("./core/watermark.js");
+                let mtimeMs = 0;
+                try {
+                    mtimeMs = statSync(path).mtimeMs;
+                }
+                catch {
+                    console.log('{"skipped":"no transcript"}');
+                    process.exit(0);
+                }
+                if (!shouldDistill(path, mtimeMs)) {
+                    console.log('{"skipped":"up-to-date"}');
+                    process.exit(0);
+                }
+                const res = await distill({ projectId: project.id, sessionId: session || path, transcriptPath: path });
+                markDistilled(path, mtimeMs);
+                console.log(JSON.stringify(res, null, 2));
+                process.exit(0);
+            }
+            const res = await distill({ projectId: project.id, sessionId: session || path, transcriptPath: path });
+            console.log(JSON.stringify(res, null, 2));
+            process.exit(0);
+        }
+        case "hook": {
+            const { readStdinJson, runDistillHook, runRecallHook } = await import("./core/hooks.js");
+            const mode = rest[0]; // "distill" | "recall"
+            const input = await readStdinJson();
+            if (mode === "distill") {
+                runDistillHook(input);
+                process.exit(0);
+            }
+            if (mode === "recall") {
+                await runRecallHook(input);
+                process.exit(0);
+            }
+            throw new Error("hook requires a mode: distill | recall");
+        }
+        case "inject-recall": {
+            // Convenience alias for `hook recall` (SessionStart/UserPromptSubmit).
+            const { readStdinJson, runRecallHook } = await import("./core/hooks.js");
+            await runRecallHook(await readStdinJson());
+            process.exit(0);
+        }
+        case "install": {
+            const target = hasFlag(rest, "claude-code") ? "claude" : "codex";
+            if (target === "codex") {
+                const { installCodex } = await import("./core/installer/codex.js");
+                console.log("claw-memory installed for Codex:\n  " + installCodex().join("\n  "));
+                console.log("\n注意: Codex を再起動してください。自動 distill は手動 (`claw-memory distill-codex --recent`)。");
+            }
+            else {
+                const { installClaude } = await import("./core/installer/claude.js");
+                console.log("claw-memory installed for Claude Code (manual):\n  " + installClaude().join("\n  "));
+                console.log("\n注意: Claude Code を再起動してください。プラグイン利用時はこの手動設定は不要です。");
+            }
+            process.exit(0);
+        }
+        case "uninstall": {
+            const target = hasFlag(rest, "claude-code") ? "claude" : "codex";
+            if (target === "codex") {
+                const { uninstallCodex } = await import("./core/installer/codex.js");
+                console.log("removed:\n  " + uninstallCodex().join("\n  "));
+            }
+            else {
+                const { uninstallClaude } = await import("./core/installer/claude.js");
+                console.log("removed:\n  " + uninstallClaude().join("\n  "));
+            }
+            process.exit(0);
+        }
+        case "distill-codex": {
+            const { listCodexSessionFiles, codexSessionId } = await import("./core/logsearch/recent.js");
+            const { parseCodexSession } = await import("./core/logsearch/parse.js");
+            const { distill } = await import("./core/distill.js");
+            const { getOrCreateProjectByPath } = await import("./core/projects.js");
+            const { shouldDistill, markDistilled } = await import("./core/watermark.js");
+            const { isExcludedPath } = await import("./core/excludes.js");
+            const { statSync, readFileSync } = await import("node:fs");
+            const all = hasFlag(rest, "all");
+            const limit = Number(getFlag(rest, "limit") ?? (all ? 100000 : 20));
+            const files = (await listCodexSessionFiles()).slice(0, limit);
+            let distilled = 0, skipped = 0, failed = 0;
+            for (const f of files) {
+                let mtimeMs = 0;
+                try {
+                    mtimeMs = statSync(f.path).mtimeMs;
+                }
+                catch {
+                    continue;
+                }
+                if (!shouldDistill(f.path, mtimeMs)) {
+                    skipped++;
+                    continue;
+                }
+                let cwd = process.cwd();
+                try {
+                    const c = parseCodexSession(readFileSync(f.path, "utf-8")).cwd;
+                    if (c)
+                        cwd = c;
+                }
+                catch { /* keep default */ }
+                if (isExcludedPath(cwd)) {
+                    markDistilled(f.path, mtimeMs);
+                    skipped++;
+                    continue;
+                }
+                const project = getOrCreateProjectByPath(cwd);
+                try {
+                    const res = await distill({ projectId: project.id, sessionId: codexSessionId(f.path), transcriptPath: f.path });
+                    markDistilled(f.path, mtimeMs);
+                    if (res.skipped)
+                        skipped++;
+                    else
+                        distilled++;
+                }
+                catch (e) {
+                    failed++;
+                    console.error(`distill failed ${f.path}: ${String(e)}`);
+                }
+            }
+            console.log(JSON.stringify({ scanned: files.length, distilled, skipped, failed }, null, 2));
+            process.exit(0);
+        }
+        case "remember": {
+            const { getOrCreateProjectByPath } = await import("./core/projects.js");
+            const { rememberText } = await import("./core/distill.js");
+            const cwd = getFlag(rest, "cwd") ?? process.cwd();
+            const text = rest.filter((a) => !a.startsWith("--") && a !== cwd).join(" ").trim();
+            if (!text)
+                throw new Error("remember requires text");
+            const project = getOrCreateProjectByPath(cwd);
+            const id = await rememberText({ projectId: project.id, sessionId: "manual", text });
+            console.log(`saved id=${id}`);
+            process.exit(0);
+        }
+        case "search-logs": {
+            const { searchLogs } = await import("./core/logsearch/search.js");
+            // Positional query = tokens that are neither a --flag nor a flag's value.
+            const positionals = [];
+            for (let i = 0; i < rest.length; i++) {
+                if (rest[i].startsWith("--")) {
+                    i++; // skip this flag's value
+                    continue;
+                }
+                positionals.push(rest[i]);
+            }
+            const query = positionals.join(" ").trim();
+            if (!query)
+                throw new Error("search-logs requires a query");
+            const sourcesArg = getFlag(rest, "source");
+            const out = await searchLogs({
+                query,
+                sources: sourcesArg ? sourcesArg.split(",") : undefined,
+                projectPath: getFlag(rest, "project"),
+                startDate: getFlag(rest, "start"),
+                endDate: getFlag(rest, "end"),
+                limit: Number(getFlag(rest, "limit") ?? 20),
+                offset: Number(getFlag(rest, "offset") ?? 0),
+            });
+            console.log(JSON.stringify(out, null, 2));
+            process.exit(0);
+        }
+        default:
+            console.error("Usage: claw-memory <command>\n" +
+                "  mcp                       start stdio MCP server\n" +
+                "  ui [--port N] [--open]    start memory viewer\n" +
+                "  distill --cwd P --session ID [--path FILE] [--if-stale]\n" +
+                "  distill-codex [--recent] [--limit N] [--all]   distill recent Codex sessions\n" +
+                "  remember --cwd P \"text\"\n" +
+                "  search-logs \"query\" [--source claude-code,codex] [--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" +
+                "  inject-recall             alias for `hook recall`\n" +
+                "  install [--codex|--claude-code]     register MCP + hooks (default: codex)\n" +
+                "  uninstall [--codex|--claude-code]   remove claw-memory config");
+            process.exit(cmd ? 1 : 0);
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+export {};

package/dist/core/config.js

@@ -0,0 +1,14 @@
+// src/core/config.ts
+import { sqlite } from "./db.js";
+export function getConfig(key) {
+    const row = sqlite
+        .prepare("SELECT value FROM app_config WHERE key = ?")
+        .get(key);
+    return row?.value;
+}
+export function setConfig(key, value) {
+    sqlite
+        .prepare(`INSERT INTO app_config(key, value, updated_at) VALUES (?, ?, datetime('now'))
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = datetime('now')`)
+        .run(key, value);
+}

package/dist/core/db.js

@@ -0,0 +1,92 @@
+// 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";
+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);
+sqlite.exec(`
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT NOT NULL UNIQUE,
+    created_at TEXT NOT NULL,
+    last_accessed_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS session_summaries (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE TABLE IF NOT EXISTS user_preferences (
+    id TEXT PRIMARY KEY,
+    project_id TEXT,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE TABLE IF NOT EXISTS app_config (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE TABLE IF NOT EXISTS conversation_chunks (
+    id TEXT PRIMARY KEY,
+    vec_rowid INTEGER NOT NULL,
+    project_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    user_text TEXT NOT NULL,
+    assistant_text TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS distill_watermarks (
+    path TEXT PRIMARY KEY,
+    mtime_ms INTEGER NOT NULL,
+    distilled_at TEXT NOT NULL
+  );
+`);
+// --- Additive, migration-less schema evolution -----------------------------
+// New columns are added with try/catch so existing ~/.claw-memory/memory.db
+// files keep working (SQLite ALTER TABLE ADD COLUMN can't be IF NOT EXISTS).
+for (const col of [
+    "obs_type TEXT",
+    "concepts TEXT",
+    "files_read TEXT",
+    "files_modified TEXT",
+    "deleted_at TEXT",
+]) {
+    try {
+        sqlite.exec(`ALTER TABLE conversation_chunks ADD COLUMN ${col}`);
+    }
+    catch {
+        // column already exists
+    }
+}
+// vec0 virtual table — embedding + project_id metadata column so KNN can filter
+// by project inside the MATCH query (no post-filter loss).
+sqlite.exec(`
+  CREATE VIRTUAL TABLE IF NOT EXISTS vec_chunks USING vec0(
+    embedding float[384] distance_metric=cosine,
+    project_id text
+  );
+`);
+// FTS5 keyword index over chunk text (claude-mem-style fallback when the query
+// is keyword-ish and semantic similarity is weak). Content-less; chunk_id links
+// back to conversation_chunks.id. Uses the trigram tokenizer: it matches
+// case-insensitive substrings (>=3 chars), which is essential for Japanese text
+// that has no word spaces and for Latin words glued to CJK (e.g. "TypeScriptの").
+sqlite.exec(`
+  CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+    chunk_id UNINDEXED,
+    text,
+    tokenize = 'trigram'
+  );
+`);

package/dist/core/distill.js

@@ -0,0 +1,146 @@
+// src/core/distill.ts
+//
+// Write path: distill a conversation into a 1-2 sentence summary + user
+// preferences + embedded conversation chunks. Mirrors agent-claw's summarize
+// pipeline, minus the HTTP layer.
+import { complete } from "./llm.js";
+import { embedPassage } from "./embeddings.js";
+import { addSessionSummary, setPreference } from "./memory.js";
+import { saveChunks, deleteChunksBySession, chunkExists, } from "./vector-memory.js";
+import { loadTranscript } from "./transcript.js";
+import { stripPrivate } from "./private.js";
+import { log } from "./logger.js";
+const MIN_MESSAGES = 2;
+const MIN_TEXT_LENGTH = 100;
+const MAX_CHARS_PER_MESSAGE = 500;
+const OBS_TYPES = ["discovery", "bugfix", "feature", "decision", "change", "other"];
+const PROMPT = (transcript) => `以下の会話を分析して JSON で回答してください。
+
+1. summary: 会話の構造化要約。会話と同じ言語で、次の節を含む簡潔なMarkdown:
+   "### 依頼" / "### 調査・判明" / "### 完了" / "### 次の一手"（該当が無い節は省略可）。
+2. obs_type: この会話の主目的を1つ選ぶ: ${OBS_TYPES.join(" | ")}
+3. concepts: 主要トピック・技術キーワードの配列（3〜8個程度）。
+4. files_read: 会話中で読んだ/参照したファイルパスの配列（無ければ空配列）。
+5. files_modified: 会話中で作成/編集したファイルパスの配列（無ければ空配列）。
+6. preferences: ユーザーの設定や好みが読み取れた場合のみ。
+   key は必ず次のいずれか（該当しなければ出さない）:
+   language | response_style | detail_level | code_style | framework | tone | tools
+   変更がなければ空配列。
+
+JSON のみ回答:
+{"summary": "...", "obs_type": "...", "concepts": ["..."], "files_read": ["..."], "files_modified": ["..."], "preferences": [{"key": "...", "value": "..."}]}
+
+<conversation>
+${transcript}
+</conversation>`;
+export async function distill(input) {
+    const loaded = input.messages ??
+        (input.transcriptPath ? loadTranscript(input.transcriptPath) : []);
+    // Drop <private>…</private> spans before anything is persisted or sent to the LLM.
+    const messages = loaded
+        .map((m) => ({ ...m, text: stripPrivate(m.text) }))
+        .filter((m) => m.text.trim());
+    if (messages.length < MIN_MESSAGES) {
+        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)}`)
+        .join("\n");
+    if (transcript.length < MIN_TEXT_LENGTH) {
+        return { skipped: true, reason: "too short" };
+    }
+    // --- LLM: summary + preferences (single tool-less turn) ---
+    const responseText = await complete({
+        prompt: PROMPT(transcript),
+        tier: "summary",
+    });
+    const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        throw new Error("Failed to parse distill JSON response");
+    const result = JSON.parse(jsonMatch[0]);
+    if (result.summary) {
+        addSessionSummary(input.projectId, input.sessionId, result.summary);
+    }
+    if (Array.isArray(result.preferences)) {
+        for (const pref of result.preferences) {
+            if (pref.key && pref.value) {
+                setPreference(input.projectId, pref.key, pref.value);
+            }
+        }
+    }
+    // Session-level structured metadata applied to every chunk of this session.
+    const obsType = result.obs_type && OBS_TYPES.includes(result.obs_type)
+        ? result.obs_type
+        : null;
+    const concepts = (result.concepts ?? []).map(String).filter(Boolean);
+    const filesRead = (result.files_read ?? []).map(String).filter(Boolean);
+    const filesModified = (result.files_modified ?? []).map(String).filter(Boolean);
+    // --- Vector memory: re-chunk this session (idempotent) ---
+    let chunkCount = 0;
+    try {
+        deleteChunksBySession(input.sessionId);
+        const pairs = [];
+        for (let i = 0; i < messages.length; i++) {
+            const m = messages[i];
+            if (m.role === "user" && m.text.trim()) {
+                const next = messages[i + 1];
+                pairs.push({
+                    userText: m.text.slice(0, 500),
+                    assistantText: next?.role === "assistant" ? next.text.slice(0, 500) : "",
+                });
+            }
+        }
+        if (pairs.length > 0) {
+            const toSave = [];
+            for (const p of pairs) {
+                // Cross-session dedup: skip pairs already stored verbatim.
+                if (chunkExists(input.projectId, p.userText, p.assistantText))
+                    continue;
+                const embedding = await embedPassage(`User: ${p.userText}\nAssistant: ${p.assistantText}`);
+                toSave.push({
+                    projectId: input.projectId,
+                    sessionId: input.sessionId,
+                    userText: p.userText,
+                    assistantText: p.assistantText,
+                    embedding,
+                    obsType,
+                    concepts,
+                    filesRead,
+                    filesModified,
+                });
+            }
+            if (toSave.length > 0)
+                saveChunks(toSave);
+            chunkCount = toSave.length;
+        }
+    }
+    catch (err) {
+        console.error("[claw-memory] chunk embed failed:", err);
+    }
+    log("distill", {
+        projectId: input.projectId,
+        sessionId: input.sessionId,
+        obsType,
+        chunks: chunkCount,
+        preferences: result.preferences?.length ?? 0,
+    });
+    return {
+        summary: result.summary,
+        preferencesCount: result.preferences?.length ?? 0,
+        chunks: chunkCount,
+    };
+}
+/** Store a single free-text note as an embedded chunk (memory_remember). */
+export async function rememberText(args) {
+    const embedding = await embedPassage(args.text);
+    const [id] = saveChunks([
+        {
+            projectId: args.projectId,
+            sessionId: args.sessionId,
+            userText: args.text.slice(0, 500),
+            assistantText: "",
+            embedding,
+        },
+    ]);
+    return id;
+}