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

package/openclaw.plugin.json

@@ -4,6 +4,9 @@
   "description": "Full-write local conversation memory with hybrid search (RRF + MMR + recency). Provides memory_search, memory_get, task_summary, memory_timeline, memory_viewer for layered retrieval.",
   "kind": "memory",
   "version": "0.1.11",
+  "skills": [
+    "skill/memos-memory-guide"
+  ],
   "homepage": "https://github.com/MemTensor/MemOS/tree/main/apps/memos-local-openclaw",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memtensor/memos-local-openclaw-plugin",
-  "version": "1.0.2-beta.5",
+  "version": "1.0.2",
   "description": "MemOS Local memory plugin for OpenClaw — full-write, hybrid-recall, progressive retrieval",
   "type": "module",
   "main": "index.ts",
@@ -20,6 +20,9 @@
     "extensions": [
       "./index.ts"
     ],
+    "skills": [
+      "skill/memos-memory-guide"
+    ],
     "installDependencies": true
   },
   "scripts": {
@@ -49,6 +52,7 @@
     "better-sqlite3": "^12.6.2",
     "posthog-node": "^5.28.0",
     "puppeteer": "^24.38.0",
+    "semver": "^7.7.4",
     "uuid": "^10.0.0"
   },
   "devDependencies": {

package/scripts/postinstall.cjs

@@ -270,10 +270,77 @@ try {
 }
 
 /* ═══════════════════════════════════════════════════════════
- *  Phase 2: Verify better-sqlite3 native module
+ *  Phase 2: Install bundled skill (memos-memory-guide)
  * ═══════════════════════════════════════════════════════════ */
 
-phase(2, "检查 better-sqlite3 原生模块 / Check native module");
+function installBundledSkill() {
+  phase(2, "安装记忆技能 / Install memory skill");
+
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  if (!home) { warn("Cannot determine HOME directory, skipping skill install."); return; }
+
+  const skillSrc = path.join(pluginDir, "skill", "memos-memory-guide", "SKILL.md");
+  if (!fs.existsSync(skillSrc)) {
+    warn("Bundled SKILL.md not found, skipping skill install.");
+    return;
+  }
+
+  let pluginVersion = "0.0.0";
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(pluginDir, "package.json"), "utf-8"));
+    pluginVersion = pkg.version || pluginVersion;
+  } catch { /* ignore */ }
+
+  const skillContent = fs.readFileSync(skillSrc, "utf-8");
+  const targets = [
+    path.join(home, ".openclaw", "workspace", "skills", "memos-memory-guide"),
+    path.join(home, ".openclaw", "skills", "memos-memory-guide"),
+  ];
+
+  const meta = JSON.stringify({ ownerId: "memos-local-openclaw-plugin", slug: "memos-memory-guide", version: pluginVersion, publishedAt: Date.now() });
+  const origin = JSON.stringify({ version: 1, registry: "memos-local-openclaw-plugin", slug: "memos-memory-guide", installedVersion: pluginVersion, installedAt: Date.now() });
+
+  for (const dest of targets) {
+    try {
+      fs.mkdirSync(dest, { recursive: true });
+      fs.writeFileSync(path.join(dest, "SKILL.md"), skillContent, "utf-8");
+      fs.writeFileSync(path.join(dest, "_meta.json"), meta, "utf-8");
+      const clawHubDir = path.join(dest, ".clawhub");
+      fs.mkdirSync(clawHubDir, { recursive: true });
+      fs.writeFileSync(path.join(clawHubDir, "origin.json"), origin, "utf-8");
+      ok(`Skill installed → ${DIM}${dest}${RESET}`);
+    } catch (e) {
+      warn(`Could not install skill to ${dest}: ${e.message}`);
+    }
+  }
+
+  // Register in skills-lock.json so OpenClaw Dashboard can discover it
+  const lockPath = path.join(home, ".openclaw", "workspace", "skills-lock.json");
+  try {
+    let lockData = { version: 1, skills: {} };
+    if (fs.existsSync(lockPath)) {
+      lockData = JSON.parse(fs.readFileSync(lockPath, "utf-8"));
+    }
+    if (!lockData.skills) lockData.skills = {};
+    lockData.skills["memos-memory-guide"] = { source: "memos-local-openclaw-plugin", sourceType: "plugin", computedHash: "" };
+    fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2) + "\n", "utf-8");
+    ok("Registered in skills-lock.json");
+  } catch (e) {
+    warn(`Could not update skills-lock.json: ${e.message}`);
+  }
+}
+
+try {
+  installBundledSkill();
+} catch (e) {
+  warn(`Skill install error: ${e.message}`);
+}
+
+/* ═══════════════════════════════════════════════════════════
+ *  Phase 3: Verify better-sqlite3 native module
+ * ═══════════════════════════════════════════════════════════ */
+
+phase(3, "检查 better-sqlite3 原生模块 / Check native module");
 
 const sqliteModulePath = path.join(pluginDir, "node_modules", "better-sqlite3");
 

