@modusensus/dsh-mneme 0.5.3 → 0.6.1

package/src/dream/sleep.js

@@ -108,7 +108,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   }
   const strictness = config.sleepConflictStrictness ?? "normal";
   const threshold = CONFLICT_THRESHOLDS[strictness] ?? CONFLICT_THRESHOLDS.normal;
-  const memories = service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary");
+  const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && !m.forgotten && m.type !== "summary");
   if (memories.length < 2) return { status: "skipped", reason: "too few memories" };
   if (signal?.aborted) return { status: "aborted", reason: "user activity" };
 
@@ -239,7 +239,7 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
   const archived = [];
   for (const m of service.all()) {
     if (signal?.aborted) break;
-    if (m.archived || m.forgotten) continue;
+    if (m.archived || m.forgotten || m.session_disposed_at) continue;
     const ref = m.last_accessed_at ?? m.updated_at ?? m.created_at;
     if (!ref) continue;
     const t = new Date(ref).getTime();
@@ -273,7 +273,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
   const limit = config.sleepPatternMinMemories ?? 100;
   const memories = service
     .list({ limit: 200, includeForgotten: false })
-    .filter((m) => !m.archived && m.type !== "summary" && m.type !== "pattern")
+    .filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary" && m.type !== "pattern")
     .sort((a, b) => (a.updated_at < b.updated_at ? 1 : -1))
     .slice(0, limit);
   if (memories.length === 0) return { status: "skipped", reason: "no memories to scan" };
@@ -342,7 +342,7 @@ function phaseRelations(service, config, logger, runId, signal = null) {
   if (entities.length < 2) return { status: "skipped", reason: "too few entities" };
   const orphans = entities.filter((e) => (service.getRelations(e.id) ?? []).length === 0);
   if (orphans.length === 0) return { status: "skipped", reason: "no orphan entities" };
-  const memories = service.all().filter((m) => !m.archived && !m.forgotten);
+  const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && !m.forgotten);
   const seen = new Set();
   const related = [];
   const MAX_RELATIONS_PER_ORPHAN = 3;

package/src/dream.js

@@ -495,7 +495,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   let inFlight = null;
 
   function shouldTrigger(service) {
-    const memories = service.all().filter((m) => !m.archived && m.type !== "summary");
+    const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary");
     const count = memories.length;
     const chars = totalChars(memories);
     const overBase = count >= baseline.count + thresholdCount || chars >= baseline.chars + thresholdChars;
@@ -844,7 +844,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           : {}),
         messages: [
           { role: "system", content: [{ type: "text", text: SUMMARY_PROMPT }] },
-          { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
+          { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
         ]
       }, reportUsage));
     } catch (error) {

package/src/index.js

@@ -317,6 +317,26 @@ export const apply = (ctx, config) => {
   const summarizer = createSummarizer(ctx, service, cfg);
   disposers.push(summarizer.dispose);
 
+  // Session lifecycle (v0.6.0): when a session leaves the store and the toggle
+  // is enabled, mark every memory born in it as session-disposed (hidden from
+  // injection/search/dream but never destroyed — recoverable via
+  // restoreBySession). Default off, so a disposed session leaves its memories
+  // active (legacy behavior). Every path is guarded: a failure inside the
+  // callback must never propagate into DSH's session teardown (that would crash
+  // the plugin on the very delete action it serves).
+  if (cfg.sessionLifecycleEnabled) {
+    disposers.push(ctx.on("session/disposed", (session) => {
+      const sessionId = session?.id;
+      if (!sessionId) return;
+      try {
+        const { disposed } = service.disposeBySession(sessionId);
+        ctx.logger?.info?.(`[dsh-mneme] session disposed, hid ${disposed} memory(s) for ${sessionId}`);
+      } catch (error) {
+        ctx.logger?.warn?.(`[dsh-mneme] session dispose failed for ${sessionId}: ${String(error)}`);
+      }
+    }));
+  }
+
   if (ctx.webServer) {
     const api = createApi(ctx, service, settings, commands ?? {
       add: () => { throw new Error("commands unavailable"); },

package/src/parser/wiki-link.js

@@ -0,0 +1,38 @@
+/**
+ * Wiki-Link parser (v0.6.1). Given a memory's content, extract explicit
+ * cross-memory links of the form [[target]] or [[显示|target]]:
+ *   [[target]]      → { display: "target", target: "target" }
+ *   [[显示|target]] → { display: "显示",  target: "target" }
+ *
+ * Unclosed / empty-target / multi-pipe / bracket-nested markers are treated as
+ * illegal and ignored. Pure module: no store, no side effects — resolution is a
+ * separate step (resolveWikiLink) that needs a store handle.
+ */
+
+/** @returns {{display: string, target: string}[]} in source order. */
+export function parseWikiLinks(content) {
+  if (typeof content !== "string" || content.length === 0) return [];
+  const links = [];
+  // [^\[\]]* keeps a single match from crossing `]]`; an unclosed `[[` never
+  // matches, and `[[a [[b]] c]]` only yields the inner `[[b]]`.
+  const re = /\[\[([^\[\]]*)\]\]/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const inner = m[1];
+    const parts = inner.split("|");
+    if (parts.length > 2) continue; // 多管道 → 非法，忽略
+    const rawTarget = (parts.length === 2 ? parts[1] : parts[0]).trim();
+    if (!rawTarget) continue; // 空目标 → 非法，忽略
+    const rawDisplay = parts[0].trim();
+    links.push({ display: rawDisplay || rawTarget, target: rawTarget });
+  }
+  return links;
+}
+
+/** Resolve a wiki-link target title to a memory row via a case-insensitive
+ *  exact title match (store.findByTitle). Returns undefined when absent or the
+ *  store exposes no such lookup. */
+export function resolveWikiLink(store, title) {
+  if (!store || typeof title !== "string" || !title.trim()) return undefined;
+  return store.findByTitle?.(title.trim());
+}

package/src/service.js

@@ -3,6 +3,7 @@ import { TYPE_FILE } from "./mirror.js";
 import { evaluateMemoryQuality } from "./quality-filter.js";
 import { createBM25Index } from "./search/bm25.js";
 import { adaptiveThreshold } from "./search/adaptive.js";
+import { parseWikiLinks } from "./parser/wiki-link.js";
 
 const INJECT_TYPES = new Set(["preference", "project", "decision", "summary"]);
 
@@ -228,6 +229,36 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     }
   }
 
+  /**
+   * Fire-and-forget wiki-link resolution for a freshly saved/updated memory
+   * (v0.6.1). Opt-in via config.wikiLinkEnabled. Parses [[target]] /
+   * [[显示|target]] markers out of the memory content and writes links_to
+   * relations (idempotent via the unique relation index). Runs through
+   * service.enqueue so it serializes with autoDream/sleep and never overlaps
+   * another background pass. Fully fail-safe: parse/store errors are swallowed
+   * and logged, never a write failure.
+   */
+  function scheduleWikiLinkResolve(memory) {
+    if (txDepth > 0) return; // deferred to the transaction's commit
+    if (!config.wikiLinkEnabled || !memory?.id) return;
+    try {
+      const links = parseWikiLinks(memory?.content ?? "");
+      if (!links.length) return;
+      const targets = [...new Set(links.map((l) => l.target).filter(Boolean))];
+      enqueue(() => {
+        try {
+          store.saveWikiLinks({ memoryId: memory.id, title: memory.title, targets });
+        } catch (err) {
+          logger?.warn?.("wiki link resolve failed:", err);
+        }
+      }).catch((err) => {
+        logger?.warn?.("wiki link resolve failed:", err);
+      });
+    } catch (err) {
+      logger?.warn?.("wiki link resolve failed:", err);
+    }
+  }
+
   /**
    * Cross-encoder rerank over a candidate list (best effort). Reranker
    * failures degrade to the original candidate order — reranking is an
@@ -331,7 +362,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
   function bm25Recall(q, limit) {
     if (config?.bm25SearchEnabled === false) return [];
     try {
-      const docs = store.list({ limit: 500, includeForgotten: false }).filter((m) => !m.archived);
+      const docs = store.list({ limit: 500, includeForgotten: false }).filter((m) => !m.archived && !m.session_disposed_at);
       if (!docs.length) return [];
       return createBM25Index(docs).search(q, { limit });
     } catch {
@@ -802,6 +833,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       afterSync("write");
       notifyWrite();
       scheduleEmbed(result);
+      scheduleWikiLinkResolve(result);
       return { action: "merged", memory: result };
     }
     const created = store.save({
@@ -821,6 +853,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     notifyWrite();
     scheduleEmbed(result);
     scheduleEntityExtraction(result);
+    scheduleWikiLinkResolve(result);
     return { action: "created", memory: result };
   }
 
@@ -999,6 +1032,12 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       tags: m.tags,
       importance: m.importance,
       source: m.source,
+      // session_id is optional on the wire: only carry it when present, so the
+      // DTO stays a lossless JSON object (undefined would vanish on serialize).
+      ...(m.session_id != null ? { session_id: m.session_id } : {}),
+      // Disposed state rides along when set, so a restore flow is not a blind
+      // op — the caller can see which entries are hidden before restoreBySession.
+      ...(m.session_disposed_at != null ? { disposed: true } : {}),
       created_at: m.created_at,
       updated_at: m.updated_at
     }));
@@ -1280,8 +1319,52 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     }
   }
 
+  /**
+   * Forward links (v0.6.1): memories the given memory explicitly links to via
+   * [[wiki-links]] in its content. Reads the links_to relations whose
+   * from_entity is this memory's title and resolves each to_entity back to a
+   * memory row (case-insensitive title match). Returns [{ target, relation }];
+   * a target title with no matching memory surfaces as { target: null }.
+   */
+  function getForwardLinks(memoryId) {
+    const memory = store.getById(memoryId);
+    if (!memory) return [];
+    const out = [];
+    for (const rel of store.getRelations(memory.title) ?? []) {
+      if (rel.relation_type !== "links_to" || rel.from_entity !== memory.title) continue;
+      out.push({ target: store.findByTitle?.(rel.to_entity) ?? null, relation: rel });
+    }
+    return out;
+  }
+
+  /**
+   * Back links (v0.6.1): memories that explicitly link TO the given memory
+   * (their content carries a wiki-link whose target resolves to this memory's
+   * title). Reads the links_to relations whose to_entity is this memory's
+   * title; the linking memory is rel.memory_id (the source that wrote the
+   * relation). Deduped per source memory; missing/self links are dropped.
+   * Returns [{ source, relation }].
+   */
+  function getBacklinks(memoryId) {
+    const memory = store.getById(memoryId);
+    if (!memory) return [];
+    const out = [];
+    const seen = new Set();
+    for (const rel of store.getRelations(memory.title) ?? []) {
+      if (rel.relation_type !== "links_to" || rel.to_entity !== memory.title) continue;
+      const source = rel.memory_id ? store.getById(rel.memory_id) : undefined;
+      if (!source || source.id === memory.id || seen.has(source.id)) continue;
+      seen.add(source.id);
+      out.push({ source, relation: rel });
+    }
+    return out;
+  }
+
   return {
     saveWithDedupe,
+    getBacklinks,
+    getForwardLinks,
+    resolveWikiLink: (title) => store.findByTitle?.(title),
     recoverMirror,
     getMirrorHealth,
     getMirrorState: () => store.getMirrorState(),
@@ -1339,6 +1422,28 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       afterSync("write");
       notifyWrite();
     },
+    // Session lifecycle (v0.6.0): mark/clear the session-disposed state on every
+    // memory born in a given session. Uses the dedicated `session_disposed_at`
+    // column, orthogonal to `archived` — restoring a session never resurrects
+    // memories the user archived on purpose. Nothing is destroyed; a session
+    // treated as a save point is fully recoverable via restoreBySession.
+    disposeBySession: (sessionId) => {
+      const disposed = store.setDisposedBySession(sessionId, true);
+      if (disposed > 0) {
+        afterSync("write");
+        notifyWrite();
+      }
+      return { disposed };
+    },
+    restoreBySession: (sessionId) => {
+      const restored = store.setDisposedBySession(sessionId, false);
+      if (restored > 0) {
+        afterSync("write");
+        notifyWrite();
+      }
+      return { restored };
+    },
+    listBySession: (sessionId, opts = {}) => toApiList(store.listBySession(sessionId, opts)),
     update: (id, p, ctx = {}) => {
       const old = store.getById(id);
       const updated = store.update(id, p);
@@ -1365,6 +1470,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       const sync = afterSync("write");
       notifyWrite();
       scheduleEmbed(updated);
+      scheduleWikiLinkResolve(updated);
       // Audit peer B: when the mirror sync failed, the store write landed but
       // the mirror did not converge — return an explicit degraded receipt rather
       // than a plain success. Non-enumerable so existing deepEqual assertions on
@@ -1476,6 +1582,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // migrates entity_attrs on merge. Bookkeeping writes like the audit
     // passthroughs above — never write-hook-triggering memory mutations.
     saveRelation: (r) => store.saveRelation(r),
+    saveWikiLinks: (r) => store.saveWikiLinks(r),
     listEntities: (o) => store.listEntities(o),
     getRelations: (id) => store.getRelations(id),
     saveAttr: (r) => store.saveAttr(r),

package/src/store.js

@@ -11,6 +11,7 @@ CREATE TABLE IF NOT EXISTS memories (
   importance  INTEGER NOT NULL DEFAULT 3,
   forgotten   INTEGER NOT NULL DEFAULT 0,
   archived    INTEGER NOT NULL DEFAULT 0,
+  session_disposed_at TEXT,
   source      TEXT,
   session_id  TEXT,
   content_history TEXT,
@@ -321,6 +322,7 @@ function toRow(row) {
     importance: row.importance,
     forgotten: row.forgotten === 1,
     archived: row.archived === 1,
+    session_disposed_at: row.session_disposed_at ?? undefined,
     source: row.source ?? undefined,
     session_id: row.session_id ?? undefined,
     content_history: parseJsonArray(row.content_history),
@@ -550,6 +552,17 @@ export function createStore(path) {
   db.exec("PRAGMA journal_mode = WAL;");
   db.exec(SCHEMA);
 
+  // Wiki-link dedup (v0.6.1): a (from_entity, to_entity) pair is unique only for
+  // relation_type='links_to'. This is a PARTIAL index scoped to links_to, so the
+  // append-only semantics of all other relation types (uses/depends_on/part_of/
+  // related_to/supersedes — the extractor and autoDream write these per-run
+  // without global dedup, and supersedes rows carry distinct metadata like
+  // attr_key/old_value) are preserved. Idempotent (IF NOT EXISTS), atomic, and
+  // race-safe. Legacy DBs have no links_to rows yet, so the index builds cleanly
+  // everywhere and never breaks plugin startup (a full-table UNIQUE index would
+  // fail on legacy duplicates).
+  db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_relations_wikilink ON entity_relations(from_entity, to_entity, relation_type) WHERE relation_type = 'links_to'");
+
   // Schema migrations for legacy databases (idempotent). Each ADD COLUMN is
   // also race-safe: two concurrently-opening processes can both pass the
   // PRAGMA table_info check before either ALTERs, so the ALTER itself is
@@ -567,6 +580,7 @@ export function createStore(path) {
   };
 
   addColumn("memories", "archived", "ALTER TABLE memories ADD COLUMN archived INTEGER NOT NULL DEFAULT 0");
+  addColumn("memories", "session_disposed_at", "ALTER TABLE memories ADD COLUMN session_disposed_at TEXT");
   addColumn("memories", "embedding", "ALTER TABLE memories ADD COLUMN embedding TEXT");
   addColumn("memories", "last_accessed_at", "ALTER TABLE memories ADD COLUMN last_accessed_at TEXT");
   addColumn("memories", "_full_content", "ALTER TABLE memories ADD COLUMN _full_content TEXT");
@@ -575,6 +589,12 @@ export function createStore(path) {
   addColumn("memories", "quality_score", "ALTER TABLE memories ADD COLUMN quality_score REAL");
   addColumn("memories", "session_id", "ALTER TABLE memories ADD COLUMN session_id TEXT");
 
+  // Composite index for session-lifecycle queries (dispose/restore/listBySession).
+  // Created post-migration, NOT in SCHEMA: on legacy DBs both columns arrive via
+  // ADD COLUMN above, so the index would fail at db.exec(SCHEMA) time. CREATE
+  // INDEX IF NOT EXISTS is atomic, so the two-process race is safe here.
+  db.exec("CREATE INDEX IF NOT EXISTS idx_memories_session ON memories(session_id, session_disposed_at)");
+
   // Legacy dream_runs without policy_epoch → backfill with the default epoch.
   addColumn("dream_runs", "policy_epoch", "ALTER TABLE dream_runs ADD COLUMN policy_epoch INTEGER NOT NULL DEFAULT 0");
   addColumn("dream_runs", "run_type", "ALTER TABLE dream_runs ADD COLUMN run_type TEXT NOT NULL DEFAULT 'auto'");
@@ -618,7 +638,7 @@ export function createStore(path) {
     return ts;
   }
 
-  function count(type, { includeForgotten = false, includeArchived = false } = {}) {
+  function count(type, { includeForgotten = false, includeArchived = false, includeDisposed = false } = {}) {
     const clauses = [];
     const params = [];
     if (type !== undefined) {
@@ -631,6 +651,9 @@ export function createStore(path) {
     if (!includeArchived) {
       clauses.push("archived = 0");
     }
+    if (!includeDisposed) {
+      clauses.push("session_disposed_at IS NULL");
+    }
     const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
     return db.prepare(`SELECT count(*) AS c FROM memories ${where}`).get(...params).c;
   }
@@ -640,6 +663,19 @@ export function createStore(path) {
     return toRow(row);
   }
 
+  /**
+   * Case-insensitive exact title lookup (v0.6.1 wiki-link). COLLATE NOCASE
+   * folds ASCII case (CJK titles are inherently case-free, so they match
+   * verbatim). Returns the first matching memory or undefined. Best-effort —
+   * used by wiki-link target resolution and the read APIs.
+   */
+  function findByTitle(title) {
+    if (typeof title !== "string" || !title.trim()) return undefined;
+    return toRow(db.prepare(
+      "SELECT * FROM memories WHERE title = ? COLLATE NOCASE LIMIT 1"
+    ).get(title.trim()));
+  }
+
   function save(memory) {
     const id = memory.id ?? randomUUID();
     const type = memory.type;
@@ -820,6 +856,45 @@ export function createStore(path) {
     return getById(id);
   }
 
+  // --- session lifecycle (v0.6.0) ------------------------------------------
+  // Session dispose is orthogonal to `archived`: memory_archive is the user/AI
+  // choosing to keep an entry long-term-but-quiet, while session_disposed_at
+  // marks entries hidden because the session they were born in was deleted
+  // (a reversible "undo" — restoreBySession clears it). They never clobber each
+  // other: restoreBySession must not resurrect user-archived memories.
+  // Mirrors list/search: disposed rows are hidden by default. A consumer that
+  // needs to see the full picture (e.g. a restore flow that tells the user
+  // "these N entries were hidden") opts in via includeDisposed.
+  function listBySession(sessionId, { includeDisposed = false } = {}) {
+    const disposedFilter = includeDisposed ? "" : "AND session_disposed_at IS NULL";
+    const rows = db.prepare(
+      `SELECT * FROM memories WHERE session_id = ? ${disposedFilter} ORDER BY updated_at DESC`
+    ).all(sessionId);
+    return rows.map(toRow);
+  }
+
+  // Idempotent by state guard, not timestamp compare (nowIso() differs every
+  // call, so a fresh-timestamp re-dispose would spuriously count): dispose only
+  // touches rows that are NOT yet disposed; restore only touches rows that ARE.
+  // updated_at is deliberately left alone — this is a lifecycle flag, not
+  // content — so a true flip is the sole trigger for a mirror generation.
+  function setDisposedBySession(sessionId, disposed) {
+    const at = disposed ? nowIso() : null;
+    let affected = 0;
+    runAtomically(() => {
+      const result = disposed
+        ? db.prepare(
+            "UPDATE memories SET session_disposed_at = ? WHERE session_id = ? AND session_disposed_at IS NULL"
+          ).run(at, sessionId)
+        : db.prepare(
+            "UPDATE memories SET session_disposed_at = NULL WHERE session_id = ? AND session_disposed_at IS NOT NULL"
+          ).run(sessionId);
+      affected = result.changes;
+      if (affected > 0) incrementGeneration();
+    });
+    return affected;
+  }
+
   // --- sleep-mode storage support (v0.4.0) ---------------------------------
   // touchLastAccess stamps the read time on recall/inject paths. It deliberately
   // does NOT bump the mirror generation: reads must not mark the mirror dirty.
@@ -876,6 +951,7 @@ export function createStore(path) {
     const rows = db.prepare(
       `SELECT * FROM memories
        WHERE forgotten = 0 AND archived = 0
+         AND session_disposed_at IS NULL
          AND (last_accessed_at IS NULL OR last_accessed_at < ?)
        ORDER BY COALESCE(last_accessed_at, created_at) ASC, id
        LIMIT ?`
@@ -883,7 +959,7 @@ export function createStore(path) {
     return rows.map(toRow);
   }
 
-  function list({ type, limit = 50, offset = 0, includeForgotten = false, includeArchived = false } = {}) {
+  function list({ type, limit = 50, offset = 0, includeForgotten = false, includeArchived = false, includeDisposed = false } = {}) {
     const clauses = [];
     const params = [];
     if (type) {
@@ -896,6 +972,9 @@ export function createStore(path) {
     if (!includeArchived) {
       clauses.push("archived = 0");
     }
+    if (!includeDisposed) {
+      clauses.push("session_disposed_at IS NULL");
+    }
     const { limit: lim, offset: off } = sanitizePage(limit, offset, 50);
     const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
     const rows = db.prepare(
@@ -953,7 +1032,7 @@ export function createStore(path) {
     ).all(limit);
   }
 
-  function search(query, { limit = 20, includeArchived = false } = {}) {
+  function search(query, { limit = 20, includeArchived = false, includeDisposed = false } = {}) {
     const q = String(query).trim();
     if (!q) return [];
     // Plain LIKE substring scan over title/content/tags (wildcards escaped so
@@ -962,9 +1041,10 @@ export function createStore(path) {
     const like = `%${escapeLike(q)}%`;
     const { limit: lim } = sanitizePage(limit, 0, 20);
     const archivedFilter = includeArchived ? "" : "archived = 0 AND ";
+    const disposedFilter = includeDisposed ? "" : "session_disposed_at IS NULL AND ";
     const rows = db.prepare(
       `SELECT * FROM memories
-       WHERE ${archivedFilter}forgotten = 0 AND (title LIKE ? ESCAPE '\\' OR content LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\')
+       WHERE ${archivedFilter}${disposedFilter}forgotten = 0 AND (title LIKE ? ESCAPE '\\' OR content LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\')
        ORDER BY
          CASE WHEN title LIKE ? ESCAPE '\\' THEN 0 ELSE 1 END,
          importance DESC,
@@ -995,12 +1075,13 @@ export function createStore(path) {
    * Brute-force cosine similarity over embedded rows. Returns rows decorated
    * with a `score` (0..1). Only rows with a stored embedding participate.
    */
-  function searchVector(vector, { limit = 20, includeArchived = false, threshold = 0 } = {}) {
+  function searchVector(vector, { limit = 20, includeArchived = false, includeDisposed = false, threshold = 0 } = {}) {
     if (!Array.isArray(vector) || !vector.length) return [];
     const archivedFilter = includeArchived ? "" : "archived = 0 AND ";
+    const disposedFilter = includeDisposed ? "" : "session_disposed_at IS NULL AND ";
     const rows = db.prepare(
       `SELECT * FROM memories
-       WHERE ${archivedFilter}forgotten = 0 AND embedding IS NOT NULL AND embedding != ''`
+       WHERE ${archivedFilter}${disposedFilter}forgotten = 0 AND embedding IS NOT NULL AND embedding != ''`
     ).all();
     const scored = [];
     for (const row of rows) {
@@ -1605,7 +1686,10 @@ export function createStore(path) {
 
   /**
    * Record a typed relation between two entities. metadata (optional) is a
-   * free-form JSON blob describing the relation. Relations are append-only.
+   * free-form JSON blob describing the relation. Relations are append-only —
+   * callers that need idempotency (e.g. wiki-links, via saveWikiLinks) guard
+   * with their own existence check plus the partial links_to unique index
+   * (idx_relations_wikilink) as a race backstop.
    */
   function saveRelation({ from_entity, to_entity, relation_type, memory_id, metadata }) {
     const id = randomUUID();
@@ -1619,7 +1703,56 @@ export function createStore(path) {
       `INSERT INTO entity_relations (id, from_entity, to_entity, relation_type, memory_id, created_at, metadata)
        VALUES (?, ?, ?, ?, ?, ?, ?)`
     ).run(id, from_entity, to_entity, relation_type, memory_id ?? null, now, metaStr);
-    return toRelation(db.prepare("SELECT * FROM entity_relations WHERE id = ?").get(id));
+    return toRelation(db.prepare(
+      "SELECT * FROM entity_relations WHERE from_entity = ? AND to_entity = ? AND relation_type = ? LIMIT 1"
+    ).get(from_entity, to_entity, relation_type));
+  }
+
+  /**
+   * Record wiki-link relations (v0.6.1). For each target title, resolve the
+   * target memory (case-insensitive title match via findByTitle) and write a
+   * links_to relation:
+   *   from_entity = source memory title, to_entity = canonical target memory
+   *   title, relation_type = 'links_to', memory_id = source memory id.
+   * Using the canonical resolved title keeps the graph case-consistent
+   * ([[beta]] and [[Beta]] collapse onto the same to_entity), so backlink
+   * lookups never fight the way a target was typed.
+   * Fail-safe: a target with no matching memory is skipped (never an error).
+   * Idempotent: an already-existing triple is a silent no-op (existence check
+   * here + the idx_relations_wikilink partial unique index as a race backstop),
+   * so `saved` only counts newly written relations. Returns { saved, skipped }.
+   */
+  function saveWikiLinks({ memoryId, title, targets }) {
+    const saved = [];
+    const skipped = [];
+    const seen = new Set(); // canonical (lowercased) targets already handled
+    const existsStmt = db.prepare(
+      "SELECT id FROM entity_relations WHERE from_entity = ? AND to_entity = ? AND relation_type = ?"
+    );
+    const list = Array.isArray(targets)
+      ? targets.filter((t) => typeof t === "string" && t.trim())
+      : [];
+    for (const raw of list) {
+      const target = raw.trim();
+      const key = target.toLowerCase();
+      if (seen.has(key)) continue; // dedupe within a single call (case-insensitive)
+      seen.add(key);
+      const targetMem = findByTitle(target);
+      if (!targetMem) {
+        skipped.push(target); // 目标不存在 → 跳过（Fail-safe）
+        continue;
+      }
+      const toEntity = targetMem.title;
+      if (existsStmt.get(title, toEntity, "links_to")) continue; // already linked → no-op
+      saved.push(saveRelation({
+        from_entity: title,
+        to_entity: toEntity,
+        relation_type: "links_to",
+        memory_id: memoryId,
+        metadata: { target_memory_id: targetMem.id }
+      }));
+    }
+    return { saved, skipped };
   }
 
   /**
@@ -1871,6 +2004,8 @@ export function createStore(path) {
     remove,
     setForget,
     setArchived,
+    listBySession,
+    setDisposedBySession,
     touchLastAccess,
     demoteToSummary,
     restoreContent,
@@ -1921,6 +2056,8 @@ export function createStore(path) {
     getAttrsByMemory,
     findMemoriesByAttr,
     saveRelation,
+    saveWikiLinks,
+    findByTitle,
     migrateAttrsToMemory,
     getRelations,
     setMirrorState,

package/src/tools.js

@@ -180,9 +180,10 @@ export function createTools(ctx, service, config, embedder) {
 
     defineTool({
       name: "memory_delete",
-      description: "Permanently delete a memory entry.",
+      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.",
       parameters: {
-        id: { type: "string", required: true }
+        id: { type: "string", description: "Exact memory id to delete (from memory_list/memory_search output)" },
+        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: {
         schema: {
@@ -193,9 +194,19 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(value.deleted ? "Memory deleted." : "Memory not found.")
       },
       async execute(args) {
-        const existed = service.getById(args.id) !== undefined;
-        if (existed) service.remove(args.id);
-        return { deleted: existed };
+        if (args.id) {
+          const existed = service.getById(args.id) !== undefined;
+          if (existed) service.remove(args.id);
+          return { deleted: existed };
+        }
+        if (args.query) {
+          const [best] = await service.searchMemories(args.query, { mode: "auto", topK: 1, useRerank: true });
+          if (best) {
+            service.remove(best.id);
+            return { deleted: true };
+          }
+        }
+        return { deleted: false };
       }
     }),
 

package/test/client.test.js

@@ -232,3 +232,39 @@ test("explorer chrome aligns with the host design system", () => {
     "pill chips belong to the drawer era and must stay gone"
   );
 });
+
+// The v0.6.1 wiki-link feature: the detail pane mounts a BacklinksPanel that
+// fetches the two read-only link endpoints by the selected memory id and
+// renders back/forward rows, each jumping back into the browser.
+test("detail pane mounts a BacklinksPanel backed by the two link endpoints", () => {
+  assert.ok(
+    clientSource.includes("h(BacklinksPanel, { memory: selected, t, onJump: jumpToMemory })"),
+    "the detail pane must mount BacklinksPanel after the actions row"
+  );
+  assert.ok(
+    clientSource.includes("/api/dsh-mneme/wikilinks/backlinks?id="),
+    "BacklinksPanel must fetch the backlinks endpoint by memory id"
+  );
+  assert.ok(
+    clientSource.includes("/api/dsh-mneme/wikilinks/forward?id="),
+    "BacklinksPanel must fetch the forward-links endpoint by memory id"
+  );
+});
+
+// Detail content turns [[target]] / [[display|target]] into clickable links:
+// the display text survives, the target title is kept for hover, and a click
+// resolves the title through the resolve endpoint before jumping.
+test("detail content renders wiki-links and resolves them on click", () => {
+  assert.ok(
+    clientSource.includes('className: "mneme-wikilink"'),
+    "inline [[target]] links must use the .mneme-wikilink style"
+  );
+  assert.ok(
+    clientSource.includes("/api/dsh-mneme/wikilinks/resolve?title="),
+    "clicking a wiki-link must resolve the title via the resolve endpoint"
+  );
+  assert.ok(
+    clientSource.includes('className: "mneme-backlinks"'),
+    "the panel must render inside a .mneme-backlinks block"
+  );
+});