@memtensor/memos-local-openclaw-plugin 1.0.2-beta.4 → 1.0.2-beta.6

package/src/ingest/task-processor.ts

@@ -310,9 +310,10 @@ export class TaskProcessor {
     const skipReason = this.shouldSkipSummary(chunks);
 
     if (skipReason) {
-      this.ctx.log.info(`Task ${task.id} skipped: ${skipReason} (chunks=${chunks.length}, title="${fallbackTitle}")`);
+      const skipTitle = await this.generateTitle(chunks, fallbackTitle);
+      this.ctx.log.info(`Task ${task.id} skipped: ${skipReason} (chunks=${chunks.length}, title="${skipTitle}")`);
       const reason = this.humanReadableSkipReason(skipReason, chunks);
-      this.store.updateTask(task.id, { title: fallbackTitle, summary: reason, status: "skipped", endedAt: Date.now() });
+      this.store.updateTask(task.id, { title: skipTitle, summary: reason, status: "skipped", endedAt: Date.now() });
       return;
     }
 
@@ -326,7 +327,7 @@ export class TaskProcessor {
     }
 
     const { title: llmTitle, body } = this.parseTitleFromSummary(summary);
-    const title = llmTitle || fallbackTitle;
+    const title = llmTitle || await this.generateTitle(chunks, fallbackTitle);
 
     this.store.updateTask(task.id, {
       title,
@@ -455,19 +456,39 @@ export class TaskProcessor {
   private parseTitleFromSummary(summary: string): { title: string; body: string } {
     const titleMatch = summary.match(/📌\s*(?:Title|标题)\s*\n(.+)/);
     if (titleMatch) {
-      const title = titleMatch[1].trim().slice(0, 80);
+      const title = titleMatch[1].trim();
       const body = summary.replace(/📌\s*(?:Title|标题)\s*\n.+\n?/, "").trim();
       return { title, body };
     }
     return { title: "", body: summary };
   }
 
+  private async generateTitle(chunks: Chunk[], fallback: string): Promise<string> {
+    try {
+      const userChunks = chunks.filter((c) => c.role === "user");
+      const titleInput = userChunks
+        .slice(0, 3)
+        .map((c) => c.content.trim())
+        .join("\n\n");
+      if (!titleInput) return fallback || "Untitled Task";
+      const title = await this.summarizer.generateTaskTitle(titleInput);
+      return title || fallback || "Untitled Task";
+    } catch (err) {
+      this.ctx.log.warn(`generateTitle failed: ${err}`);
+      return fallback || "Untitled Task";
+    }
+  }
+
   private extractTitle(chunks: Chunk[]): string {
-    const firstUser = chunks.find((c) => c.role === "user");
+    const firstUser = chunks.find((c) => {
+      if (c.role !== "user") return false;
+      const t = c.content.trim();
+      if (t.length > 200) return false;
+      if (/session.startup|Session Startup|\/new|\/reset/i.test(t)) return false;
+      return true;
+    });
     if (!firstUser) return "Untitled Task";
-    const text = firstUser.content.trim();
-    if (text.length <= 60) return text;
-    return text.slice(0, 57) + "...";
+    return firstUser.content.trim().slice(0, 80);
   }
 
   private humanReadableSkipReason(reason: string, chunks: Chunk[]): string {

package/src/ingest/worker.ts

@@ -59,32 +59,32 @@ export class IngestWorker {
         let duplicated = 0;
         let errors = 0;
         const resultLines: string[] = [];
+        const inputDetails: Array<{ role: string; content: string }> = [];
 
         while (this.queue.length > 0) {
           const msg = this.queue.shift()!;
+          inputDetails.push({ role: msg.role, content: msg.content });
           try {
             const result = await this.ingestMessage(msg);
             lastSessionKey = msg.sessionKey;
             lastOwner = msg.owner ?? "agent:main";
             lastTimestamp = Math.max(lastTimestamp, msg.timestamp);
-            const brief = (s: string) => s.length > 80 ? s.slice(0, 80) + "…" : s;
             if (result === "skipped") {
               skipped++;
-              resultLines.push(`[${msg.role}] ⏭ exact-dup → ${brief(msg.content)}`);
+              resultLines.push(JSON.stringify({ role: msg.role, action: "exact-dup", summary: "", content: msg.content }));
             } else if (result.action === "stored") {
               stored++;
-              resultLines.push(`[${msg.role}] ✅ stored → ${brief(result.summary ?? msg.content)}`);
+              resultLines.push(JSON.stringify({ role: msg.role, action: "stored", summary: result.summary ?? "", content: msg.content }));
             } else if (result.action === "duplicate") {
               duplicated++;
-              resultLines.push(`[${msg.role}] 🔁 dedup(${result.reason ?? "similar"}) → ${brief(msg.content)}`);
+              resultLines.push(JSON.stringify({ role: msg.role, action: "dedup", reason: result.reason ?? "similar", summary: result.summary ?? "", content: msg.content }));
             } else if (result.action === "merged") {
               merged++;
-              resultLines.push(`[${msg.role}] 🔀 merged → ${brief(msg.content)}`);
+              resultLines.push(JSON.stringify({ role: msg.role, action: "merged", summary: result.summary ?? "", content: msg.content }));
             }
           } catch (err) {
             errors++;
-            const brief = (s: string) => s.length > 80 ? s.slice(0, 80) + "…" : s;
-            resultLines.push(`[${msg.role}] ❌ error → ${brief(msg.content)}`);
+            resultLines.push(JSON.stringify({ role: msg.role, action: "error", summary: "", content: msg.content }));
             this.ctx.log.error(`Failed to ingest message turn=${msg.turnId}: ${err}`);
           }
         }
@@ -97,6 +97,7 @@ export class IngestWorker {
             const inputInfo = {
               session: lastSessionKey,
               messages: batchSize,
+              details: inputDetails,
             };
             const stats = [`stored=${stored}`, skipped > 0 ? `skipped=${skipped}` : null, duplicated > 0 ? `dedup=${duplicated}` : null, merged > 0 ? `merged=${merged}` : null, errors > 0 ? `errors=${errors}` : null].filter(Boolean).join(", ");
             this.store.recordApiLog("memory_add", inputInfo, `${stats}\n${resultLines.join("\n")}`, dur, errors === 0);
@@ -122,8 +123,7 @@ export class IngestWorker {
   private async ingestMessage(msg: ConversationMessage): Promise<
     "skipped" | { action: "stored" | "duplicate" | "merged"; summary?: string; reason?: string }
   > {
-    const kind = msg.role === "tool" ? "tool_result" : "paragraph";
-    return await this.storeChunk(msg, msg.content, kind, 0);
+    return await this.storeChunk(msg, msg.content, "paragraph", 0);
   }
 
   private async storeChunk(
@@ -146,6 +146,8 @@ export class IngestWorker {
     let dedupTarget: string | null = null;
     let dedupReason: string | null = null;
     let mergedFromOld: string | null = null;
+    let mergeCount = 0;
+    let mergeHistory = "[]";
 
     // Fast path: exact content_hash match within same owner (agent dimension)
     const chunkOwner = msg.owner ?? "agent:main";
@@ -160,7 +162,7 @@ export class IngestWorker {
 
     // Smart dedup: find Top-5 similar chunks, then ask LLM to judge
     if (dedupStatus === "active" && embedding) {
-      const similarThreshold = this.ctx.config.dedup?.similarityThreshold ?? 0.60;
+      const similarThreshold = this.ctx.config.dedup?.similarityThreshold ?? 0.80;
       const dedupOwnerFilter = msg.owner ? [msg.owner] : undefined;
       const topSimilar = findTopSimilar(this.store, embedding, similarThreshold, 5, this.ctx.log, dedupOwnerFilter);
 
@@ -208,7 +210,23 @@ export class IngestWorker {
 
               mergedFromOld = targetChunkId;
               dedupReason = dedupResult.reason;
-              this.ctx.log.debug(`Smart dedup: UPDATE → old chunk=${targetChunkId} retired, new chunk=${chunkId} gets merged summary, reason: ${dedupResult.reason}`);
+
+              // Inherit merge history from the old chunk
+              if (oldChunk) {
+                const oldHistory = JSON.parse(oldChunk.mergeHistory || "[]");
+                oldHistory.push({
+                  action: "merge",
+                  at: Date.now(),
+                  reason: dedupResult.reason,
+                  from: oldSummary,
+                  to: dedupResult.mergedSummary,
+                  sourceChunkId: targetChunkId,
+                });
+                mergeHistory = JSON.stringify(oldHistory);
+                mergeCount = (oldChunk.mergeCount || 0) + 1;
+              }
+
+              this.ctx.log.debug(`Smart dedup: UPDATE → old chunk=${targetChunkId} retired, new chunk=${chunkId} gets merged summary (mergeCount=${mergeCount}), reason: ${dedupResult.reason}`);
             }
           }
 
@@ -235,9 +253,9 @@ export class IngestWorker {
       dedupStatus,
       dedupTarget,
       dedupReason,
-      mergeCount: 0,
+      mergeCount: mergeCount,
       lastHitAt: null,
-      mergeHistory: "[]",
+      mergeHistory: mergeHistory,
       createdAt: msg.timestamp,
       updatedAt: msg.timestamp,
     };

package/src/recall/engine.ts

@@ -42,7 +42,7 @@ export class RecallEngine {
     const candidatePool = maxResults * 5;
     const ownerFilter = opts.ownerFilter;
 
-    // Step 1: Gather candidates from both FTS and vector search
+    // Step 1: Gather candidates from FTS, vector search, and pattern search
     const ftsCandidates = query
       ? this.store.ftsSearch(query, candidatePool, ownerFilter)
       : [];
@@ -60,10 +60,24 @@ export class RecallEngine {
       }
     }
 
+    // Step 1b: Pattern search (LIKE-based) as fallback for short terms that
+    // trigram FTS cannot match (trigram requires >= 3 chars).
+    const shortTerms = query
+      .replace(/[."""(){}[\]*:^~!@#$%&\\/<>,;'`?？。，！、：""''（）【】《》]/g, " ")
+      .split(/\s+/)
+      .filter((t) => t.length === 2);
+    const patternHits = shortTerms.length > 0
+      ? this.store.patternSearch(shortTerms, { limit: candidatePool })
+      : [];
+    const patternRanked = patternHits.map((h, i) => ({
+      id: h.chunkId,
+      score: 1 / (i + 1),
+    }));
+
     // Step 2: RRF fusion
     const ftsRanked = ftsCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
     const vecRanked = vecCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
-    const rrfScores = rrfFuse([ftsRanked, vecRanked], recallCfg.rrfK);
+    const rrfScores = rrfFuse([ftsRanked, vecRanked, patternRanked], recallCfg.rrfK);
 
     if (rrfScores.size === 0) {
       this.recordQuery(query, maxResults, minScore, 0);
@@ -118,9 +132,10 @@ export class RecallEngine {
       if (!chunk) continue;
       if (roleFilter && chunk.role !== roleFilter) continue;
 
+      const excerpt = (chunk.mergeCount ?? 0) > 0 ? chunk.summary : makeExcerpt(chunk.content);
       hits.push({
         summary: chunk.summary,
-        original_excerpt: makeExcerpt(chunk.content),
+        original_excerpt: excerpt,
         ref: {
           sessionKey: chunk.sessionKey,
           chunkId: chunk.id,
@@ -255,7 +270,7 @@ export class RecallEngine {
   ): Promise<number[]> {
     const candidateList = candidates.map((c, i) => ({
       index: i,
-      summary: `[${c.skill.name}] ${c.skill.description}`,
+      content: `[${c.skill.name}] ${c.skill.description}`,
       role: "skill" as const,
     }));
 
@@ -274,13 +289,5 @@ export class RecallEngine {
 }
 
 function makeExcerpt(content: string): string {
-  const min = 200;
-  const max = 500;
-  if (content.length <= max) return content;
-
-  let cut = content.lastIndexOf(".", max);
-  if (cut < min) cut = content.lastIndexOf(" ", max);
-  if (cut < min) cut = max;
-
-  return content.slice(0, cut) + "…";
+  return content;
 }

package/src/skill/bundled-memory-guide.ts

@@ -1,91 +1,9 @@
 /**
  * Bundled MemOS memory-guide skill content.
- * Written to workspace/skills/memos-memory-guide on plugin register so OpenClaw loads it.
+ * Reads from skill/memos-memory-guide/SKILL.md at runtime (single source of truth).
  */
-export const MEMORY_GUIDE_SKILL_MD = `---
-name: memos-memory-guide
-description: Use the MemOS Local memory system to search and use the user's past conversations. Use this skill whenever the user refers to past chats, their own preferences or history, or when you need to answer from prior context. When auto-recall returns nothing (long or unclear user query), generate your own short search query and call memory_search. Use task_summary when you need full task context, skill_get for experience guides, and memory_timeline to expand around a memory hit.
----
+import * as fs from "fs";
+import * as path from "path";
 
-# MemOS Local Memory — Agent Guide
-
-This skill describes how to use the MemOS memory tools so you can reliably search and use the user's long-term conversation history.
-
-## How memory is provided each turn
-
-- **Automatic recall (hook):** At the start of each turn, the system runs a memory search using the user's current message and injects relevant past memories into your context. You do not need to call any tool for that.
-- **When that is not enough:** If the user's message is very long, vague, or the automatic search returns **no memories**, you should **generate your own short, focused query** and call \`memory_search\` yourself. For example:
-  - User sent a long paragraph → extract 1–2 key topics or a short question and search with that.
-  - Auto-recall said "no memories" or you see no memory block → call \`memory_search\` with a query you derive (e.g. the user's name, a topic they often mention, or a rephrased question).
-- **When you need more detail:** Search results only give excerpts and IDs. Use the tools below to fetch full task context, skill content, or surrounding messages.
-
-## Tools — what they do and when to call
-
-### memory_search
-
-- **What it does:** Searches the user's stored conversation memory by a natural-language query. Returns a list of relevant excerpts with \`chunkId\` and optionally \`task_id\`.
-- **When to call:**
-  - The automatic recall did not run or returned nothing (e.g. no \`<memory_context>\` block, or a note that no memories were found).
-  - The user's query is long or unclear — **generate a short query yourself** (keywords, rephrased question, or a clear sub-question) and call \`memory_search(query="...")\`.
-  - You need to search with a different angle (e.g. filter by \`role='user'\` to find what the user said, or use a more specific query).
-- **Parameters:** \`query\` (required), optional \`minScore\`, \`role\` (e.g. \`"user"\`).
-- **Output:** List of items with role, excerpt, \`chunkId\`, and sometimes \`task_id\`. Use those IDs with the tools below when you need more context.
-
-### task_summary
-
-- **What it does:** Returns the full task summary for a given \`task_id\`: title, status, and the complete narrative summary of that conversation task (steps, decisions, URLs, commands, etc.).
-- **When to call:** A \`memory_search\` hit included a \`task_id\` and you need the full story of that task (e.g. what was done, what the user decided, what failed or succeeded).
-- **Parameters:** \`taskId\` (from a search hit).
-- **Effect:** You get one coherent summary of the whole task instead of isolated excerpts.
-
-### skill_get
-
-- **What it does:** Returns the content of a learned skill (experience guide) by \`skillId\` or by \`taskId\`. If you pass \`taskId\`, the system finds the skill linked to that task.
-- **When to call:** A search hit has a \`task_id\` and the task is the kind that has a "how to do this again" guide (e.g. a workflow the user has run before). Use this to follow the same approach or reuse steps.
-- **Parameters:** \`skillId\` (direct) or \`taskId\` (lookup).
-- **Effect:** You receive the full SKILL.md-style guide. You can then call \`skill_install(skillId)\` if the user or you want that skill loaded for future turns.
-
-### skill_install
-
-- **What it does:** Installs a skill (by \`skillId\`) into the workspace so it is loaded in future sessions.
-- **When to call:** After \`skill_get\` when the skill is useful for ongoing use (e.g. the user's recurring workflow). Optional; only when you want the skill to be permanently available.
-- **Parameters:** \`skillId\`.
-
-### memory_timeline
-
-- **What it does:** Expands context around a single memory chunk: returns the surrounding conversation messages (±N turns) so you see what was said before and after that excerpt.
-- **When to call:** A \`memory_search\` hit is relevant but you need the surrounding dialogue (e.g. who said what next, or the exact follow-up question).
-- **Parameters:** \`chunkId\` (from a search hit), optional \`window\` (default 2).
-- **Effect:** You get a short, linear slice of the conversation around that chunk.
-
-### memory_viewer
-
-- **What it does:** Returns the URL of the MemOS Memory Viewer (web UI) where the user can browse, search, and manage their memories.
-- **When to call:** The user asks how to view their memories, open the memory dashboard, or manage stored data.
-- **Parameters:** None.
-- **Effect:** You can tell the user to open that URL in a browser.
-
-## Quick decision flow
-
-1. **No memories in context or auto-recall reported nothing**
-   → Call \`memory_search\` with a **self-generated short query** (e.g. key topic or rephrased question).
-
-2. **Search returned hits with \`task_id\` and you need full context**
-   → Call \`task_summary(taskId)\`.
-
-3. **Task has an experience guide you want to follow**
-   → Call \`skill_get(taskId=...)\` (or \`skill_get(skillId=...)\` if you have the id). Optionally \`skill_install(skillId)\` for future use.
-
-4. **You need the exact surrounding conversation of a hit**
-   → Call \`memory_timeline(chunkId=...)\`.
-
-5. **User asks where to see or manage their memories**
-   → Call \`memory_viewer()\` and share the URL.
-
-## Writing good search queries
-
-- Prefer **short, focused** queries (a few words or one clear question).
-- Use **concrete terms**: names, topics, tools, or decisions (e.g. "preferred editor", "deploy script", "API key setup").
-- If the user's message is long, **derive one or two sub-queries** rather than pasting the whole message.
-- Use \`role='user'\` when you specifically want to find what the user said (e.g. preferences, past questions).
-`;
+const skillPath = path.join(__dirname, "..", "..", "skill", "memos-memory-guide", "SKILL.md");
+export const MEMORY_GUIDE_SKILL_MD: string = fs.readFileSync(skillPath, "utf-8");

package/src/skill/evaluator.ts

@@ -52,7 +52,7 @@ Task title: {TITLE}
 Task summary:
 {SUMMARY}
 
-LANGUAGE RULE: The "reason" field MUST use the SAME language as the task title/summary. Chinese input → Chinese reason. English input → English reason. "suggestedName" stays in English kebab-case.
+LANGUAGE RULE (MUST FOLLOW): Detect the language of the task title/summary. If it is Chinese, the "reason" field MUST be in Chinese. If English, reason in English. Only "suggestedName" stays in English kebab-case. 如果任务标题/摘要是中文，reason 必须用中文。
 
 Reply in JSON only, no extra text:
 {

package/src/storage/sqlite.ts

@@ -46,7 +46,7 @@ export class SqliteStore {
         content,
         content='chunks',
         content_rowid='rowid',
-        tokenize='porter unicode61'
+        tokenize='trigram'
       );
 
       CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
@@ -109,6 +109,7 @@ export class SqliteStore {
     this.migrateOwnerFields();
     this.migrateSkillVisibility();
     this.migrateSkillEmbeddingsAndFts();
+    this.migrateFtsToTrigram();
     this.log.debug("Database schema initialized");
   }
 
@@ -159,7 +160,7 @@ export class SqliteStore {
         description,
         content='skills',
         content_rowid='rowid',
-        tokenize='porter unicode61'
+        tokenize='trigram'
       );
     `);
 
@@ -195,6 +196,81 @@ export class SqliteStore {
     } catch { /* best-effort */ }
   }
 
+  private migrateFtsToTrigram(): void {
+    // Check if chunks_fts still uses the old tokenizer (porter unicode61)
+    try {
+      const row = this.db.prepare(
+        "SELECT sql FROM sqlite_master WHERE name='chunks_fts'"
+      ).get() as { sql: string } | undefined;
+      if (row && row.sql && !row.sql.includes("trigram")) {
+        this.log.info("Migrating chunks_fts from porter/unicode61 to trigram tokenizer...");
+        this.db.exec("DROP TRIGGER IF EXISTS chunks_ai");
+        this.db.exec("DROP TRIGGER IF EXISTS chunks_ad");
+        this.db.exec("DROP TRIGGER IF EXISTS chunks_au");
+        this.db.exec("DROP TABLE IF EXISTS chunks_fts");
+        this.db.exec(`
+          CREATE VIRTUAL TABLE chunks_fts USING fts5(
+            summary, content, content='chunks', content_rowid='rowid',
+            tokenize='trigram'
+          )
+        `);
+        this.db.exec(`
+          CREATE TRIGGER chunks_ai AFTER INSERT ON chunks BEGIN
+            INSERT INTO chunks_fts(rowid, summary, content) VALUES (new.rowid, new.summary, new.content);
+          END;
+          CREATE TRIGGER chunks_ad AFTER DELETE ON chunks BEGIN
+            INSERT INTO chunks_fts(chunks_fts, rowid, summary, content) VALUES ('delete', old.rowid, old.summary, old.content);
+          END;
+          CREATE TRIGGER chunks_au AFTER UPDATE ON chunks BEGIN
+            INSERT INTO chunks_fts(chunks_fts, rowid, summary, content) VALUES ('delete', old.rowid, old.summary, old.content);
+            INSERT INTO chunks_fts(rowid, summary, content) VALUES (new.rowid, new.summary, new.content);
+          END
+        `);
+        this.db.exec("INSERT INTO chunks_fts(rowid, summary, content) SELECT rowid, summary, content FROM chunks");
+        const count = (this.db.prepare("SELECT COUNT(*) as c FROM chunks_fts").get() as { c: number }).c;
+        this.log.info(`Migrated chunks_fts to trigram: ${count} rows indexed`);
+      }
+    } catch (err) {
+      this.log.warn(`Failed to migrate chunks_fts to trigram: ${err}`);
+    }
+
+    // Same for skills_fts
+    try {
+      const row = this.db.prepare(
+        "SELECT sql FROM sqlite_master WHERE name='skills_fts'"
+      ).get() as { sql: string } | undefined;
+      if (row && row.sql && !row.sql.includes("trigram")) {
+        this.log.info("Migrating skills_fts to trigram tokenizer...");
+        this.db.exec("DROP TRIGGER IF EXISTS skills_ai");
+        this.db.exec("DROP TRIGGER IF EXISTS skills_ad");
+        this.db.exec("DROP TRIGGER IF EXISTS skills_au");
+        this.db.exec("DROP TABLE IF EXISTS skills_fts");
+        this.db.exec(`
+          CREATE VIRTUAL TABLE skills_fts USING fts5(
+            name, description, content='skills', content_rowid='rowid',
+            tokenize='trigram'
+          )
+        `);
+        this.db.exec(`
+          CREATE TRIGGER skills_ai AFTER INSERT ON skills BEGIN
+            INSERT INTO skills_fts(rowid, name, description) VALUES (new.rowid, new.name, new.description);
+          END;
+          CREATE TRIGGER skills_ad AFTER DELETE ON skills BEGIN
+            INSERT INTO skills_fts(skills_fts, rowid, name, description) VALUES ('delete', old.rowid, old.name, old.description);
+          END;
+          CREATE TRIGGER skills_au AFTER UPDATE ON skills BEGIN
+            INSERT INTO skills_fts(skills_fts, rowid, name, description) VALUES ('delete', old.rowid, old.name, old.description);
+            INSERT INTO skills_fts(rowid, name, description) VALUES (new.rowid, new.name, new.description);
+          END
+        `);
+        this.db.exec("INSERT INTO skills_fts(rowid, name, description) SELECT rowid, name, description FROM skills");
+        this.log.info("Migrated skills_fts to trigram");
+      }
+    } catch (err) {
+      this.log.warn(`Failed to migrate skills_fts to trigram: ${err}`);
+    }
+  }
+
   private migrateTaskId(): void {
     const cols = this.db.prepare("PRAGMA table_info(chunks)").all() as Array<{ name: string }>;
     if (!cols.some((c) => c.name === "task_id")) {
@@ -530,8 +606,6 @@ export class SqliteStore {
   getMetrics(days: number): {
     writesPerDay: Array<{ date: string; count: number }>;
     viewerCallsPerDay: Array<{ date: string; list: number; search: number; total: number }>;
-    roleBreakdown: Record<string, number>;
-    kindBreakdown: Record<string, number>;
     totals: { memories: number; sessions: number; embeddings: number; todayWrites: number; todayViewerCalls: number };
   } {
     const since = Date.now() - days * 86400 * 1000;
@@ -566,11 +640,6 @@ export class SqliteStore {
       .sort((a, b) => a[0].localeCompare(b[0]))
       .map(([date, v]) => ({ date, list: v.list, search: v.search, total: v.list + v.search }));
 
-    const roles = this.db.prepare("SELECT role, COUNT(*) as count FROM chunks GROUP BY role").all() as Array<{ role: string; count: number }>;
-    const kinds = this.db.prepare("SELECT kind, COUNT(*) as count FROM chunks GROUP BY kind").all() as Array<{ kind: string; count: number }>;
-    const roleBreakdown = Object.fromEntries(roles.map((r) => [r.role, r.count]));
-    const kindBreakdown = Object.fromEntries(kinds.map((k) => [k.kind, k.count]));
-
     const totalChunks = (this.db.prepare("SELECT COUNT(*) as c FROM chunks").get() as { c: number }).c;
     const totalSessions = (this.db.prepare("SELECT COUNT(DISTINCT session_key) as c FROM chunks").get() as { c: number }).c;
     const totalEmbeddings = (this.db.prepare("SELECT COUNT(*) as c FROM embeddings").get() as { c: number }).c;
@@ -580,8 +649,6 @@ export class SqliteStore {
     return {
       writesPerDay,
       viewerCallsPerDay,
-      roleBreakdown,
-      kindBreakdown,
       totals: {
         memories: totalChunks,
         sessions: totalSessions,
@@ -870,6 +937,10 @@ export class SqliteStore {
       { sql: "content LIKE '%=== MemOS LONG-TERM MEMORY%'", reason: "MemOS legacy injection" },
       { sql: "content LIKE '%[MemOS Auto-Recall]%'", reason: "MemOS Auto-Recall injection" },
       { sql: "content LIKE '%## Memory system%No memories were automatically recalled%'", reason: "Memory system no-recall hint" },
+      { sql: "content LIKE '%## Retrieved memories from past conversations%CRITICAL INSTRUCTION%'", reason: "prependContext recall injection" },
+      { sql: "content LIKE '%VERIFIED facts the user previously shared%'", reason: "VERIFIED facts injection" },
+      { sql: "content LIKE '%<memos_system_instruction>%'", reason: "memos_system_instruction injection" },
+      { sql: "content LIKE '%📝 Related memories:%'", reason: "Related memories injection" },
     ];
     for (const { sql, reason } of patterns) {
       const rows = this.db.prepare(
@@ -1103,14 +1174,16 @@ export class SqliteStore {
    */
   findActiveChunkByHash(content: string, owner?: string): string | null {
     const hash = contentHash(content);
+    // Check ANY existing chunk with the same hash (regardless of dedup_status)
+    // to prevent re-creating duplicates when all prior copies have been marked duplicate/merged.
     if (owner) {
       const row = this.db.prepare(
-        "SELECT id FROM chunks WHERE content_hash = ? AND dedup_status = 'active' AND owner = ? LIMIT 1",
+        "SELECT id FROM chunks WHERE content_hash = ? AND owner = ? ORDER BY CASE dedup_status WHEN 'active' THEN 0 ELSE 1 END LIMIT 1",
       ).get(hash, owner) as { id: string } | undefined;
       return row?.id ?? null;
     }
     const row = this.db.prepare(
-      "SELECT id FROM chunks WHERE content_hash = ? AND dedup_status = 'active' LIMIT 1",
+      "SELECT id FROM chunks WHERE content_hash = ? ORDER BY CASE dedup_status WHEN 'active' THEN 0 ELSE 1 END LIMIT 1",
     ).get(hash) as { id: string } | undefined;
     return row?.id ?? null;
   }
@@ -1365,14 +1438,13 @@ export class SqliteStore {
  * with implicit AND (space-separated) for safe querying.
  */
 function sanitizeFtsQuery(raw: string): string {
-  const tokens = raw
-    .replace(/[."""(){}[\]*:^~!@#$%&\\/<>,;'`]/g, " ")
-    .split(/\s+/)
-    .map((t) => t.trim().replace(/^-+|-+$/g, ""))
-    .filter((t) => t.length > 1)
-    .filter((t) => !FTS_RESERVED.has(t.toUpperCase()));
-
-  return tokens.join(" ");
+  // With trigram tokenizer, the query string is matched as a substring.
+  // Clean special chars but keep the text as-is (trigram needs >= 3 chars).
+  const cleaned = raw
+    .replace(/[."""(){}[\]*:^~!@#$%&\\/<>,;'`?？。，！、：""''（）【】《》]/g, " ")
+    .trim();
+  if (cleaned.length < 3) return "";
+  return cleaned;
 }
 
 const FTS_RESERVED = new Set(["AND", "OR", "NOT", "NEAR"]);

package/src/tools/memory-get.ts

@@ -47,10 +47,7 @@ export function createMemoryGetTool(store: SqliteStore): ToolDefinition {
         return { error: `Chunk not found: ${ref.chunkId}` };
       }
 
-      const content =
-        chunk.content.length > maxChars
-          ? chunk.content.slice(0, maxChars) + "…"
-          : chunk.content;
+      const content = chunk.content;
 
       const result: GetResult = {
         content,

package/src/types.ts

@@ -55,14 +55,7 @@ export interface Task {
   updatedAt: number;
 }
 
-export type ChunkKind =
-  | "paragraph"
-  | "code_block"
-  | "error_stack"
-  | "command"
-  | "list"
-  | "mixed"
-  | "tool_result";
+export type ChunkKind = "paragraph";
 
 export interface ChunkRef {
   sessionKey: string;
@@ -294,7 +287,7 @@ export const DEFAULTS = {
   mmrLambda: 0.7,
   recencyHalfLifeDays: 14,
   vectorSearchMaxChunks: 0,
-  dedupSimilarityThreshold: 0.60,
+  dedupSimilarityThreshold: 0.80,
   evidenceWrapperTag: "STORED_MEMORY",
   excerptMinChars: 200,
   excerptMaxChars: 500,