thincoder 0.12.54 → 0.12.59

package/src/memory/core.mjs

@@ -4,8 +4,8 @@
 
 import { parseEntry, serializeEntry, entryFilename } from "../markdown.mjs"
 import { embed, cosine, toBlob, fromBlob } from "../embedding.mjs"
-import { readFile, stat, readdir, writeFile, mkdir } from "node:fs/promises"
-import { join } from "node:path"
+import { readFile, stat, readdir, writeFile, mkdir, unlink } from "node:fs/promises"
+import { join, resolve } from "node:path"
 import { segmentCJK, VALID_TYPES, SCHEMA_VERSION } from "./schema.mjs"
 
 const EMBED_BATCH_SIZE = 256
@@ -92,11 +92,11 @@ export function ftsSearch(memory, ftsQuery, limit) {
   const originFilter = memory.projectOrigin ? `AND (f.layer = 'team' OR f.origin = ?)` : ""
   const originParams = memory.projectOrigin ? [ftsQuery, memory.projectOrigin, limit] : [ftsQuery, limit]
   const files = memory.db.prepare(`
-    SELECT f.layer, f.path, f.type, f.title, f.content, f.tags, f.author, bm25(files_fts) AS rank
+    SELECT f.layer, f.origin, f.path, f.type, f.title, f.content, f.tags, f.author, bm25(files_fts) AS rank
     FROM files_fts JOIN files f ON f.rowid = files_fts.rowid
     WHERE files_fts MATCH ? ${originFilter}
     ORDER BY rank LIMIT ?
-  `).all(...originParams).map((r) => ({ ...r, id: `${r.layer}:${r.origin ?? ""}:${r.path}` }))
+  `).all(...originParams).map((r) => ({ ...r, id: `${r.layer}:${r.origin}:${r.path}` }))
 
   return [...personal, ...files].sort((a, b) => a.rank - b.rank).slice(0, limit)
 }
@@ -110,9 +110,12 @@ export function fetchEntry(memory, uid) {
     const r = memory.db.prepare(`SELECT id, type, title, content, tags FROM entries WHERE id = ?`).get(Number(rest[0]))
     return r ? { ...r, layer, id: uid } : null
   }
-  // rest = [origin, ...pathParts]; origin may be empty string (compat with old format)
-  const origin = rest[0] ?? ""
-  const path = rest.slice(1).join(":")
+  // Files branch: origins may contain colons (Windows drive letters, e.g. project:C:\dir:file.md),
+  // so the LAST colon is always the origin/path separator — same parsing as deleteByUid.
+  // origin may be empty (compat with the old `project::file.md` format).
+  const lastColon = uid.lastIndexOf(":")
+  const origin = lastColon > layer.length ? uid.slice(layer.length + 1, lastColon) : ""
+  const path = lastColon > layer.length ? uid.slice(lastColon + 1) : uid.slice(layer.length + 1)
   if (layer === "project" && memory.projectOrigin) {
     const r = memory.db.prepare(`SELECT type, title, content, tags, author FROM files WHERE layer = ? AND origin = ? AND path = ?`).get(layer, origin || memory.projectOrigin, path)
     if (r) return { ...r, layer, id: uid }
@@ -269,10 +272,201 @@ export async function list(memory, { type, limit = DEFAULT_LIST_LIMIT } = {}) {
     .all(limit)
 }
 
-/** Delete a memory entry. Returns whether deletion succeeded */
+/** LIKE pattern from a keyword (wildcards escaped — literal substring match, MEMORY.md §6 keyword filter). */
+function likePattern(keyword) {
+  return `%${keyword.replace(/[\\%_]/g, (c) => `\\${c}`)}%`
+}
+
+/**
+ * Shared row query for the §6 list action and the §6 batch delete (one match surface —
+ * rows carry { layer, id, type, title, ts }). Filters:
+ *   scope: "personal" | "project" | "team" | null (null = all layers)
+ *   type / keyword: optional (keyword matches title OR content, substring)
+ * Personal rows come from the entries table; project/team rows come from a DISK scan of
+ * the managed dir (2026-09-05 fix — disk is the truth): files present on disk but
+ * missing from the files index (orphans: external copies / gitmem pull / an earlier
+ * index failure) were invisible to list AND immune to batch delete — the old table-only
+ * match surface made a scope wipe need repeated delete rounds (deleteWhere→syncDir
+ * re-indexed the orphans one round later). Scanning disk keeps list and batch delete
+ * consistent with what the user can see and delete. Rows from other projects'/team
+ * repos' dirs stay out (the scan only covers the dirs this memory context manages).
+ * Malformed files are skipped (parseEntry failure — same semantics as syncDir). Sorted
+ * by ts (created/updated, ms) DESC.
+ */
+export async function matchMemoryRows(memory, { scope = null, type = null, keyword = null, projectDir = null, teamDir = null } = {}) {
+  const rows = []
+  const wantLayer = (l) => !scope || scope === l
+  if (wantLayer("personal")) {
+    let sql = `SELECT id, type, title, created_at AS ts FROM entries`
+    const cond = []
+    const params = []
+    if (type) { cond.push("type = ?"); params.push(type) }
+    if (keyword) { cond.push("(title LIKE ? ESCAPE '\\' OR content LIKE ? ESCAPE '\\')"); const p = likePattern(keyword); params.push(p, p) }
+    if (cond.length) sql += " WHERE " + cond.join(" AND ")
+    sql += " ORDER BY created_at DESC"
+    for (const r of memory.db.prepare(sql).all(...params)) {
+      rows.push({ layer: "personal", id: `personal:${r.id}`, uid: `personal:${r.id}`, type: r.type, title: r.title, ts: r.ts })
+    }
+  }
+  if (wantLayer("project") && projectDir) {
+    for (const r of await diskFileRows(projectDir, type, keyword)) rows.push({ ...r, layer: "project", id: `project:${projectDir}:${r.path}` })
+  }
+  if (wantLayer("team") && teamDir) {
+    for (const r of await diskFileRows(teamDir, type, keyword)) rows.push({ ...r, layer: "team", id: `team:${teamDir}:${r.path}` })
+  }
+  rows.sort((a, b) => (b.ts ?? 0) - (a.ts ?? 0))
+  return rows
+}
+
+/**
+ * Disk-truth file scan for the project/team layer (2026-09-05 fix — see matchMemoryRows):
+ * readdir + parse every .md entry in dir, filter by type equality and keyword substring
+ * on title OR content (case-insensitive — SQLite LIKE parity). ts = file mtime (ms).
+ * Rows come back WITHOUT the layer field — the caller stamps layer and builds the uid.
+ */
+async function diskFileRows(dir, type, keyword) {
+  let names
+  try {
+    names = (await readdir(dir)).filter((n) => n.endsWith(".md"))
+  } catch {
+    return []
+  }
+  const kw = keyword ? keyword.toLowerCase() : null
+  const out = []
+  for (const name of names) {
+    try {
+      const abs = join(dir, name)
+      const { meta, content } = parseEntry(await readFile(abs, "utf8"))
+      if (type && meta.type !== type) continue
+      if (kw && !(meta.title.toLowerCase().includes(kw) || content.toLowerCase().includes(kw))) continue
+      const mtime = Math.floor((await stat(abs)).mtimeMs)
+      out.push({ path: name, type: meta.type, title: meta.title, ts: mtime })
+    } catch (e) {
+      console.error(`[memory] skip ${name}: ${e.message}`)
+    }
+  }
+  out.sort((a, b) => b.ts - a.ts)
+  return out
+}
+
+/**
+ * §6 batch delete (action delete + type/keyword filter, confirm handled by the tool layer):
+ * deletes every row matchMemoryRows returns for the scope. Personal rows go straight to the
+ * DB (FTS + embedding cleanup via row triggers); project/team rows delete the markdown file
+ * (path containment enforced, ENOENT tolerated) then re-sync the layer dir once (index
+ * cleanup single source). Match surface = disk scan (2026-09-05 fix — orphans on disk
+ * with no index row are matched and deleted in the same pass; the trailing syncDir
+ * re-indexes the survivors). Team deletion never touches git — a later gitmem pull may
+ * resurrect the file while the remote still has it (same semantics as deleteByUid).
+ * Returns the number of deleted rows.
+ */
+export async function deleteWhere(memory, { scope, type = null, keyword = null } = {}, { dirs = {} } = {}) {
+  const rows = await matchMemoryRows(memory, { scope, type, keyword, projectDir: dirs.project ?? null, teamDir: dirs.team ?? null })
+  if (rows.length === 0) return 0
+  const personalIds = []
+  const byDir = new Map() // "layer\x00dir" → { layer, dir, paths: [] }
+  for (const r of rows) {
+    if (r.layer === "personal") {
+      const id = Number(String(r.uid).split(":")[1])
+      if (Number.isInteger(id)) personalIds.push(id)
+      continue
+    }
+    const dir = r.layer === "project" ? dirs.project : dirs.team
+    if (!dir) continue
+    const key = `${r.layer}\x00${dir}`
+    let group = byDir.get(key)
+    if (!group) { group = { layer: r.layer, dir, paths: [] }; byDir.set(key, group) }
+    group.paths.push(r.path)
+  }
+  const del = memory.db.prepare(`DELETE FROM entries WHERE id = ?`)
+  for (const id of personalIds) del.run(id)
+  for (const group of byDir.values()) {
+    for (const path of group.paths) {
+      assertPathInside(group.dir, path)
+      const abs = join(group.dir, path)
+      await unlink(abs).catch((e) => { if (e.code !== "ENOENT") throw e })
+    }
+    await syncDir(memory, { layer: group.layer, dir: group.dir })
+  }
+  return rows.length
+}
+
+/** §6 clear action: wipe ALL personal entries (pure DB rows — files are project/team only).
+ *  FTS + embedding go with the row triggers. Returns the number of deleted rows. */
+export function clearPersonal(memory) {
+  const { changes } = memory.db.prepare(`DELETE FROM entries`).run()
+  return changes
+}
+
+/** Delete a memory entry by unified id. Returns the deleted entry (F3: { id, layer, type, title, content, tags }).
+ *  - personal:<n> (or bare <n>) → DELETE the entries row; FTS syncs via the entries_ad trigger and the
+ *    embedding BLOB column goes with the row.
+ *  - project:<origin>:<path> / team:<origin>:<path> → delete the markdown file (path must resolve inside
+ *    the layer dir — dirs[layer], passed by the caller — `..`/absolute variants (incl. `..\`) are rejected),
+ *    then syncDir clears the files row (single source of index cleanup). ENOENT on the file is treated as
+ *    already-deleted and continues. Team deletion never touches git (git propagation is gitmem's job; a
+ *    later gitmem pull may resurrect the file while the remote still has it).
+ *  Throws on invalid id / missing entry (NF2) / path escaping the layer dir. */
+export async function deleteByUid(memory, uid, { dirs = {} } = {}) {
+  const norm = /^\d+$/.test(uid) ? `personal:${uid}` : String(uid)
+  const [layer, ...rest] = norm.split(":")
+  if (layer === "personal") {
+    const id = rest[0] ?? ""
+    if (!/^\d+$/.test(id)) throw new Error(`invalid memory id: ${norm}`)
+    const entry = fetchEntry(memory, norm)
+    if (!entry) throw new Error(`memory ${norm} not found in scope personal`)
+    memory.db.prepare(`DELETE FROM entries WHERE id = ?`).run(Number(id))
+    return entry
+  }
+  if (layer !== "project" && layer !== "team") throw new Error(`invalid memory id: ${norm}`)
+  const dir = dirs[layer]
+  if (!dir) throw new Error(`${layer} scope unavailable: no ${layer} directory configured`)
+  // path = segment after the LAST colon — origins may contain colons (Windows drive letters)
+  const lastColon = norm.lastIndexOf(":")
+  const path = lastColon > layer.length ? norm.slice(lastColon + 1) : norm.slice(layer.length + 1)
+  assertPathInside(dir, path)
+  let entry = fetchFileEntry(memory, layer, norm, path)
+  const abs = join(dir, path)
+  let fileExists = false
+  try { await stat(abs); fileExists = true } catch { /* ENOENT — treat as already deleted */ }
+  if (!entry && fileExists) {
+    try {
+      const { meta, content } = parseEntry(await readFile(abs, "utf8"))
+      entry = { layer, id: norm, type: meta.type, title: meta.title, content, tags: meta.tags.join(" ") }
+    } catch { /* malformed file — keep the DB row (or null → not found below) */ }
+  }
+  if (!entry) throw new Error(`memory ${norm} not found in scope ${layer}`)
+  if (fileExists) await unlink(abs).catch((e) => { if (e.code !== "ENOENT") throw e })
+  await syncDir(memory, { layer, dir })
+  return entry
+}
+
+/** Legacy personal-only delete (bare numeric id) — kept as the compat surface over deleteByUid. */
 export async function remove(memory, id) {
-  const info = memory.db.prepare(`DELETE FROM entries WHERE id = ?`).run(id)
-  return info.changes > 0
+  const uid = /^\d+$/.test(String(id)) ? `personal:${id}` : String(id)
+  if (!fetchEntry(memory, uid)) return false
+  await deleteByUid(memory, uid, {})
+  return true
+}
+
+/** Fetch a project/team file row for deletion: fetchEntry first, then a path-only fallback
+ *  (origins with Windows drive letters, e.g. project:C:\dir:file.md, break naive ":" splitting). */
+function fetchFileEntry(memory, layer, uid, path) {
+  const entry = fetchEntry(memory, uid)
+  if (entry) return entry
+  const r = memory.db.prepare(`SELECT type, title, content, tags, author FROM files WHERE layer = ? AND path = ?`).get(layer, path)
+  return r ? { ...r, layer, id: uid } : null
+}
+
+/** Separator-agnostic containment check: the resolved path must stay inside dir.
+ *  Both / and \ count as separators, so Windows-style traversal (..\..\x) is caught on every platform. */
+function assertPathInside(dir, path) {
+  if (!path) throw new Error(`invalid memory id: empty path`)
+  const base = resolve(dir).replaceAll("\\", "/")
+  const abs = resolve(dir, path.replaceAll("\\", "/")).replaceAll("\\", "/")
+  if (abs !== base && !abs.startsWith(base + "/")) {
+    throw new Error(`invalid memory path "${path}": must stay within ${dir}`)
+  }
 }
 
 /**

package/src/memory/docs.mjs

@@ -7,7 +7,7 @@ import { join } from "node:path"
 import { embed, cosine, toBlob, fromBlob } from "../embedding.mjs"
 import { commitAndPush } from "../git/gitmem.mjs"
 import { DOC_EXTS, SKIP_DIRS, MAX_DOC_FILE_BYTES } from "./schema.mjs"
-import { buildFtsQuery, put, search, putMarkdown, EMBED_TEXT_MAX_LEN } from "./core.mjs"
+import { buildFtsQuery, put, search, putMarkdown, deleteByUid, matchMemoryRows, deleteWhere, clearPersonal, EMBED_TEXT_MAX_LEN } from "./core.mjs"
 import { _upsertDocFile, yieldTick } from "./code-index.mjs"
 import { markIndexedCommit, listProjectFiles } from "./code-sync.mjs"
 
@@ -164,7 +164,8 @@ export function docSearchTool(memory) {
   return {
     name: "doc_search",
     description:
-      "Search the project's documentation (README, design docs, guides, markdown files) for relevant information. Use this to find design decisions, coding conventions, architecture docs, or project rules. Prefer this over code_search when you need to understand the project's intended design rather than existing implementation.",
+      "Search the project's documentation (README, design docs, guides, markdown files) for relevant information. Use this to find design decisions, coding conventions, architecture docs, or project rules. Prefer this over code_search when you need to understand the project's intended design rather than existing implementation. " +
+      "Returns matching doc chunks: path, heading, line range, relevance score, content excerpt.",
     parameters: {
       type: "object",
       properties: {
@@ -186,83 +187,217 @@ export function docSearchTool(memory) {
 
 // ---------------------------------------------------------------- agent tools
 
+/** §6 shared tool surface — action enum / parameter shapes / descriptions byte-identical
+ *  with thincoder-vscode/src/memory.mjs (MEMORY.md §6 D-M1/F-M6); scope VALUES per end
+ *  (VS Code has no team layer and rejects it with CLI guidance). */
+const MEMORY_ACTIONS = ["search", "put", "list", "delete", "clear"]
+const MEMORY_SCOPES = ["personal", "project", "team"]
+const MEMORY_TOOL_DESCRIPTION =
+  "Manage long-term memory in ONE tool — the action parameter picks the operation:\n" +
+  "- search — find knowledge saved in previous sessions (query, optional scope/limit); results include every entry's id\n" +
+  "- put — save a piece of knowledge for future sessions (type: rule = coding standards, knowledge = project facts, decision = architecture decisions, pattern = debugging/workflow patterns; title/content/tags/scope)\n" +
+  "- list — inventory what memory holds: optional scope/type/keyword filters, limit default 50; one row per entry: id [type] title (date); a truncated list notes the full count\n" +
+  "- delete — SINGLE: {id, scope} deletes one entry by the id shown in put/search/list output. BATCH: {scope + type and/or keyword} deletes every matching entry in that scope — a call without confirm:true is refused and returns the count plus a preview (re-send with confirm:true to execute); scope-wide wipes without filters are refused on every layer\n" +
+  "- clear — {scope: \"personal\", confirm: true} wipes ALL personal memory entries. clear is personal-only: a missing scope or a project/team scope is refused (use delete batch filters on shared layers)\n" +
+  "Deleting project/team (CLI) entries removes the local markdown file and its index row — team deletion is local only and a later team sync may resurrect the file while the remote still has it.\n" +
+  "Save bugs, conventions, and preferences here — they persist across sessions."
+
+function validateTypeFilter(type) {
+  if (type === undefined || type === null || type === "") return null
+  const t = String(type)
+  if (!["rule", "knowledge", "decision", "pattern"].includes(t)) throw new Error(`Invalid memory type "${t}"; expected one of: rule, knowledge, decision, pattern`)
+  return t
+}
+
+function normalizeLimit(limit, dflt) {
+  const n = Number(limit)
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : dflt
+}
+
+function fmtDate(ts) {
+  return ts ? new Date(ts).toISOString().slice(0, 10) : "?"
+}
+
+const listRowLine = (r) => `${r.id} [${r.type}] ${r.title}（${fmtDate(r.ts)}）`
+
 /**
- * Generate the two memory-related agent tools (following the tools.mjs tool shape).
- * memory_put is a side-effecting tool (needs permission confirmation), memory_search is read-only.
+ * Generate the memory agent tool — ONE `memory` tool with five actions (MEMORY.md §6 D-M1).
+ * search/list are read-only actions (planMode pass / no permission ask — dispatch classifies
+ * them action-level, same as subagent check/status); put keeps its side-effect permission
+ * gate; batch delete/clear gate on confirm:true + scope inside the tool (direct-delete
+ * ruling — the confirm parameter IS the gate) and stay non-readonly like the retired tools.
  * opts: { cwd, projectDir, author, team: { dir, name } | null }
  */
 export function memoryTools(memory, opts = {}) {
   const projectDir = opts.projectDir ? join(opts.cwd ?? process.cwd(), opts.projectDir) : null
+  const dirs = { project: projectDir, team: opts.team?.dir ?? null }
   return [
     {
-      name: "memory_put",
-      description:
-        "Save a piece of knowledge to long-term memory. Use when you learn something worth remembering across sessions: a project convention, a debugging insight, an architecture decision. Types: rule (coding standards), knowledge (project facts), decision (architecture decisions), pattern (debugging/workflow patterns). Scopes: personal (default, private to you), project (shared via this repo's .thincoder/memory/), team (org-wide team repo, if configured).",
+      name: "memory",
+      description: MEMORY_TOOL_DESCRIPTION,
       parameters: {
         type: "object",
         properties: {
-          type: { type: "string", enum: ["rule", "knowledge", "decision", "pattern"] },
-          title: { type: "string", description: "Short title" },
-          content: { type: "string", description: "Full content to remember" },
-          tags: { type: "string", description: "Space-separated tags" },
-          scope: { type: "string", enum: ["personal", "project", "team"], description: "Where to save (default personal)" },
+          action: { type: "string", enum: MEMORY_ACTIONS, description: "Operation to run (required)" },
+          scope: { type: "string", enum: MEMORY_SCOPES, description: "Where the memory lives: personal (private), project (shared via this repo's .thincoder/memory/), team (CLI only). put defaults to personal; search/list search every layer when omitted; delete/clear require it" },
+          type: { type: "string", enum: ["rule", "knowledge", "decision", "pattern"], description: "Entry type: put = what to save; list/delete batch = filter by type" },
+          title: { type: "string", description: "put: short title" },
+          content: { type: "string", description: "put: full content to remember" },
+          tags: { type: "string", description: "put: space-separated tags" },
+          query: { type: "string", description: "search: natural-language query" },
+          keyword: { type: "string", description: "list/delete batch: filter matching title/content" },
+          id: { type: "string", description: "delete single: the entry id from put/search/list output" },
+          limit: { type: "number", description: "Max rows: list 50 by default, search 5 by default" },
+          confirm: { type: "boolean", description: "delete batch/clear: must be true — without it the tool refuses" },
         },
-        required: ["type", "title", "content"],
+        required: ["action"],
       },
       readonly: false,
       async execute(args) {
-        const scope = args.scope ?? "personal"
-        if (scope === "personal") {
-          const id = await put(memory, args)
-          return `Saved to personal memory (id=${id}): [${args.type}] ${args.title}`
+        const action = String(args?.action ?? "")
+        if (!MEMORY_ACTIONS.includes(action)) {
+          throw new Error(`memory: unknown action "${action}" — expected one of: ${MEMORY_ACTIONS.join("/")}`)
         }
-        if (scope === "project") {
-          if (!projectDir) throw new Error("project scope unavailable: no project directory configured")
-          const filename = await putMarkdown(memory, {
-            layer: "project",
-            dir: projectDir,
-            type: args.type,
-            title: args.title,
-            content: args.content,
-            tags: (args.tags ?? "").split(/\s+/).filter(Boolean),
-            author: opts.author ?? "unknown",
-          })
-          return `Saved to project memory (${filename}): [${args.type}] ${args.title}`
+        switch (action) {
+          case "search": return execSearch(memory, args)
+          case "put": return execPut(memory, args, opts, dirs)
+          case "list": return execList(memory, args, dirs)
+          case "delete": return execDelete(memory, args, dirs)
+          case "clear": return execClear(memory, args)
         }
-        if (!opts.team?.dir) {
-          throw new Error("team scope not configured: set memory.team in ~/.thincoder/config.json")
-        }
-        const filename = await putMarkdown(memory, {
-          layer: "team",
-          dir: opts.team.dir,
-          type: args.type,
-          title: args.title,
-          content: args.content,
-          tags: (args.tags ?? "").split(/\s+/).filter(Boolean),
-          author: opts.author ?? "unknown",
-        })
-        await commitAndPush(opts.team.dir, filename, `memory: [${args.type}] ${args.title}`)
-        return `Saved to team memory and pushed (${filename}): [${args.type}] ${args.title}`
-      },
-    },
-    {
-      name: "memory_search",
-      description:
-        "Search long-term memory across all layers (personal/project/team) for relevant knowledge saved in previous sessions. Use the same language as the memories being searched.",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Natural language search query" },
-          limit: { type: "number", description: "Max results (default 5)" },
-        },
-        required: ["query"],
-      },
-      readonly: true,
-      async execute(args) {
-        const results = await search(memory, args.query, { limit: args.limit ?? 5 })
-        if (results.length === 0) return "(no matching memories)"
-        return results.map((r) => `[${r.layer}][${r.type}] ${r.title}\n${r.content}`).join("\n\n")
       },
     },
   ]
 }
+
+/** action search — the retired search tool surface (read-only, same output contract). */
+async function execSearch(memory, args) {
+  const scope = args.scope
+  if (scope !== undefined && scope !== null && !MEMORY_SCOPES.includes(String(scope))) {
+    throw new Error(`memory search: invalid scope "${scope}"`)
+  }
+  const query = String(args.query ?? "").trim()
+  if (!query) return "(no matching memories)" // 空 query 短路——两端同语义（评审 code review #4）
+  const limit = normalizeLimit(args.limit, 5)
+  let results
+  if (!scope) {
+    results = await search(memory, query, { limit })
+  } else {
+    // scope filter: oversample then slice the requested layer (results keep global rank order).
+    // 窗口 = max(limit*4, 20) 是召回上限——大库 + 高 limit 时该层结果可能不足 limit（接受的取舍——评审 code review #3）
+    const wide = await search(memory, query, { limit: Math.max(limit * 4, 20) })
+    results = wide.filter((r) => r.layer === String(scope)).slice(0, limit)
+  }
+  if (results.length === 0) return "(no matching memories)"
+  return results.map((r) => `[${r.layer}][${r.type}] ${r.title} (id=${r.id})\n${r.content}`).join("\n\n")
+}
+
+/** action put — the retired put tool surface (side-effect gate, unchanged semantics). */
+async function execPut(memory, args, opts, dirs) {
+  const scope = String(args.scope ?? "personal")
+  if (!MEMORY_SCOPES.includes(scope)) throw new Error(`memory put: invalid scope "${scope}"`)
+  if (scope === "personal") {
+    const id = await put(memory, { type: args.type, title: args.title, content: args.content, tags: args.tags ?? "" })
+    return `Saved to personal memory (id=personal:${id}): [${args.type}] ${args.title}`
+  }
+  if (scope === "project") {
+    if (!dirs.project) throw new Error("project scope unavailable: no project directory configured")
+    const filename = await putMarkdown(memory, {
+      layer: "project",
+      dir: dirs.project,
+      type: args.type,
+      title: args.title,
+      content: args.content,
+      tags: (args.tags ?? "").split(/\s+/).filter(Boolean),
+      author: opts.author ?? "unknown",
+    })
+    return `Saved to project memory (id=project:${dirs.project}:${filename}): [${args.type}] ${args.title}`
+  }
+  if (!dirs.team) {
+    throw new Error("team scope not configured: set memory.team in ~/.thincoder/config.json")
+  }
+  const filename = await putMarkdown(memory, {
+    layer: "team",
+    dir: dirs.team,
+    type: args.type,
+    title: args.title,
+    content: args.content,
+    tags: (args.tags ?? "").split(/\s+/).filter(Boolean),
+    author: opts.author ?? "unknown",
+  })
+  await commitAndPush(dirs.team, filename, `memory: [${args.type}] ${args.title}`)
+  return `Saved to team memory and pushed (id=team:${dirs.team}:${filename}): [${args.type}] ${args.title}`
+}
+
+/** action list — new inventory action (read-only): scope/type/keyword filters + limit truncation note. */
+async function execList(memory, args, dirs) {
+  const scope = args.scope ?? null
+  if (scope && !MEMORY_SCOPES.includes(String(scope))) throw new Error(`memory list: invalid scope "${scope}"`)
+  const rows = await matchMemoryRows(memory, {
+    scope: scope ? String(scope) : null,
+    type: validateTypeFilter(args.type),
+    keyword: args.keyword ? String(args.keyword).trim() : null,
+    projectDir: dirs.project,
+    teamDir: dirs.team,
+  })
+  if (rows.length === 0) return "0 条匹配"
+  const limit = normalizeLimit(args.limit, 50)
+  const shown = rows.slice(0, limit)
+  const lines = shown.map(listRowLine)
+  if (rows.length > shown.length) lines.unshift(`${shown.length} 条——截断前 ${rows.length}`)
+  return lines.join("\n")
+}
+
+/** action delete — single ({ id, scope } — §0.1-era single-delete semantics) + batch (scope + type/keyword + confirm). */
+async function execDelete(memory, args, dirs) {
+  const hasId = args.id !== undefined && args.id !== null && String(args.id) !== ""
+  if (hasId) return execDeleteSingle(memory, args, dirs)
+  // batch form
+  const scope = args.scope
+  if (!scope) throw new Error("batch delete requires scope plus type and/or keyword filter")
+  if (!MEMORY_SCOPES.includes(String(scope))) throw new Error(`memory delete: invalid scope "${scope}"`)
+  const type = validateTypeFilter(args.type)
+  const keyword = args.keyword ? String(args.keyword).trim() : null
+  if (!type && !keyword) {
+    throw new Error("batch delete requires type and/or keyword filter — a scope-wide wipe without filters is refused (personal full wipe is the clear action)")
+  }
+  if (scope === "project" && !dirs.project) throw new Error("project scope unavailable: no project directory configured")
+  if (scope === "team" && !dirs.team) throw new Error("team scope not configured: set memory.team in ~/.thincoder/config.json")
+  const filters = { scope: String(scope), type, keyword }
+  const rows = await matchMemoryRows(memory, { ...filters, projectDir: dirs.project, teamDir: dirs.team })
+  if (rows.length === 0) return "0 条匹配"
+  if (args.confirm !== true) {
+    const lines = [rows.length > 5 ? `将删 ${rows.length} 条：前 5 条预览` : `将删 ${rows.length} 条`]
+    lines.push(...rows.slice(0, 5).map(listRowLine))
+    if (rows.length > 5) lines.push(`5 条——截断前 ${rows.length}`)
+    lines.push("confirm:true required — re-send with it to execute the deletion")
+    return lines.join("\n")
+  }
+  const n = await deleteWhere(memory, filters, { dirs })
+  return `Deleted ${n} entries in scope ${scope}`
+}
+
+/** Single-entry delete — §0.1-era delete semantics (id + scope, NF2/NF3, direct-delete ruling). */
+async function execDeleteSingle(memory, args, dirs) {
+  if (!args.scope) throw new Error("delete requires id + scope")
+  const uid = String(args.id)
+  const prefix = uid.split(":")[0]
+  const uidScope = prefix === "personal" || prefix === "project" || prefix === "team" ? prefix : /^\d+$/.test(prefix) ? "personal" : null
+  if (!uidScope) throw new Error(`invalid memory id: ${uid}`)
+  if (uidScope !== args.scope) throw new Error(`id prefix ${prefix}: 与 scope ${args.scope} 不匹配`)
+  const entry = await deleteByUid(memory, uid, { dirs })
+  return `Deleted ${entry.id}: ${entry.title}\n${(entry.content ?? "").slice(0, 500)}`
+}
+
+/** action clear — personal-only full wipe (scope + confirm:true gates; project/team refused). */
+function execClear(memory, args) {
+  const scope = args.scope
+  if (!scope) throw new Error('clear requires scope "personal" — pass scope: "personal" plus confirm: true')
+  if (String(scope) !== "personal") {
+    if (!MEMORY_SCOPES.includes(String(scope))) throw new Error(`memory clear: invalid scope "${scope}"`)
+    throw new Error("shared layers don't support clear — use delete with type/keyword batch filters instead")
+  }
+  if (args.confirm !== true) throw new Error("clear requires confirm:true — this wipes ALL personal memory")
+  const n = clearPersonal(memory)
+  return `Cleared personal memory (${n} entries deleted)`
+}

package/src/memory.mjs

@@ -7,7 +7,7 @@
 export { createMemory, migrate, segmentCJK, VALID_TYPES, SCHEMA_VERSION, CODE_EXTS, DOC_EXTS, SKIP_DIRS, BIG_FILE_LINES } from "./memory/schema.mjs"
 
 // CRUD + search + ensureEmbeddings
-export { put, search, ftsSearch, fetchEntry, ensureEmbeddings, putMarkdown, syncDir, indexMarkdownFile, list, remove, buildFtsQuery } from "./memory/core.mjs"
+export { put, search, ftsSearch, fetchEntry, ensureEmbeddings, putMarkdown, syncDir, indexMarkdownFile, list, remove, deleteByUid, matchMemoryRows, deleteWhere, clearPersonal, buildFtsQuery } from "./memory/core.mjs"
 
 // code chunking + markdown chunking
 export { detectLanguage, extractSymbols, extractPySymbols, chunkCode, extractLeadingDoc, yieldTick, _upsertCodeFile, chunkMarkdown, _upsertDocFile } from "./memory/code-index.mjs"

package/src/model-specs.mjs

@@ -88,7 +88,13 @@ const MODEL_SPECS = [
 ]
 const DEFAULT_SPEC = { context: 128_000, maxOutput: 32_000, cacheMode: "none" }
 
-/** Look up spec by model name prefix (case-insensitive), conservative default for unknown models */
+/** Look up spec by model name prefix (case-insensitive), conservative default for unknown models.
+ *
+ * Vendor-namespace prefix stripping (2026-09-04)：第三方 token 市场（roapi/new-api/one-api/
+ * aiproxy 聚合网关）惯例在模型名前加厂商前缀（zhipu/glm-5.3、openai/gpt-4o）。完整名未命中
+ * 且含 "/" 时，剥掉第一个 "/" 前的 namespace 再按前缀匹配一次——ZHIPU/GLM-5.3 → glm-5.3 命中
+ * 真实规格，不再降级 128K 默认。kimi/kimi-k3 的显式 alias 行保留为文档锚（发送路径
+ * provider.core isRouter 依赖含 "/" 判定），通用机制已覆盖同类。 */
 const warnedModels = new Set() // warn once per model name — specForModel is a hot path (every request)
 // Pre-sorted once at module scope — specForModel runs on every request (agent, provider core,
 // context, auto-think, TUI rendering); re-sorting per call was wasteful.
@@ -98,6 +104,14 @@ export function specForModel(model) {
   for (const [prefix, spec] of SORTED_SPECS) {
     if (m.startsWith(prefix.toLowerCase())) return spec
   }
+  // Vendor-namespace strip: vendor/model — retry the prefix match on the bare model part.
+  const slash = m.indexOf("/")
+  if (slash > 0) {
+    const bare = m.slice(slash + 1)
+    for (const [prefix, spec] of SORTED_SPECS) {
+      if (bare.startsWith(prefix.toLowerCase())) return spec
+    }
+  }
   // Unknown model: warn ONCE (not per request) so a typo'd ID or a missing alias surfaces
   // instead of silently degrading to the 128K default (IK5VGJ).
   if (m && !warnedModels.has(m)) {
@@ -106,3 +120,26 @@ export function specForModel(model) {
   }
   return DEFAULT_SPEC
 }
+
+/**
+ * providerSpec(provider) — spec with a provider-level context override (PROVIDER.md §15, 2026-09-02).
+ *
+ * providers[].context is configured in K units (128 = 128K = 131072 tokens) and overrides the
+ * MODEL_SPECS value for THIS provider only — the same model can have different real context
+ * windows on different endpoints (official vs local deployment). The ×1024 conversion happens
+ * HERE and nowhere else.
+ *
+ * Returns a COPY ({ ...spec, context }) — the shared spec object from the SORTED_SPECS lookup
+ * must never be mutated, or the override would leak across providers (T-C1).
+ *
+ * Validation is defensive (pure function): absent/invalid context falls back to the plain spec
+ * (config.mjs loadConfig already warns + strips invalid values; this guard covers direct callers
+ * and keeps the function total). specForModel stays a pure table lookup — callers without a
+ * provider keep using it.
+ */
+export function providerSpec(provider) {
+  const spec = specForModel(provider?.model ?? "")
+  const k = Number(provider?.context) // Number() 接受数字字符串（"128"）——两端语义统一（code review #1）
+  if (Number.isInteger(k) && k > 0) return { ...spec, context: k * 1024 }
+  return spec
+}