@modusensus/dsh-mneme 0.7.5 → 0.7.6

package/dsh-mneme/src/service.js

@@ -1611,6 +1611,44 @@ export function createService({ store, mirror, config, onWrite, logger, settings
     count: (type, opts) => store.count(type, opts),
     stats: (opts) => store.stats(opts),
     getById: (id) => store.getById(id),
+    // issue #48: resolve a possibly-truncated id to its canonical full id.
+    // Exact hit wins; otherwise the input is treated as a prefix of the id
+    // PRIMARY KEY. Never guesses on ambiguity — returns the candidates and the
+    // caller must pass a full id. Outcome is {ok:true,id} or {ok:false,reason,
+    // message} with reason ∈ invalid | not-found | ambiguous. warnMiss logs the
+    // silent-miss case the delete tool previously swallowed (no return channel
+    // for it, so observability has to live here in the service layer).
+    resolveMemoryId: (input, { warnMiss = false } = {}) => {
+      const bad = (reason, message) => ({ ok: false, reason, message });
+      if (typeof input !== "string") return bad("invalid", "memory id is required");
+      // 手抄/上下文压缩来的 id 可能带首尾空白，统一 trim 后再做精确与前缀解析。
+      const id = input.trim();
+      if (!id) return bad("invalid", "memory id is required");
+      const exact = store.getById(id);
+      if (exact) return { ok: true, id: exact.id };
+      const matches = store.listByIdPrefix(id);
+      if (matches.length === 0) {
+        if (warnMiss) {
+          logger?.warn?.(
+            `[dsh-mneme] memory id "${id}" matched nothing (exact or prefix) — ` +
+            "no entry was deleted; ids are full-length, pass one from memory_list/memory_search output or delete by query=…"
+          );
+        }
+        return bad(
+          "not-found",
+          `memory not found: ${id} (checked exact id and prefix; use a full id from memory_list/memory_search output)`
+        );
+      }
+      if (matches.length > 1) {
+        const sample = matches.slice(0, 5).map((m) => m.id);
+        const tail = matches.length > sample.length ? ` …(+${matches.length - sample.length})` : "";
+        return bad(
+          "ambiguous",
+          `memory id prefix "${id}" matches ${matches.length} entries (${sample.join(", ")}${tail}); refusing to guess — pass a full id`
+        );
+      }
+      return { ok: true, id: matches[0].id };
+    },
     remove: (id) => {
       store.remove(id);
       afterSync("write");

package/dsh-mneme/src/store.js

@@ -697,6 +697,27 @@ export function createStore(path) {
     return toRow(row);
   }
 
+  /**
+   * issue #48: resolve a truncated id — as can leak through an agent's context
+   * window when list/search output is shortened — by matching it as a prefix of
+   * the id PRIMARY KEY. Exact lookups keep using getById; this only serves
+   * resolving a *candidate* id. Returns up to 51 rows so the caller can tell
+   * "unique" from "ambiguous" without a second query. LIKE wildcards are
+   * stripped from the input (a valid id fragment is hex/UUID text, never % or
+   * _). Prefix over a PK stays an index scan, so this is cheap even at scale.
+   */
+  function listByIdPrefix(idPrefix) {
+    if (typeof idPrefix !== "string" || !idPrefix.trim()) return [];
+    // LIKE 通配符不参与 id 匹配，一律剥掉。若剥完为空（如 id="%"），
+    // 不能让 SQL 退化成 `LIKE '%'` 全表命中——那会让单条记忆被误删，
+    // 一律视为无匹配返回。
+    const safe = idPrefix.replace(/[\\%_]/g, "");
+    if (!safe) return [];
+    const rows = db.prepare("SELECT * FROM memories WHERE id LIKE ? LIMIT 51")
+      .all(`${safe}%`);
+    return rows.map(toRow);
+  }
+
   /**
    * Case-insensitive exact title lookup (v0.6.1 wiki-link). COLLATE NOCASE
    * folds ASCII case (CJK titles are inherently case-free, so they match
@@ -2210,6 +2231,7 @@ export function createStore(path) {
     count,
     stats,
     getById,
+    listByIdPrefix,
     save,
     update,
     compareAndUpdate,

package/dsh-mneme/src/tools.js

@@ -302,7 +302,7 @@ export function createTools(ctx, service, config, embedder) {
       name: "memory_update",
       description: "Modify an existing memory entry (title, content, type, tags, importance).",
       parameters: {
-        id: { type: "string", required: true, description: "Memory id" },
+        id: { type: "string", required: true, description: "Memory id (full id from memory_list/memory_search output, or a unique prefix of it)" },
         title: { type: "string" },
         content: { type: "string" },
         type: { type: "string", enum: ["preference", "project", "decision", "history", "user", "fact"] },
@@ -329,7 +329,9 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(`Updated memory ${value.memory.id}: ${value.memory.title}`)
       },
       async execute(args) {
-        const memory = service.update(args.id, {
+        const resolved = service.resolveMemoryId(args.id);
+        if (!resolved.ok) throw new Error(resolved.message);
+        const memory = service.update(resolved.id, {
           title: args.title,
           content: args.content,
           type: args.type,
@@ -342,9 +344,9 @@ export function createTools(ctx, service, config, embedder) {
 
     defineTool({
       name: "memory_delete",
-      description: "Permanently delete a memory entry. Pass id for exact delete, or query to delete the single best-matching entry by text — lets the agent honor 'delete the memory about X' without a prior list/search round trip.",
+      description: "Permanently delete a memory entry. Pass id for exact delete (full id, or a unique prefix of it — ambiguous prefixes are rejected), or query to delete the single best-matching entry by text — lets the agent honor 'delete the memory about X' without a prior list/search round trip. An id that matches nothing is logged as a warning instead of failing silently.",
       parameters: {
-        id: { type: "string", description: "Exact memory id to delete (from memory_list/memory_search output)" },
+        id: { type: "string", description: "Memory id to delete: full id (from memory_list/memory_search output) or a unique prefix of it; a miss is logged (warn) and returns deleted:false" },
         query: { type: "string", description: "Delete the best-matching entry for this text (searches title/content/tags; uses hybrid recall when an embedder is configured)" }
       },
       output: {
@@ -353,13 +355,19 @@ export function createTools(ctx, service, config, embedder) {
           additionalProperties: false,
           properties: { deleted: { type: "boolean", required: true } }
         },
-        render: (_args, value) => TEXT_OUTPUT(value.deleted ? "Memory deleted." : "Memory not found.")
+        render: (_args, value) => TEXT_OUTPUT(value.deleted
+          ? "Memory deleted."
+          : "Memory not found — nothing was deleted. Pass a full id (or a unique prefix) from memory_list/memory_search output, or delete by query=… instead.")
       },
       async execute(args) {
         if (args.id) {
-          const existed = service.getById(args.id) !== undefined;
-          if (existed) service.remove(args.id);
-          return { deleted: existed };
+          const resolved = service.resolveMemoryId(args.id, { warnMiss: true });
+          if (!resolved.ok) {
+            if (resolved.reason === "ambiguous") throw new Error(resolved.message);
+            return { deleted: false };
+          }
+          service.remove(resolved.id);
+          return { deleted: true };
         }
         if (args.query) {
           const [best] = await service.searchMemories(args.query, { mode: "auto", topK: 1, useRerank: true });
@@ -378,7 +386,7 @@ export function createTools(ctx, service, config, embedder) {
         "Stop a memory from being auto-injected and from appearing in searches and lists without deleting it. " +
         "The entry stays in storage; pass forgotten: false to restore it.",
       parameters: {
-        id: { type: "string", required: true },
+        id: { type: "string", required: true, description: "Memory id: full id (from memory_list/memory_search output) or a unique prefix of it; ambiguous prefixes are rejected" },
         forgotten: { type: "boolean", description: "Suppress (true, default) or restore (false) the entry's visibility" }
       },
       output: {
@@ -399,10 +407,9 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(`Memory ${value.memory.id} injection ${value.memory.forgotten ? "suppressed" : "restored"}.`)
       },
       async execute(args) {
-        if (service.getById(args.id) === undefined) {
-          throw new Error("memory not found");
-        }
-        const memory = service.setForget(args.id, args.forgotten ?? true);
+        const resolved = service.resolveMemoryId(args.id);
+        if (!resolved.ok) throw new Error(resolved.message);
+        const memory = service.setForget(resolved.id, args.forgotten ?? true);
         return { memory: { id: memory.id, forgotten: memory.forgotten } };
       }
     }),
@@ -414,7 +421,7 @@ export function createTools(ctx, service, config, embedder) {
         "Archived entries stay in storage and are recoverable: pass archived=false to restore, and use memory_list with " +
         "include_archived=true to find archived entries.",
       parameters: {
-        id: { type: "string", required: true, description: "Memory id" },
+        id: { type: "string", required: true, description: "Memory id: full id (from memory_list/memory_search output) or a unique prefix of it; ambiguous prefixes are rejected" },
         archived: { type: "boolean", description: "Archive (true, default) or restore (false) the entry" }
       },
       output: {
@@ -435,10 +442,9 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(`Memory ${value.memory.id} ${value.memory.archived ? "archived" : "restored"}.`)
       },
       async execute(args) {
-        if (service.getById(args.id) === undefined) {
-          throw new Error("memory not found");
-        }
-        const memory = service.setArchived(args.id, args.archived ?? true);
+        const resolved = service.resolveMemoryId(args.id);
+        if (!resolved.ok) throw new Error(resolved.message);
+        const memory = service.setArchived(resolved.id, args.archived ?? true);
         return { memory: { id: memory.id, archived: memory.archived } };
       }
     })

package/dsh-mneme/test/client.test.js

@@ -5,7 +5,9 @@ import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
-const clientSource = readFileSync(join(root, "lib/client.js"), "utf8");
+// src/ is the single source of truth for every module (including the Web
+// client bundle); lib/ is build output produced by `npm run sync`.
+const clientSource = readFileSync(join(root, "src/client.js"), "utf8");
 const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
 
 // The Web client bundle registers itself via __ModuleLoader__.load. DSH
@@ -18,11 +20,14 @@ test("client bundle registers under the package name", () => {
   assert.equal(match[1], pkg.name, "registered id must equal package.json name");
 });
 
-// client.js is hand-authored under lib/ only (no src/ counterpart), so the
-// src->lib sync must never prune it.
-test("client bundle is lib-only with no src counterpart", () => {
-  assert.equal(existsSync(join(root, "src/client.js")), false, "src/ must not contain client.js");
+// client.js is authored under src/ like every other module; lib/client.js is
+// build output generated by `npm run sync` (prepack), so it must stay a
+// byte-identical copy — drift here means the sync wasn't run.
+test("client bundle is src-authored and synced into lib", () => {
+  assert.equal(existsSync(join(root, "src/client.js")), true, "src/client.js must exist");
   assert.equal(existsSync(join(root, "lib/client.js")), true, "lib/client.js must exist");
+  const libClient = readFileSync(join(root, "lib/client.js"), "utf8");
+  assert.equal(libClient, clientSource, "lib/client.js must equal src/client.js (run `npm run sync`)");
 });
 
 // The memory entry lives at the sidebar foot, not in the settings modal: the

package/dsh-mneme/test/tools.test.js

@@ -398,6 +398,139 @@ test("memory_delete on missing id returns deleted:false", async () => {
   assert.equal(result.deleted, false);
 });
 
+// --- issue #48: id resolution via unique prefix (delete/update/forget/archive) --
+
+test("memory_delete accepts a unique id prefix", async () => {
+  const id = "a1b2c3d4-0000-0000-0000-000000000001";
+  const { registered, store } = setup();
+  store.save({ id, type: "decision", title: "t", content: "c" });
+  const del = registered.find((t) => t.name === "memory_delete");
+  const result = await del.execute({ id: "a1b2c3d4" });
+  assert.equal(result.deleted, true);
+  assert.equal(store.getById(id), undefined, "entry is gone");
+  assert.equal(store.count(), 0);
+});
+
+test("memory_delete rejects an ambiguous id prefix without deleting", async () => {
+  const { registered, store } = setup();
+  store.save({ id: "deadbeef-0000-0000-0000-000000000001", type: "decision", title: "t1", content: "c" });
+  store.save({ id: "deadbeef-0000-0000-0000-000000000002", type: "decision", title: "t2", content: "c" });
+  const del = registered.find((t) => t.name === "memory_delete");
+  await assert.rejects(() => del.execute({ id: "deadbeef" }), /matches 2 entries.*refusing to guess/s);
+  assert.equal(store.count(), 2, "ambiguous prefix removes nothing");
+});
+
+test("memory_delete with a non-matching id prefix returns deleted:false and leaves data", async () => {
+  const { registered, store } = setup();
+  store.save({ id: "a1b2c3d4-0000-0000-0000-000000000001", type: "decision", title: "t", content: "c" });
+  const del = registered.find((t) => t.name === "memory_delete");
+  const result = await del.execute({ id: "ffffffff" });
+  assert.equal(result.deleted, false);
+  assert.equal(store.count(), 1, "nothing removed when the prefix matches nothing");
+});
+
+test("memory_update accepts a unique id prefix", async () => {
+  const { registered, service, store } = setup();
+  const { memory } = service.saveWithDedupe({ type: "decision", title: "t", content: "c" });
+  const update = registered.find((t) => t.name === "memory_update");
+  const result = await update.execute({ id: memory.id.slice(0, 8), content: "updated via prefix" });
+  assert.equal(result.memory.id, memory.id, "resolved to the full id");
+  assert.equal(store.getById(memory.id).content, "updated via prefix");
+});
+
+test("memory_update rejects an ambiguous id prefix", async () => {
+  const { registered, store } = setup();
+  store.save({ id: "cafe1234-0000-0000-0000-000000000001", type: "decision", title: "t1", content: "c" });
+  store.save({ id: "cafe1234-0000-0000-0000-000000000002", type: "decision", title: "t2", content: "c" });
+  const update = registered.find((t) => t.name === "memory_update");
+  await assert.rejects(() => update.execute({ id: "cafe1234", content: "x" }), /matches 2 entries.*refusing to guess/s);
+  assert.equal(store.getById("cafe1234-0000-0000-0000-000000000001").content, "c");
+});
+
+test("memory_forget accepts a unique id prefix and restores it", async () => {
+  const id = "facade01-0000-0000-0000-000000000001";
+  const { registered, store } = setup();
+  store.save({ id, type: "project", title: "t", content: "c", importance: 5 });
+  const forget = registered.find((t) => t.name === "memory_forget");
+  const result = await forget.execute({ id: "facade01" });
+  assert.equal(result.memory.id, id, "resolved to the full id");
+  assert.equal(result.memory.forgotten, true);
+  assert.equal(store.getById(id).forgotten, true);
+  const restored = await forget.execute({ id: "facade01", forgotten: false });
+  assert.equal(restored.memory.forgotten, false);
+});
+
+test("memory_archive accepts a unique id prefix and restores it", async () => {
+  const id = "arcade01-0000-0000-0000-000000000001";
+  const { registered, service, store } = setup();
+  store.save({ id, type: "project", title: "t", content: "c" });
+  const archive = registered.find((t) => t.name === "memory_archive");
+  const result = await archive.execute({ id: "arcade01" });
+  assert.equal(result.memory.id, id, "resolved to the full id");
+  assert.equal(result.memory.archived, true);
+  assert.ok(!service.list({ type: "project" }).some((x) => x.id === id), "archived hidden from default list");
+  const restored = await archive.execute({ id: "arcade01", archived: false });
+  assert.equal(restored.memory.archived, false);
+  assert.ok(service.list({ type: "project" }).some((x) => x.id === id), "restored entry visible again");
+});
+
+// Exact id match must win even when the same string is also a prefix of
+// another (custom/unequal-length ids): a full id is never "ambiguous" with
+// a longer one that merely starts with it.
+test("memory_delete prefers an exact id match over an identical-prefix collision", async () => {
+  const { registered, store } = setup();
+  store.save({ id: "abc", type: "decision", title: "short", content: "c" });
+  store.save({ id: "abc-def-000000000000000000000000001", type: "decision", title: "long", content: "c" });
+  const del = registered.find((t) => t.name === "memory_delete");
+  const result = await del.execute({ id: "abc" });
+  assert.equal(result.deleted, true);
+  assert.equal(store.getById("abc"), undefined, "exact-match entry removed");
+  assert.equal(store.count(), 1, "the longer id sharing the prefix stays");
+});
+
+// A wildcard-only id ("%", "_") strips to an empty prefix; it must never
+// degrade into a `LIKE '%'` table-wide match that deletes a lone memory.
+test("memory_delete with a wildcard-only id matches nothing and deletes nothing", async () => {
+  const { registered, store } = setup();
+  store.save({ id: "a1b2c3d4-0000-0000-0000-000000000001", type: "decision", title: "t", content: "c" });
+  const del = registered.find((t) => t.name === "memory_delete");
+  for (const wildcard of ["%", "_", "%_", "%%", "___"]) {
+    const result = await del.execute({ id: wildcard });
+    assert.equal(result.deleted, false, `id "${wildcard}" must not match the whole table`);
+  }
+  assert.equal(store.count(), 1, "nothing removed by wildcard-only ids");
+});
+
+// Hand-copied ids can carry surrounding whitespace; resolve against the
+// trimmed form so a padded id still reaches the right memory.
+test("memory_delete trims surrounding whitespace from the id", async () => {
+  const id = "a1b2c3d4-0000-0000-0000-000000000001";
+  const { registered, store } = setup();
+  store.save({ id, type: "decision", title: "t", content: "c" });
+  const del = registered.find((t) => t.name === "memory_delete");
+  const result = await del.execute({ id: `  ${id}  ` });
+  assert.equal(result.deleted, true);
+  assert.equal(store.count(), 0);
+});
+
+// issue #48 observability: an unmatched id on memory_delete is logged (warn)
+// instead of silently vanishing — the logger is optional, but when present the
+// service layer records the silent-miss case.
+test("memory_delete logs a warn when the id matches nothing", async () => {
+  const warns = [];
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {}, logger: { warn: (msg) => warns.push(msg) } });
+  store.save({ id: "a1b2c3d4-0000-0000-0000-000000000001", type: "decision", title: "t", content: "c" });
+  const registered = [];
+  const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
+  createTools(ctx, service, {}, undefined);
+  const del = registered.find((t) => t.name === "memory_delete");
+  const result = await del.execute({ id: "ffffffff" });
+  assert.equal(result.deleted, false);
+  assert.equal(warns.length, 1, "one warn for the silent-miss case");
+  assert.match(warns[0], /matched nothing/);
+});
+
 test("memory_delete by query deletes the best match (no id round-trip)", async () => {
   const { registered, service, store } = setup();
   const { memory } = service.saveWithDedupe({ type: "preference", title: "喜欢 Rust", content: "用户偏好 Rust 优先于 Go", importance: 4 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modusensus/dsh-mneme",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "description": "Structured memory engine for DeepSeek Harness. Offline semantic search, entity-attribute-timeline, autoDream self-consolidation, and human-editable Markdown storage.",
   "license": "MIT",
   "repository": {