package/skill/memos-memory-guide/SKILL.md

@@ -1,6 +1,6 @@
 ---
 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, skill_search to discover public skills, memory_write_public for shared knowledge, and memory_timeline to expand around a memory hit.
+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. Available tools: memory_search, memory_get, memory_write_public, task_summary, skill_get, skill_search, skill_install, skill_publish, skill_unpublish, memory_timeline, memory_viewer."
 ---
 
 # MemOS Local Memory — Agent Guide
@@ -17,91 +17,119 @@ This skill describes how to use the MemOS memory tools so you can reliably searc
 
 ### 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`. Only returns memories belonging to the current agent or marked as public.
+- **What it does:** Search long-term conversation memory for past conversations, user preferences, decisions, and experiences. Returns relevant excerpts with `chunkId` and optionally `task_id`. Only returns memories belonging to the current agent or marked as public.
 - **When to call:**
   - The automatic recall did not run or returned nothing.
   - The user's query is long or unclear — **generate a short query yourself** and call `memory_search(query="...")`.
   - You need to search with a different angle (e.g. filter by `role='user'`).
-- **Parameters:** `query` (required), optional `minScore`, `role`.
+- **Parameters:**
+  - `query` (string, **required**) — Natural language search query.
+  - `maxResults` (number, optional) — Max results, default 20, max 20.
+  - `minScore` (number, optional) — Minimum score 0–1, default 0.45, floor 0.35.
+  - `role` (string, optional) — Filter by role: `'user'`, `'assistant'`, or `'tool'`. Use `'user'` to find what the user said.
+
+### memory_get
+
+- **What it does:** Get the full original text of a memory chunk. Use to verify exact details from a search hit.
+- **When to call:** A `memory_search` hit looks relevant but you need to see the complete original content, not just the summary/excerpt.
+- **Parameters:**
+  - `chunkId` (string, **required**) — The chunkId from a search hit.
+  - `maxChars` (number, optional) — Max characters to return (default 4000, max 12000).
 
 ### memory_write_public
 
-- **What it does:** Writes a piece of information to **public memory**. Public memory is visible to all agents — any agent doing `memory_search` can find it.
-- **When to call:** In multi-agent or collaborative scenarios, when you have **persistent information useful to everyone** (e.g. shared decisions, conventions, configurations, workflows). Do not write session-only or purely private content.
-- **Parameters:** `content` (required), `summary` (optional).
+- **What it does:** Write a piece of information to public memory. Public memories are visible to all agents during `memory_search`. Use for shared knowledge, team decisions, or cross-agent coordination information.
+- **When to call:** In multi-agent or collaborative scenarios, when you have persistent information useful to everyone (e.g. shared decisions, conventions, configurations, workflows). Do not write session-only or purely private content.
+- **Parameters:**
+  - `content` (string, **required**) — The content to write to public memory.
+  - `summary` (string, optional) — Short summary of the content.
 
 ### task_summary
 
-- **What it does:** Returns the full task summary for a given `task_id`: title, status, and the complete narrative summary.
-- **When to call:** A `memory_search` hit included a `task_id` and you need the full story of that task.
-- **Parameters:** `taskId` (from a search hit).
+- **What it does:** Get the detailed summary of a complete task: title, status, narrative summary, and related skills. Use when `memory_search` returns a hit with a `task_id` and you need the full story. Preserves critical information: URLs, file paths, commands, error codes, step-by-step instructions.
+- **When to call:** A `memory_search` hit included a `task_id` and you need the full context of that task.
+- **Parameters:**
+  - `taskId` (string, **required**) — The task_id from a memory_search hit.
 
 ### skill_get
 
