@nogataka/claw-memory 0.1.3 → 0.3.0

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,
@@ -90,3 +118,98 @@ sqlite.exec(`
     tokenize = 'trigram'
   );
 `);
+// --- Lesson layer ----------------------------------------------------------
+// A "lesson" is reusable, abstracted knowledge distilled from sessions (bug-fix
+// patterns, project constraints, design decisions, user preferences). Unlike
+// conversation_chunks (raw history), lessons are explicit, structured, scoped,
+// and lifecycle-managed (candidate → approved/rejected/archived/superseded).
+// JSON-array columns (applies_when / avoid_when / concepts / files /
+// source_chunk_ids) are stored as TEXT to keep the schema flat and ORM-free,
+// mirroring conversation_chunks.concepts.
+sqlite.exec(`
+  CREATE TABLE IF NOT EXISTS lessons (
+    id TEXT PRIMARY KEY,
+    project_id TEXT,
+    repo_id TEXT,
+    session_id TEXT,
+    vec_rowid INTEGER,
+    title TEXT NOT NULL,
+    lesson TEXT NOT NULL,
+    applies_when TEXT,
+    avoid_when TEXT,
+    evidence TEXT,
+    scope TEXT NOT NULL DEFAULT 'repo',
+    obs_type TEXT,
+    concepts TEXT,
+    files TEXT,
+    confidence REAL NOT NULL DEFAULT 0.5,
+    source_chunk_ids TEXT,
+    status TEXT NOT NULL DEFAULT 'candidate',
+    superseded_by TEXT,
+    valid_until TEXT,
+    last_used_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  -- Lifecycle audit trail: every status transition / decay / scope change.
+  CREATE TABLE IF NOT EXISTS lesson_events (
+    id TEXT PRIMARY KEY,
+    lesson_id TEXT NOT NULL,
+    event_type TEXT NOT NULL,
+    old_status TEXT,
+    new_status TEXT,
+    note TEXT,
+    created_at TEXT NOT NULL
+  );
+
+  -- Relations between lessons: duplicate / conflicts_with / supersedes /
+  -- related_to / derived_from (populated by dedup + conflict detection).
+  CREATE TABLE IF NOT EXISTS lesson_links (
+    id TEXT PRIMARY KEY,
+    lesson_id TEXT NOT NULL,
+    linked_lesson_id TEXT NOT NULL,
+    relation TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_lessons_status ON lessons(status);
+  CREATE INDEX IF NOT EXISTS idx_lessons_project ON lessons(project_id);
+  CREATE INDEX IF NOT EXISTS idx_lesson_events_lesson ON lesson_events(lesson_id);
+  CREATE INDEX IF NOT EXISTS idx_lesson_links_lesson ON lesson_links(lesson_id);
+`);
+// Additive, migration-less column evolution for lessons (same approach as
+// conversation_chunks above): newly-introduced columns are ALTER-added in a
+// try/catch so older ~/.claw-memory/memory.db files keep working.
+for (const col of [
+    "repo_id TEXT",
+    "valid_until TEXT",
+    "last_used_at TEXT",
+    "superseded_by TEXT",
+]) {
+    try {
+        sqlite.exec(`ALTER TABLE lessons ADD COLUMN ${col}`);
+    }
+    catch {
+        // column already exists
+    }
+}
+// vec0 virtual table for lesson embeddings (same 384-dim e5 space as
+// vec_chunks). scope + project_id metadata columns let KNN filter inside the
+// MATCH query without post-filter loss.
+sqlite.exec(`
+  CREATE VIRTUAL TABLE IF NOT EXISTS lesson_vec USING vec0(
+    embedding float[384] distance_metric=cosine,
+    project_id text,
+    scope text
+  );
+`);
+// FTS5 keyword index over lesson title + body (trigram, same rationale as
+// chunks_fts). lesson_id links back to lessons.id.
+sqlite.exec(`
+  CREATE VIRTUAL TABLE IF NOT EXISTS lessons_fts USING fts5(
+    lesson_id UNINDEXED,
+    text,
+    tokenize = 'trigram'
+  );
+`);

package/dist/core/distill.js

@@ -10,9 +10,57 @@ import { saveChunks, deleteChunksBySession, chunkExists, } from "./vector-memory
 import { loadTranscript } from "./transcript.js";
 import { stripPrivate } from "./private.js";
 import { log } from "./logger.js";
