@nogataka/claw-memory 0.1.3 → 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

@@ -2,6 +2,8 @@
 
 [English](README.md) | **日本語**
 
+![claw-memory メモリビューア](docs/screenshot.png)
+
 **AI コーディングエージェント（Claude Code / Codex）のためのローカル完結型・長期記憶。**
 エージェントが過去のセッション・あなたの好み・以前の決定事項を記憶し、記録済みの全
 トランスクリプトを横断検索できます。デーモン不要、Python 不要、外部ベクトル DB 不要。
@@ -12,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 の生ログ全文検索
 - **自動取り込み**: フックで終了済みセッションを蒸留し、新しいセッションへ関連記憶を注入
@@ -42,11 +44,16 @@ npm install -g @nogataka/claw-memory
 | ソース | 内容 | ツール |
 |--------|------|--------|
 | **蒸留 DB** | LLM がセッションを要約 → 要約・好み・構造化メタデータ付きの埋め込みチャンク。セマンティック検索可能。 | `memory_recall`, `memory_search`, `memory_get` |
-| **生ログ検索** | 実際の Claude Code（`~/.claude/projects`）/ Codex（`~/.codex/sessions`）ログを全文検索。蒸留していないセッションも対象。 | `memory_search_logs` |
+| **生ログ検索** | 実際の Claude Code（`~/.claude/projects`）/ Codex（`~/.codex/sessions`）/ **ChatGPT web** エクスポート（`conversations.json`）ログを全文検索。蒸留していないセッションも対象。 | `memory_search_logs` |
 
 蒸留 DB は整理済みで高速に想起でき、生ログ検索は claw-memory 導入前を含め「いつか話した
 こと」を必ず見つけられるセーフティネットです。
 
+**ChatGPT web** の会話は OpenAI サーバー側にありローカルに残らないため、公式エクスポートから読み込みます。
+ChatGPT → Settings → **Data controls** → **Export data** でダウンロードし、解凍して `conversations.json` を
+`~/.claw-memory/chatgpt/` に置く（または `CLAW_MEMORY_CHATGPT_EXPORT` でファイル/フォルダを指定）だけで、
+他ログと同様に検索でき、`claw-memory distill-chatgpt` で専用 `chatgpt` プロジェクトとして意味 DB にも取り込めます。
+
 ### 2. 自動取り込み（distill）
 
 セッション終了時、トランスクリプトを次の形に蒸留します。
@@ -94,7 +101,19 @@ npm install -g @nogataka/claw-memory
 
 ビルド不要・読み取り専用のビューア（`claw-memory ui`）。プロジェクト・要約・チャンク
 （メタデータ付き）・好みを閲覧でき、生ログ検索も実行できます。SSE で開いている間は自動
-更新。起動した時だけ動きます。
+更新。起動した時だけ動きます。抽出されたレッスンをレビュー・承認・編集できる **Lessons**
+タブも備えています。
+
+### 8. 再利用可能なレッスン
+
+過去ログをそのまま検索するだけでなく、claw-memory は AI コーディングセッションを
+**再利用可能なレッスン**へと蒸留します。プロジェクト固有の制約、デバッグパターン、設計
+判断、ユーザーの開発方針などの、実行可能で抽象化された知識です。レッスンは通常の要約と
+同時に抽出され（追加の LLM 呼び出しなし）、ローカルに保存され、同じローカルモデルで埋め込
+まれ、（承認後のみ）類似タスク時に想起されます。各レッスンは `scope`・`confidence`・
+`applies_when` / `avoid_when` と、ライフサイクル（candidate → approved → archived /
+superseded）を持ち、重複・矛盾検出と時間経過による confidence 減衰を備えます。raw ログは
+根拠として保持しつつ、通常の想起では簡潔で再利用可能なレッスンを優先します。
 
 ---
 