-- **What it does:** Returns the content of a learned skill (experience guide) by `skillId` or by `taskId`.
+- **What it does:** Retrieve a proven skill (experience guide) by `skillId` or by `taskId`. If you pass a `taskId`, the system will find the associated skill automatically.
 - **When to call:** A search hit has a `task_id` and the task has a "how to do this again" guide. Use this to follow the same approach or reuse steps.
-- **Parameters:** `skillId` (direct) or `taskId` (lookup).
+- **Parameters:**
+  - `skillId` (string, optional) — Direct skill ID.
+  - `taskId` (string, optional) — Task ID — will look up the skill linked to this task.
+  - At least one of `skillId` or `taskId` must be provided.
 
 ### skill_search
 
-- **What it does:** Searches available **skills** (capabilities/guides) by natural language. Can search your own skills, other agents' public skills, or both — controlled by the `scope` parameter.
-- **When to call:** The current task requires a capability or guide you don't have. Use `skill_search` to find one first; after finding it, use `skill_get` to read it, then `skill_install` to load it for future turns. Set `scope` to `public` to only see others' public skills, `self` for only your own, or leave as default `mix` for both.
-- **Parameters:** `query` (required, natural language description of the need), `scope` (optional, default `mix`: self + public; `self`: own only; `public`: public only).
+- **What it does:** Search available skills by natural language. Searches your own skills, public skills, or both — controlled by the `scope` parameter.
+- **When to call:** The current task requires a capability or guide you don't have. Use `skill_search` to find one first; after finding it, use `skill_get` to read it, then `skill_install` to load it for future turns.
+- **Parameters:**
+  - `query` (string, **required**) — Natural language description of the needed skill.
+  - `scope` (string, optional) — Search scope: `'mix'` (default, self + public), `'self'` (own only), `'public'` (public only).
 
 ### skill_install
 
-- **What it does:** Installs a skill (by `skillId`) into the workspace for future sessions.
+- **What it does:** Install a learned skill into the agent workspace so it becomes permanently available. After installation, the skill will be loaded automatically in future sessions.
 - **When to call:** After `skill_get` when the skill is useful for ongoing use.
-- **Parameters:** `skillId`.
+- **Parameters:**
+  - `skillId` (string, **required**) — The skill ID to install.
 
 ### skill_publish
 
-- **What it does:** Makes a skill **public** so other agents can discover and install it via `skill_search`.
+- **What it does:** Make a skill public so other agents can discover and install it via `skill_search`.
 - **When to call:** You have a useful skill that other agents could benefit from, and you want to share it.
-- **Parameters:** `skillId`.
+- **Parameters:**
+  - `skillId` (string, **required**) — The skill ID to publish.
 
 ### skill_unpublish
 
-- **What it does:** Makes a skill **private** again. Other agents will no longer discover it.
+- **What it does:** Make a skill private again. Other agents will no longer be able to discover it.
 - **When to call:** You want to stop sharing a previously published skill.
-- **Parameters:** `skillId`.
+- **Parameters:**
+  - `skillId` (string, **required**) — The skill ID to unpublish.
 
 ### memory_timeline
 
-- **What it does:** Expands context around a single memory chunk: returns the surrounding conversation messages.
+- **What it does:** Expand context around a memory search hit. Pass the `chunkId` from a search result to read the surrounding conversation messages.
 - **When to call:** A `memory_search` hit is relevant but you need the surrounding dialogue.
-- **Parameters:** `chunkId` (from a search hit), optional `window` (default 2).
+- **Parameters:**
+  - `chunkId` (string, **required**) — The chunkId from a memory_search hit.
+  - `window` (number, optional) — Context window ±N messages, default 2.
 
 ### memory_viewer
 
-- **What it does:** Returns the URL of the MemOS Memory Viewer web dashboard.
-- **When to call:** The user asks how to view their memories or open the memory dashboard.
+- **What it does:** Show the MemOS Memory Viewer URL. Call this when the user asks how to view, browse, manage, or check their memories. Returns the URL the user can open in their browser.
+- **When to call:** The user asks where to see or manage their memories.
 - **Parameters:** None.
 
 ## Quick decision flow
 
 1. **No memories in context or auto-recall reported nothing**