+import { saveCandidates, extractDedicated, dedicatedEnabled, } from "./lesson-extract.js";
 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 で回答してください。
 
@@ -26,9 +74,15 @@ const PROMPT = (transcript) => `以下の会話を分析して JSON で回答し
    key は必ず次のいずれか（該当しなければ出さない）:
    language | response_style | detail_level | code_style | framework | tone | tools
    変更がなければ空配列。
+7. lessons: 次回以降の作業で再利用できる「教訓」だけを抽出（無ければ空配列）。
+   一時的な会話・未検証の推測・秘密情報・一回限りのコマンド・重複は抽出しない。
+   各 lesson は実行可能・具体的・再利用可能であること。
+   各要素: {"title","lesson","applies_when":[],"avoid_when":[],
+   "scope":"global|project|repo|file|task|user_preference","confidence":0.0-1.0,
+   "evidence","concepts":[],"files":[]}
 
 JSON のみ回答:
-{"summary": "...", "obs_type": "...", "concepts": ["..."], "files_read": ["..."], "files_modified": ["..."], "preferences": [{"key": "...", "value": "..."}]}
+{"summary": "...", "obs_type": "...", "concepts": ["..."], "files_read": ["..."], "files_modified": ["..."], "preferences": [{"key": "...", "value": "..."}], "lessons": []}
 
 <conversation>
 ${transcript}
@@ -44,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" };
@@ -77,6 +131,7 @@ export async function distill(input) {
     const filesModified = (result.files_modified ?? []).map(String).filter(Boolean);
     // --- Vector memory: re-chunk this session (idempotent) ---
     let chunkCount = 0;
+    let savedChunkIds = [];
     try {
         deleteChunksBySession(input.sessionId);
         const pairs = [];
@@ -84,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),
                 });
             }
         }
@@ -110,24 +176,50 @@ export async function distill(input) {
                 });
             }
             if (toSave.length > 0)
-                saveChunks(toSave);
+                savedChunkIds = saveChunks(toSave);
             chunkCount = toSave.length;
         }
     }
     catch (err) {
         console.error("[claw-memory] chunk embed failed:", err);
     }
+    // --- Lesson layer: extract reusable lessons (best-effort) ---
+    // Candidates ride along in the summary JSON above (no extra LLM call). When
+    // CLAW_MEMORY_LESSON_DEDICATED=1, run a separate higher-quality extraction
+    // pass instead. Failures here must never break the summary path.
+    let lessonCount = 0;
+    try {
+        const candidates = dedicatedEnabled()
+            ? await extractDedicated(transcript)
+            : Array.isArray(result.lessons)
+                ? result.lessons
+                : [];
+        if (candidates.length > 0) {
+            const ids = await saveCandidates({
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                candidates,
+                sourceChunkIds: savedChunkIds,
+            });
+            lessonCount = ids.length;
+        }
+    }
+    catch (err) {
+        console.error("[claw-memory] lesson extract failed:", err);
+    }
     log("distill", {
         projectId: input.projectId,
         sessionId: input.sessionId,
         obsType,
         chunks: chunkCount,
         preferences: result.preferences?.length ?? 0,
+        lessons: lessonCount,
     });
     return {
         summary: result.summary,
         preferencesCount: result.preferences?.length ?? 0,
         chunks: chunkCount,
+        lessons: lessonCount,
     };
 }
 /** Store a single free-text note as an embedded chunk (memory_remember). */

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/lesson-extract.js

@@ -0,0 +1,233 @@
+// src/core/lesson-extract.ts
+//
+// Turn distilled session signal into candidate lessons. Two entry points:
+//
+//  - saveCandidates(): persist already-extracted LessonCandidate[] (the default
+//    path — candidates ride along in distill()'s existing summary JSON, so no
+//    extra LLM call).
+//  - extractDedicated(): a separate, higher-quality extraction pass over the
+//    transcript using the section-12 prompt + the "smart" tier. Opt-in via
+//    CLAW_MEMORY_LESSON_DEDICATED=1.
+//
+// All lessons are saved as status='candidate'; only human/rule approval promotes
+// them to 'approved' (the status that lesson_search / recall actually surface).
+import { execFileSync } from "node:child_process";
+import { complete } from "./llm.js";
+import { embedPassage } from "./embeddings.js";
+import { saveLesson, linkLessons, searchSimilarLessons, } from "./lessons.js";
+import { getProject } from "./projects.js";
+import { log } from "./logger.js";
+// Distance thresholds (cosine, 0..2) for relation classification.
+const DUP_DISTANCE = Number(process.env.LESSON_DUP_DISTANCE ?? 0.08);
+const RELATED_DISTANCE = Number(process.env.LESSON_RELATED_DISTANCE ?? 0.28);
+const VALID_SCOPES = [
+    "global",
+    "project",
+    "repo",
+    "file",
+    "task",
+    "user_preference",
+    "team",
+];
+export function normalizeScope(scope) {
+    const s = (scope ?? "").trim().toLowerCase();
+    return VALID_SCOPES.includes(s) ? s : "repo";
+}
+export function clampConfidence(c) {
+    if (typeof c !== "number" || Number.isNaN(c))
+        return 0.5;
+    return Math.max(0, Math.min(1, c));
+}
+/**
+ * Resolve a stable repo id for a project: the git top-level path, falling back
+ * to the project's own path. Best-effort — git failures are non-fatal. Cached
+ * per project path so repeated distills don't re-spawn git.
+ */
+const repoCache = new Map();
+export function resolveRepoId(projectId) {
+    if (!projectId)
+        return null;
+    const project = getProject(projectId);
+    if (!project)
+        return null;
+    const cached = repoCache.get(project.path);
+    if (cached !== undefined)
+        return cached;
+    let repo = project.path;
+    try {
+        repo = execFileSync("git", ["-C", project.path, "rev-parse", "--show-toplevel"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim() || project.path;
+    }
+    catch {
+        // not a git repo — repo id is the project path itself
+    }
+    repoCache.set(project.path, repo);
+    return repo;
+}
+/** Persist candidate lessons (embed + saveLesson as 'candidate'). */
+export async function saveCandidates(input) {
+    const repoId = resolveRepoId(input.projectId);
+    const ids = [];
+    for (const c of input.candidates) {
+        const title = (c.title ?? "").trim();
+        const lesson = (c.lesson ?? "").trim();
+        if (!title || !lesson)
+            continue;
+        const embedding = await embedPassage(`${title}\n${lesson}`);
+        const id = saveLesson({
+            projectId: input.projectId ?? null,
+            repoId,
+            sessionId: input.sessionId ?? null,
+            title: title.slice(0, 200),
+            lesson: lesson.slice(0, 2000),
+            appliesWhen: (c.applies_when ?? []).map(String).filter(Boolean),
+            avoidWhen: (c.avoid_when ?? []).map(String).filter(Boolean),
+            evidence: c.evidence ? String(c.evidence).slice(0, 1000) : null,
+            scope: normalizeScope(c.scope),
+            concepts: (c.concepts ?? []).map(String).filter(Boolean),
+            files: (c.files ?? []).map(String).filter(Boolean),
+            confidence: clampConfidence(c.confidence),
+            sourceChunkIds: input.sourceChunkIds ?? [],
+            status: "candidate",
+            embedding,
+        });
+        // Detect duplicates / related / conflicts vs existing lessons (best-effort).
+        try {
+            await detectRelations({ lessonId: id, embedding, candidate: c });
+        }
+        catch (err) {
+            console.error("[claw-memory] lesson relation detection failed:", err);
+        }
+        ids.push(id);
+    }
+    log("lesson-extract", {
+        projectId: input.projectId,
+        sessionId: input.sessionId,
+        saved: ids.length,
+    });
+    return ids;
+}
+function shareAny(a, b) {
+    if (!a.length || !b.length)
+        return false;
+    const set = new Set(a.map((s) => s.toLowerCase()));
+    return b.some((s) => set.has(s.toLowerCase()));
+}
+const CONFLICT_PROMPT = (a, b) => `次の2つのレッスンの関係を判定してください。
+
+Lesson A: ${a}
+Lesson B: ${b}
+
+関係を1つ選び JSON のみで回答:
+{"relation": "duplicate" | "conflict" | "related" | "none"}
+- duplicate: 実質同じ内容
+- conflict: 互いに矛盾する主張
+- related: 関連するが別の知識
+- none: 無関係`;
+function conflictLlmEnabled() {
+    return process.env.CLAW_MEMORY_LESSON_CONFLICT_LLM === "1";
+}
+/**
+ * Compare a freshly-saved lesson against existing lessons and record
+ * lesson_links (duplicate / related_to / conflicts_with). Embedding distance
+ * gives duplicate/related deterministically; an opt-in LLM pass (env
+ * CLAW_MEMORY_LESSON_CONFLICT_LLM=1) adds semantic conflict detection. A
+ * detected conflict leaves the new lesson as 'candidate' for Conflict Review.
+ */
+export async function detectRelations(opts) {
+    const result = { duplicates: 0, related: 0, conflicts: 0 };
+    const neighbors = searchSimilarLessons(opts.embedding, {
+        topK: 6,
+        maxDistance: RELATED_DISTANCE,
+    }).filter((n) => n.id !== opts.lessonId &&
+        n.status !== "rejected" &&
+        n.status !== "superseded");
+    if (neighbors.length === 0)
+        return result;
+    const newConcepts = (opts.candidate.concepts ?? []).map(String);
+    const newFiles = (opts.candidate.files ?? []).map(String);
+    const link = (target, relation) => linkLessons(opts.lessonId, target, relation);
+    // Deterministic: nearest neighbor classification by distance + overlap.
+    let llmDone = false;
+    for (const n of neighbors) {
+        if (n.distance <= DUP_DISTANCE) {
+            link(n.id, "duplicate");
+            result.duplicates++;
+            continue;
+        }
+        const overlaps = shareAny(newConcepts, n.concepts) || shareAny(newFiles, n.files);
+        // Opt-in LLM judgment on the closest overlapping neighbor only (1 call max).
+        if (conflictLlmEnabled() && !llmDone && overlaps) {
+            llmDone = true;
+            try {
+                const text = await complete({
+                    prompt: CONFLICT_PROMPT(`${opts.candidate.title}: ${opts.candidate.lesson}`, `${n.title}: ${n.lesson}`),
+                    tier: "simple",
+                });
+                const m = text.match(/"relation"\s*:\s*"(\w+)"/);
+                const rel = m?.[1];
+                if (rel === "conflict") {
+                    link(n.id, "conflicts_with");
+                    result.conflicts++;
+                    continue;
+                }
+                if (rel === "duplicate") {
+                    link(n.id, "duplicate");
+                    result.duplicates++;
+                    continue;
+                }
+            }
+            catch {
+                // LLM unavailable — fall through to deterministic related link
+            }
+        }
+        if (overlaps) {
+            link(n.id, "related_to");
+            result.related++;
+        }
+    }
+    return result;
+}
+const DEDICATED_PROMPT = (transcript) => `あなたはAIコーディングセッションから、将来再利用可能なレッスンを抽出する役割です。
+
+抽出するのは、次回以降の作業で役立つ可能性が高い教訓だけです。
+
+抽出しないもの:
+- 一時的な会話
+- 検証されていない推測
+- 秘密情報（APIキー・トークン・個人情報）
+- 生ログの丸写し
+- 再利用性の低い一回限りのコマンド
+- 既存レッスンと重複する内容
+
+各レッスンは、実行可能で、具体的で、再利用可能である必要があります。
+該当が無ければ空配列を返してください。
+
+JSON のみ回答:
+{"lessons": [{"title": "...", "lesson": "...", "applies_when": ["..."], "avoid_when": ["..."], "scope": "global|project|repo|file|task|user_preference", "confidence": 0.0, "evidence": "...", "concepts": ["..."], "files": ["..."]}]}
+
+<conversation>
+${transcript}
+</conversation>`;
+/** Dedicated extraction pass (opt-in). Returns parsed candidates. */
+export async function extractDedicated(transcript) {
+    const responseText = await complete({
+        prompt: DEDICATED_PROMPT(transcript),
+        tier: "smart",
+    });
+    const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        return [];
+    try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return Array.isArray(parsed.lessons) ? parsed.lessons : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function dedicatedEnabled() {
+    return process.env.CLAW_MEMORY_LESSON_DEDICATED === "1";
+}