@@ -125,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` が見えるかどうかで行えます。
 
@@ -146,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
 
@@ -178,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` バイナリを公開
 ```
@@ -195,11 +215,17 @@ npm link             # 任意: `claw-memory` バイナリを公開
 | `memory_remember(text, cwd?, sessionId?)` | フリーテキストのメモを永続保存。 |
 | `memory_distill(cwd, sessionId? \| transcriptPath?)` | セッションを要約して記憶化（LLM バックエンドが必要）。 |
 | `memory_get_preferences(cwd?)` | プロジェクトの保存済み好みを一覧。 |
-| `memory_search_logs(query, sources?, projectPath?, startDate?, endDate?, limit?, offset?)` | Claude Code + Codex の生ログを全文検索。 |
+| `memory_search_logs(query, sources?, projectPath?, startDate?, endDate?, limit?, offset?)` | Claude Code + Codex + ChatGPT-web の生ログを全文検索（`sources`: `claude-code` / `codex` / `chatgpt-web`）。 |
 | `memory_forget(ids)` | チャンクをソフト削除（検索 / recall / ビューアから除外）。 |
+| `lesson_search(query, cwd?, limit?)` | 承認済みレッスンを関連度 + scope + confidence で検索。 |
+| `lesson_inject(query, cwd?, limit?)` | 同上を `<relevant-lessons>` ブロックとして返す。 |
+| `lesson_get(lesson_id)` | レッスン1件の詳細（全フィールド + 履歴 + リンク）。 |
+| `lesson_extract(cwd, sessionId? \| transcriptPath?)` | セッションから専用のレッスン抽出（LLM 必要）。 |
+| `lesson_approve / lesson_reject / lesson_archive(lesson_id, reason?)` | ステータス遷移。 |
+| `lesson_supersede(old_lesson_id, new_lesson_id)` | 古いレッスンを新しいもので置き換え。 |
 
-`memory_distill`（LLM）と `memory_search_logs`（`~/.claude/projects`・`~/.codex/sessions`
-を直接読む）以外は完全ローカルで動作します。
+`memory_distill` / `lesson_extract`（LLM）と `memory_search_logs`
+（`~/.claude/projects`・`~/.codex/sessions` を直接読む）以外は完全ローカルで動作します。
 
 ---
 
@@ -218,6 +244,12 @@ npm link             # 任意: `claw-memory` バイナリを公開
 | `CLAW_MEMORY_EXCLUDED_PROJECTS` | — | 記録・想起しないパス部分文字列（カンマ/コロン区切り）。 |
 | `MEMORY_SIMILARITY_MAX_DISTANCE` | `0.6` | セマンティックヒットの最大コサイン距離（小さいほど厳格）。 |
 | `CLAW_MEMORY_UI_PORT` | `4319` | ビューアのポート。 |
+| `LESSON_RECALL_LIMIT` | `3` | recall ブロックに注入する承認済みレッスン数（`0` で無効）。 |
+| `CLAW_MEMORY_LESSON_DEDICATED` | — | `1` で専用の高品質レッスン抽出パスを実行（LLM 追加呼び出し）。 |
+| `CLAW_MEMORY_LESSON_CONFLICT_LLM` | — | `1` で抽出時に LLM による矛盾検出を有効化。 |
+| `LESSON_DECAY_FACTOR` / `LESSON_STALE_DAYS` | `0.9` / `30` | `lessons decay` の減衰係数と陳腐化しきい値。 |
+| `CLAW_MEMORY_CHATGPT_EXPORT` | `~/.claw-memory/chatgpt` | ChatGPT `conversations.json` エクスポート（ファイル or `*.json` を含むフォルダ）。 |
+| `CLAW_MEMORY_CHATGPT_MAX_BYTES` | `209715200`（200 MB） | これを超える ChatGPT エクスポートはスキップ（メモリ内パースのため）。 |
 
 ### LLM バックエンド
 
@@ -241,8 +273,18 @@ claw-memory mcp                                  # stdio MCP サーバー（エ
 claw-memory ui [--port N] [--open]               # 読み取り専用 Web ビューア
 claw-memory distill --cwd P --session ID [--path FILE] [--if-stale]
 claw-memory distill-codex [--recent] [--limit N] [--all]
+claw-memory distill-chatgpt [--limit N] [--all]  # ChatGPT web エクスポートの会話を蒸留
 claw-memory remember --cwd P "メモ"
-claw-memory search-logs "クエリ" [--source claude-code,codex] [--project P]
+claw-memory lessons list [--status candidate|approved|...] [--cwd P]
+claw-memory lessons search "クエリ" [--cwd P] [--limit N]
+claw-memory lessons inject "クエリ" [--cwd P] [--limit N]
+claw-memory lessons extract --session ID [--cwd P] [--path FILE]
+claw-memory lessons approve|reject|archive <lesson_id> [--reason R]
+claw-memory lessons supersede <old_id> <new_id>
+claw-memory lessons decay [--days N] [--factor F] [--dry]
+claw-memory lessons export [--status S] [--cwd P] > bundle.json
+claw-memory lessons import bundle.json [--status S] [--cwd P]
+claw-memory search-logs "クエリ" [--source claude-code,codex,chatgpt-web] [--project P]
                                  [--start ISO] [--end ISO] [--limit N] [--offset N]
 claw-memory hook <recall|distill>               # ライフサイクルフック（JSON を stdin で受領）
 claw-memory install   [--codex | --claude-code] # MCP + フックを登録（既定: codex）
@@ -311,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

@@ -2,6 +2,8 @@
 
 **English** | [日本語](README.ja.md)
 
+![claw-memory memory viewer](docs/screenshot.png)
+
 **Local, in-process long-term memory for AI coding agents (Claude Code & Codex).**
 Your agent remembers past sessions, your preferences, and prior decisions — and can
 search every raw transcript you've ever recorded. No daemon, no Python, no external
@@ -12,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
@@ -44,11 +46,18 @@ npm install -g @nogataka/claw-memory
 | Source | What it is | Tooling |
 |--------|-----------|---------|
 | **Distilled DB** | LLM-summarized sessions → summaries, preferences, and embedded conversation chunks with structured metadata. Semantically searchable. | `memory_recall`, `memory_search`, `memory_get` |
-| **Raw transcript search** | Full-text grep over your *actual* Claude Code (`~/.claude/projects`) and Codex (`~/.codex/sessions`) logs — including sessions that were never distilled. | `memory_search_logs` |
+| **Raw transcript search** | Full-text grep over your *actual* Claude Code (`~/.claude/projects`), Codex (`~/.codex/sessions`), and **ChatGPT web** export (`conversations.json`) logs — including sessions that were never distilled. | `memory_search_logs` |
 
 The distilled DB is curated and fast to recall; raw search is a safety net that finds
 anything you ever discussed, even before claw-memory was installed.
 
+**ChatGPT web** conversations live on OpenAI's servers, not on disk, so claw-memory
+reads them from the official export: ChatGPT → Settings → **Data controls** → **Export
+data**; unzip and drop `conversations.json` into `~/.claw-memory/chatgpt/` (or point
+`CLAW_MEMORY_CHATGPT_EXPORT` at the file/folder). Then it's searchable like any other
+log, and `claw-memory distill-chatgpt` adds it to the semantic DB under a dedicated
+`chatgpt` project.
+
 ### 2. Automatic capture (distill)
 
 When a session ends, claw-memory distills the transcript into:
@@ -99,7 +108,21 @@ handle the high-frequency distill work.
 
 A zero-build, read-only viewer (`claw-memory ui`) to browse projects, summaries,
 chunks (with their metadata), preferences, and to run raw-log search — with live
-updates via SSE. It runs only when you start it.
+updates via SSE. It runs only when you start it. The viewer also has a **Lessons**
+tab for reviewing, approving and editing extracted lessons.
+
+### 8. Reusable lessons
+
+Beyond retrieving past logs, claw-memory distills AI coding sessions into
+**reusable lessons** — actionable, abstracted knowledge such as project-specific
+constraints, debugging patterns, design decisions and user preferences. Lessons
+are extracted alongside the normal summary (no extra LLM call), stored locally,
+embedded with the same local model, and surfaced (only after approval) when a
+similar task appears later. Each lesson carries `scope`, `confidence`,
+`applies_when` / `avoid_when` and a lifecycle (candidate → approved → archived /
+superseded), with duplicate / conflict detection and confidence decay over time.
+Raw logs remain available as evidence; day-to-day recall focuses on concise,
+reusable lessons.
 
 ---
 
@@ -130,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`.
 