-   → Call `memory_search` with a **self-generated short query**.
+   → Call `memory_search(query="...")` with a **self-generated short query**.
+
+2. **Need to see the full original text of a search hit**
+   → Call `memory_get(chunkId="...")`.
 
-2. **Search returned hits with `task_id` and you need full context**
-   → Call `task_summary(taskId)`.
+3. **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=...)`. Optionally `skill_install(skillId)` for future use.
+4. **Task has an experience guide you want to follow**
+   → Call `skill_get(taskId="...")` or `skill_get(skillId="...")`. Optionally `skill_install(skillId="...")` for future use.
 
-4. **You need the exact surrounding conversation of a hit**
-   → Call `memory_timeline(chunkId=...)`.
+5. **You need the exact surrounding conversation of a hit**
+   → Call `memory_timeline(chunkId="...")`.
 
-5. **You need a capability/guide that you don't have**
+6. **You need a capability/guide that you don't have**
    → Call `skill_search(query="...", scope="mix")` to discover available skills.
 
-6. **You have shared knowledge useful to all agents**
+7. **You have shared knowledge useful to all agents**
    → Call `memory_write_public(content="...")` to persist it in public memory.
 
-7. **You want to share a useful skill with other agents**
-   → Call `skill_publish(skillId=...)`.
+8. **You want to share/stop sharing a skill with other agents**
+   → Call `skill_publish(skillId="...")` or `skill_unpublish(skillId="...")`.
 
-8. **User asks where to see or manage their memories**
+9. **User asks where to see or manage their memories**
    → Call `memory_viewer()` and share the URL.
 
 ## Writing good search queries
@@ -110,3 +138,12 @@ This skill describes how to use the MemOS memory tools so you can reliably searc
 - Use **concrete terms**: names, topics, tools, or decisions.
 - 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.
+
+## Memory ownership and agent isolation
+
+Each memory is tagged with an `owner` (e.g. `agent:main`, `agent:sales-bot`). This is handled **automatically** — you do not need to pass any owner parameter.
+
+- **Your memories:** All tools (`memory_search`, `memory_get`, `memory_timeline`) automatically scope queries to your agent's own memories.
+- **Public memories:** Memories marked as `public` are visible to all agents. Use `memory_write_public` to write shared knowledge.
+- **Cross-agent isolation:** You cannot see memories owned by other agents (unless they are public).
+- **How it works:** The system identifies your agent ID from the OpenClaw runtime context and applies owner filtering automatically on every search, recall, and retrieval.

package/src/capture/index.ts

@@ -193,14 +193,58 @@ function stripMemoryInjection(text: string): string {
     "",
   ).trim();
 
-  // Mixed user+assistant content: "user question\n\n---\n\nassistant reply"
-  // Some older plugins merged entire turns into a single user message.
-  // Keep only the first segment (user's actual input).
-  const dashSep = cleaned.indexOf("\n\n---\n");
-  if (dashSep !== -1 && dashSep > 5) {
-    const firstPart = cleaned.slice(0, dashSep).trim();
-    if (firstPart.length >= 5) {
-      cleaned = firstPart;
+  // Old format: ## Retrieved memories from past conversations\n\nCRITICAL INSTRUCTION:...
+  const recallIdx = cleaned.indexOf("## Retrieved memories from past conversations");
+  if (recallIdx !== -1) {
+    const before = cleaned.slice(0, recallIdx);
+    const after = cleaned.slice(recallIdx);
+    const tsMatch = after.match(/\n\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\d{4}-\d{2}-\d{2}/);
+    if (tsMatch && tsMatch.index != null) {
+      cleaned = (before + after.slice(tsMatch.index)).trim();
+    } else {
+      cleaned = before.trim();
+    }
+  }
+
+  // prependContext format: ## User's conversation history (from memory system)\n...
+  // Ends at last "Current time:" line or last chunkId= line, whichever comes later.
+  const prependIdx = cleaned.indexOf("## User's conversation history (from memory system)");
+  if (prependIdx !== -1) {
+    const before = cleaned.slice(0, prependIdx);
+    const after = cleaned.slice(prependIdx);
+
+    // Find the last anchor line that belongs to the injected block
+    const currentTimeMatch = after.match(/Current time:[^\n]*/g);
+    const chunkIdMatch = after.match(/chunkId="[^"]*"/g);
+    let cutPos = 0;
+    if (currentTimeMatch) {
+      const lastCt = after.lastIndexOf(currentTimeMatch[currentTimeMatch.length - 1]);
+      const lineEnd = after.indexOf("\n", lastCt);
+      cutPos = Math.max(cutPos, lineEnd !== -1 ? lineEnd + 1 : after.length);
+    }
+    if (chunkIdMatch) {
+      const lastCk = after.lastIndexOf(chunkIdMatch[chunkIdMatch.length - 1]);
+      const lineEnd = after.indexOf("\n", lastCk);
+      cutPos = Math.max(cutPos, lineEnd !== -1 ? lineEnd + 1 : after.length);
+    }
+    if (cutPos === 0) {
+      // No anchors found; remove everything from the header onward
+      cleaned = before.trim();
+    } else {
+      cleaned = (before + after.slice(cutPos)).trim();
+    }
+  }
+
+  // New format: <memos_system_instruction>...</memos_system_instruction>\n\n📝 Related memories:...
+  const memosTagIdx = cleaned.indexOf("<memos_system_instruction>");
+  if (memosTagIdx !== -1) {
+    const before = cleaned.slice(0, memosTagIdx);
+    const after = cleaned.slice(memosTagIdx);
+    const tsMatch = after.match(/\n\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\d{4}-\d{2}-\d{2}/);
+    if (tsMatch && tsMatch.index != null) {
+      cleaned = (before + after.slice(tsMatch.index)).trim();
+    } else {
+      cleaned = before.trim();
     }
   }
 

package/src/ingest/chunker.ts

@@ -1,8 +1,6 @@
-import type { ChunkKind } from "../types";
-
 export interface RawChunk {
   content: string;
-  kind: ChunkKind;
+  kind: "paragraph";
 }
 
 const MAX_CHUNK_CHARS = 3000;
@@ -24,32 +22,27 @@ const COMMAND_LINE_RE = /^(?:\$|>|#)\s+.+$/gm;
  * Semantic-aware chunking:
  * 1. Extract fenced code blocks as whole units (never split inside)
  * 2. Detect unfenced code regions by brace-matching (functions/classes kept intact)
- * 3. Extract error stacks, list blocks, command lines
+ * 3. Extract error stacks, list blocks, command lines as separate chunks
  * 4. Split remaining prose at paragraph boundaries (double newline)
- * 5. Merge short adjacent chunks of the same kind
+ * 5. Merge short adjacent chunks
  */
 export function chunkText(text: string): RawChunk[] {
   let remaining = text;
-  const slots: Array<{ placeholder: string; chunk: RawChunk }> = [];
+  const slots: Array<{ placeholder: string; content: string }> = [];
   let counter = 0;
 
-  function ph(content: string, kind: ChunkKind): string {
+  function ph(content: string): string {
     const tag = `\x00SLOT_${counter++}\x00`;
-    slots.push({ placeholder: tag, chunk: { content: content.trim(), kind } });
+    slots.push({ placeholder: tag, content: content.trim() });
     return tag;
   }
 
-  remaining = remaining.replace(FENCED_CODE_RE, (m) => ph(m, "code_block"));
-
+  remaining = remaining.replace(FENCED_CODE_RE, (m) => ph(m));
   remaining = extractBraceBlocks(remaining, ph);
 
-  const structural: Array<{ re: RegExp; kind: ChunkKind }> = [
-    { re: ERROR_STACK_RE, kind: "error_stack" },
-    { re: LIST_BLOCK_RE, kind: "list" },
-    { re: COMMAND_LINE_RE, kind: "command" },
-  ];
-  for (const { re, kind } of structural) {
-    remaining = remaining.replace(re, (m) => ph(m, kind));
+  const structural: RegExp[] = [ERROR_STACK_RE, LIST_BLOCK_RE, COMMAND_LINE_RE];
+  for (const re of structural) {
+    remaining = remaining.replace(re, (m) => ph(m));
   }
 
   const raw: RawChunk[] = [];
@@ -64,7 +57,7 @@ export function chunkText(text: string): RawChunk[] {
       for (const part of parts) {
         const slot = slots.find((s) => s.placeholder === part);
         if (slot) {
-          raw.push(slot.chunk);
+          raw.push({ content: slot.content, kind: "paragraph" });
         } else if (part.trim().length >= MIN_CHUNK_CHARS) {
           raw.push({ content: part.trim(), kind: "paragraph" });
         }
@@ -75,8 +68,8 @@ export function chunkText(text: string): RawChunk[] {
   }
 
   for (const s of slots) {
-    if (!raw.some((c) => c.content === s.chunk.content)) {
-      raw.push(s.chunk);
+    if (!raw.some((c) => c.content === s.content)) {
+      raw.push({ content: s.content, kind: "paragraph" });
     }
   }
 
@@ -92,7 +85,7 @@ export function chunkText(text: string): RawChunk[] {
  */
 function extractBraceBlocks(
   text: string,
-  ph: (content: string, kind: ChunkKind) => string,
+  ph: (content: string) => string,
 ): string {
   const lines = text.split("\n");
   const result: string[] = [];
@@ -126,7 +119,7 @@ function extractBraceBlocks(
       if (depth <= 0 || (BLOCK_CLOSE_RE.test(line) && depth <= 0)) {
         const block = blockLines.join("\n");
         if (block.trim().length >= MIN_CHUNK_CHARS) {
-          result.push(ph(block, "code_block"));
+          result.push(ph(block));
         } else {
           result.push(block);
         }
@@ -142,7 +135,7 @@ function extractBraceBlocks(
   if (blockLines.length > 0) {
     const block = blockLines.join("\n");
     if (block.trim().length >= MIN_CHUNK_CHARS) {
-      result.push(ph(block, "code_block"));
+      result.push(ph(block));
     } else {
       result.push(block);
     }
@@ -171,11 +164,10 @@ function mergeSmallChunks(chunks: RawChunk[]): RawChunk[] {
       continue;
     }
 
-    const sameKind = buf.kind === c.kind;
     const bothSmall = buf.content.length < IDEAL_CHUNK_CHARS && c.content.length < IDEAL_CHUNK_CHARS;
     const mergedLen = buf.content.length + c.content.length + 2;
 
-    if (sameKind && bothSmall && mergedLen <= MAX_CHUNK_CHARS) {
+    if (bothSmall && mergedLen <= MAX_CHUNK_CHARS) {
       buf.content = buf.content + "\n\n" + c.content;
     } else {
       merged.push(buf);
@@ -189,29 +181,29 @@ function mergeSmallChunks(chunks: RawChunk[]): RawChunk[] {
 function splitOversized(chunks: RawChunk[]): RawChunk[] {
   const result: RawChunk[] = [];
   for (const c of chunks) {
-    if (c.content.length <= MAX_CHUNK_CHARS || c.kind === "code_block") {
+    if (c.content.length <= MAX_CHUNK_CHARS) {
       result.push(c);
       continue;
     }
-    result.push(...splitAtSentenceBoundary(c.content, c.kind));
+    result.push(...splitAtSentenceBoundary(c.content));
   }
   return result;
 }
 
-function splitAtSentenceBoundary(text: string, kind: ChunkKind): RawChunk[] {
+function splitAtSentenceBoundary(text: string): RawChunk[] {
   const sentences = text.match(/[^.!?。！？\n]+(?:[.!?。！？]+|\n{2,})/g) ?? [text];
   const result: RawChunk[] = [];
   let buf = "";
 
   for (const s of sentences) {
     if (buf.length + s.length > MAX_CHUNK_CHARS && buf.length > 0) {
-      result.push({ content: buf.trim(), kind });
+      result.push({ content: buf.trim(), kind: "paragraph" });
       buf = "";
     }
     buf += s;
   }
   if (buf.trim().length >= MIN_CHUNK_CHARS) {
-    result.push({ content: buf.trim(), kind });
+    result.push({ content: buf.trim(), kind: "paragraph" });
   }
   return result;
 }