@@ -151,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.
 
@@ -183,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
 ```
@@ -200,11 +224,18 @@ npm link             # optional: expose the `claw-memory` binary
 | `memory_remember(text, cwd?, sessionId?)` | Store a durable free-text note. |
 | `memory_distill(cwd, sessionId? \| transcriptPath?)` | Summarize a session into memory (needs an LLM backend). |
 | `memory_get_preferences(cwd?)` | List stored preferences for the project. |
-| `memory_search_logs(query, sources?, projectPath?, startDate?, endDate?, limit?, offset?)` | Full-text search over RAW Claude Code + Codex transcripts. |
+| `memory_search_logs(query, sources?, projectPath?, startDate?, endDate?, limit?, offset?)` | Full-text search over RAW Claude Code + Codex + ChatGPT-web transcripts (`sources`: `claude-code` / `codex` / `chatgpt-web`). |
 | `memory_forget(ids)` | Soft-delete chunks (hidden from search / recall / viewer). |
+| `lesson_search(query, cwd?, limit?)` | Search approved reusable lessons, ranked by relevance + scope + confidence. |
+| `lesson_inject(query, cwd?, limit?)` | Same, returned as a ready-to-read `<relevant-lessons>` block. |
+| `lesson_get(lesson_id)` | Full detail of one lesson (fields + history + links). |
+| `lesson_extract(cwd, sessionId? \| transcriptPath?)` | Dedicated lesson-extraction pass over a session (needs an LLM backend). |
+| `lesson_approve / lesson_reject / lesson_archive(lesson_id, reason?)` | Lifecycle transitions. |
+| `lesson_supersede(old_lesson_id, new_lesson_id)` | Replace an old lesson with a newer one. |
 
-All tools are fully local except `memory_distill` (LLM) and `memory_search_logs`
-(reads `~/.claude/projects` and `~/.codex/sessions` directly).
+All tools are fully local except `memory_distill` / `lesson_extract` (LLM) and
+`memory_search_logs` (reads `~/.claude/projects` and `~/.codex/sessions`
+directly).
 
 ---
 
@@ -223,6 +254,12 @@ All tools are fully local except `memory_distill` (LLM) and `memory_search_logs`
 | `CLAW_MEMORY_EXCLUDED_PROJECTS` | — | Comma/colon-separated path substrings to never record or recall. |
 | `MEMORY_SIMILARITY_MAX_DISTANCE` | `0.6` | Max cosine distance for a semantic hit (lower = stricter). |
 | `CLAW_MEMORY_UI_PORT` | `4319` | Viewer port. |
+| `LESSON_RECALL_LIMIT` | `3` | Approved lessons injected into the recall block (`0` disables). |
+| `CLAW_MEMORY_LESSON_DEDICATED` | — | `1` = run a separate, higher-quality lesson-extraction pass (extra LLM call). |
+| `CLAW_MEMORY_LESSON_CONFLICT_LLM` | — | `1` = use the LLM to detect conflicting lessons during extraction. |
+| `LESSON_DECAY_FACTOR` / `LESSON_STALE_DAYS` | `0.9` / `30` | Confidence-decay factor and staleness threshold for `lessons decay`. |
+| `CLAW_MEMORY_CHATGPT_EXPORT` | `~/.claw-memory/chatgpt` | ChatGPT `conversations.json` export — a file or a folder of `*.json`. |
+| `CLAW_MEMORY_CHATGPT_MAX_BYTES` | `209715200` (200 MB) | Skip ChatGPT export files larger than this (parsed in memory). |
 
 ### LLM backends
 
@@ -246,8 +283,18 @@ claw-memory mcp                                  # stdio MCP server (what agents
 claw-memory ui [--port N] [--open]               # read-only web viewer
 claw-memory distill --cwd P --session ID [--path FILE] [--if-stale]
 claw-memory distill-codex [--recent] [--limit N] [--all]
+claw-memory distill-chatgpt [--limit N] [--all]  # distill ChatGPT web export conversations
 claw-memory remember --cwd P "a note"
-claw-memory search-logs "query" [--source claude-code,codex] [--project P]
+claw-memory lessons list [--status candidate|approved|...] [--cwd P]
+claw-memory lessons search "query" [--cwd P] [--limit N]
+claw-memory lessons inject "query" [--cwd P] [--limit N]
+claw-memory lessons extract --session ID [--cwd P] [--path FILE]
+claw-memory lessons approve|reject|archive <lesson_id> [--reason R]
+claw-memory lessons supersede <old_id> <new_id>
+claw-memory lessons decay [--days N] [--factor F] [--dry]
+claw-memory lessons export [--status S] [--cwd P] > bundle.json
+claw-memory lessons import bundle.json [--status S] [--cwd P]
+claw-memory search-logs "query" [--source claude-code,codex,chatgpt-web] [--project P]
                                  [--start ISO] [--end ISO] [--limit N] [--offset N]
 claw-memory hook <recall|distill>               # lifecycle hook (reads JSON on stdin)
 claw-memory install   [--codex | --claude-code] # register MCP + hooks (default: codex)
@@ -316,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

@@ -162,6 +162,79 @@ async function main() {
             console.log(JSON.stringify({ scanned: files.length, distilled, skipped, failed }, null, 2));
             process.exit(0);
         }
+        case "distill-chatgpt": {
+            const { loadChatgptConversations } = await import("./core/logsearch/recent.js");
+            const { chatgptProjectPath } = await import("./core/logsearch/paths.js");
+            const { distill } = await import("./core/distill.js");
+            const { getOrCreateProjectByPath } = await import("./core/projects.js");
+            const { shouldDistill, markDistilled } = await import("./core/watermark.js");
+            const all = hasFlag(rest, "all");
+            const limit = Number(getFlag(rest, "limit") ?? (all ? 100000 : 50));
+            const convos = (await loadChatgptConversations()).slice(0, limit);
+            // ChatGPT has no cwd; all conversations live under one stable synthetic
+            // project so they never pollute a real repository's recall.
+            const project = getOrCreateProjectByPath(chatgptProjectPath);
+            let distilled = 0, skipped = 0, failed = 0;
+            for (const conv of convos) {
+                // Watermark per conversation, keyed by id + last write time.
+                const wmKey = `chatgpt:${conv.conversationId}`;
+                const mtimeMs = conv.updateTime ? new Date(conv.updateTime).getTime() : 0;
+                if (!shouldDistill(wmKey, mtimeMs)) {
+                    skipped++;
+                    continue;
+                }
+                try {
+                    const res = await distill({
+                        projectId: project.id,
+                        sessionId: conv.conversationId,
+                        messages: conv.messages.map((m) => ({ role: m.role, text: m.text })),
+                    });
+                    markDistilled(wmKey, mtimeMs);
+                    if (res.skipped)
+                        skipped++;
+                    else
+                        distilled++;
+                }
+                catch (e) {
+                    failed++;
+                    console.error(`distill failed ${conv.conversationId}: ${String(e)}`);
+                }
+            }
+            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");
@@ -201,14 +274,155 @@ async function main() {
             console.log(JSON.stringify(out, null, 2));
             process.exit(0);
         }
+        case "lessons": {
+            const sub = rest[0];
+            const subRest = rest.slice(1);
+            const positionals = (args) => {
+                const out = [];
+                for (let i = 0; i < args.length; i++) {
+                    if (args[i].startsWith("--")) {
+                        i++;
+                        continue;
+                    }
+                    out.push(args[i]);
+                }
+                return out;
+            };
+            const projectId = async () => {
+                const { getOrCreateProjectByPath } = await import("./core/projects.js");
+                return getOrCreateProjectByPath(getFlag(subRest, "cwd") ?? process.cwd()).id;
+            };
+            switch (sub) {
+                case "list": {
+                    const { listLessons } = await import("./core/lessons.js");
+                    const status = getFlag(subRest, "status");
+                    const rows = listLessons({ status, projectId: getFlag(subRest, "cwd") ? await projectId() : undefined });
+                    for (const l of rows) {
+                        console.log(`${l.id}  [${l.status}/${l.scope}]  conf=${l.confidence.toFixed(2)}  ${l.title}`);
+                    }
+                    console.log(`(${rows.length} lessons)`);
+                    process.exit(0);
+                }
+                case "search": {
+                    const { searchLessons } = await import("./core/lesson-search.js");
+                    const query = positionals(subRest).join(" ").trim();
+                    if (!query)
+                        throw new Error("lessons search requires a query");
+                    const hits = await searchLessons(query, { projectId: await projectId() }, { limit: Number(getFlag(subRest, "limit") ?? 5) });
+                    for (const l of hits) {
+                        console.log(`${l.id}  score=${l.score.toFixed(3)}  [${l.scope}]  ${l.title}`);
+                    }
+                    process.exit(0);
+                }
+                case "inject": {
+                    const { injectLessons } = await import("./core/lesson-search.js");
+                    const query = positionals(subRest).join(" ").trim();
+                    if (!query)
+                        throw new Error("lessons inject requires a query");
+                    console.log(await injectLessons(query, { projectId: await projectId() }, { limit: Number(getFlag(subRest, "limit") ?? 5) }));
+                    process.exit(0);
+                }
+                case "approve":
+                case "reject":
+                case "archive": {
+                    const { setStatus } = await import("./core/lessons.js");
+                    const id = positionals(subRest)[0];
+                    if (!id)
+                        throw new Error(`lessons ${sub} requires a lesson_id`);
+                    const newStatus = sub === "approve" ? "approved" : sub === "reject" ? "rejected" : "archived";
+                    const ok = setStatus(id, newStatus, getFlag(subRest, "reason"));
+                    console.log(ok ? `${id} -> ${newStatus}` : "(該当なし)");
+                    process.exit(ok ? 0 : 1);
+                }
+                case "supersede": {
+                    const { supersede } = await import("./core/lessons.js");
+                    const [oldId, newId] = positionals(subRest);
+                    if (!oldId || !newId)
+                        throw new Error("lessons supersede requires <old_id> <new_id>");
+                    const ok = supersede(oldId, newId);
+                    console.log(ok ? `${oldId} superseded by ${newId}` : "(該当なし)");
+                    process.exit(ok ? 0 : 1);
+                }
+                case "decay": {
+                    const { decayConfidence, listStale } = await import("./core/lesson-quality.js");
+                    const dryRun = hasFlag(subRest, "dry");
+                    const res = decayConfidence({
+                        factor: getFlag(subRest, "factor") ? Number(getFlag(subRest, "factor")) : undefined,
+                        staleDays: getFlag(subRest, "days") ? Number(getFlag(subRest, "days")) : undefined,
+                        dryRun,
+                    });
+                    console.log(JSON.stringify({ ...res, dryRun, stale: listStale().length }, null, 2));
+                    process.exit(0);
+                }
+                case "export": {
+                    const { exportLessons } = await import("./core/lesson-share.js");
+                    const bundle = exportLessons({
+                        projectId: getFlag(subRest, "cwd") ? await projectId() : undefined,
+                        status: getFlag(subRest, "status"),
+                    });
+                    console.log(JSON.stringify(bundle, null, 2));
+                    process.exit(0);
+                }
+                case "import": {
+                    const { importLessons } = await import("./core/lesson-share.js");
+                    const { readFileSync } = await import("node:fs");
+                    const file = positionals(subRest)[0];
+                    if (!file)
+                        throw new Error("lessons import requires a bundle file path");
+                    const bundle = JSON.parse(readFileSync(file, "utf-8"));
+                    const res = await importLessons(bundle, {
+                        projectId: await projectId(),
+                        status: getFlag(subRest, "status"),
+                    });
+                    console.log(JSON.stringify(res, null, 2));
+                    process.exit(0);
+                }
+                case "extract": {
+                    const { getOrCreateProjectByPath } = await import("./core/projects.js");
+                    const { resolveSessionJsonl, loadTranscript } = await import("./core/transcript.js");
+                    const { stripPrivate } = await import("./core/private.js");
+                    const { extractDedicated, saveCandidates } = await import("./core/lesson-extract.js");
+                    const cwd = getFlag(subRest, "cwd") ?? process.cwd();
+                    const session = getFlag(subRest, "session") ?? "";
+                    const path = getFlag(subRest, "path") ?? (session ? resolveSessionJsonl(cwd, session) : undefined);
+                    if (!path)
+                        throw new Error("lessons extract requires --session or --path");
+                    const project = getOrCreateProjectByPath(cwd);
+                    const msgs = loadTranscript(path).map((m) => ({ ...m, text: stripPrivate(m.text) })).filter((m) => m.text.trim());
+                    const transcript = msgs.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.text.slice(0, 500)}`).join("\n");
+                    const candidates = await extractDedicated(transcript);
+                    const ids = await saveCandidates({ projectId: project.id, sessionId: session || path, candidates });
+                    console.log(JSON.stringify({ extracted: candidates.length, saved: ids.length }, null, 2));
+                    process.exit(0);
+                }
+                default:
+                    console.error("Usage: claw-memory lessons <subcommand>\n" +
+                        "  list [--status candidate|approved|...] [--cwd P]\n" +
+                        "  search \"query\" [--cwd P] [--limit N]\n" +
+                        "  inject \"query\" [--cwd P] [--limit N]\n" +
+                        "  extract --session ID [--cwd P] [--path FILE]\n" +
+                        "  approve <lesson_id>\n" +
+                        "  reject <lesson_id> [--reason R]\n" +
+                        "  archive <lesson_id> [--reason R]\n" +
+                        "  supersede <old_id> <new_id>\n" +
+                        "  decay [--days N] [--factor F] [--dry]\n" +
+                        "  export [--status S] [--cwd P]    print a portable JSON bundle\n" +
+                        "  import <file> [--status S] [--cwd P]   import a bundle (default status: candidate)");
+                    process.exit(sub ? 1 : 0);
+            }
+            return;
+        }
         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" +
+                "  distill-chatgpt [--limit N] [--all]            distill ChatGPT web export conversations\n" +
                 "  remember --cwd P \"text\"\n" +
-                "  search-logs \"query\" [--source claude-code,codex] [--project P] [--start ISO] [--end ISO] [--limit N] [--offset N]\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" +
                 "  inject-recall             alias for `hook recall`\n" +
                 "  install [--codex|--claude-code]     register MCP + hooks (default: codex)\n" +