@modusensus/dsh-mneme 0.6.1 → 0.6.5

package/lib/dream.js

@@ -1,5 +1,6 @@
 import { validateDecisions, applyDecisions } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts } from "./dream/clustering.js";
+import { runAutoTag } from "./dream/tag-extractor.js";
 import { createHash, randomUUID } from "node:crypto";
 export { validateDecisions, applyDecisions, normalizeDecisions };
 
@@ -815,6 +816,25 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // that only froze conflicts is not a noop.
     const noChange = frozenCount === 0 && applied === 0 && committed.every((c) => c.action === "keep");
 
+    // v0.6.2 auto-tag: a light LLM pass over the retained (post-consolidation)
+    // memories. Opt-in via config.autoTagEnabled, bounded by autoTagMaxPerRun,
+    // and always fail-safe — a tag failure must never change the consolidation
+    // outcome reported below (it is logged and counted, nothing more).
+    let autoTagged = 0;
+    if (config.autoTagEnabled === true) {
+      try {
+        const tagResult = await runAutoTag({ ctx, service, config, route });
+        autoTagged = tagResult?.tagged ?? 0;
+        if (tagResult?.ok === false && tagResult?.skippedBy && tagResult.skippedBy !== "empty") {
+          logger?.warn?.(`dsh-mneme dream: auto-tag skipped (${tagResult.skippedBy})`);
+        } else if (autoTagged > 0) {
+          logger?.info?.(`[dsh-mneme] auto-tag: ${autoTagged} memory(ies) tagged`);
+        }
+      } catch (error) {
+        logger?.warn?.(`dsh-mneme dream: auto-tag failed: ${String(error)}`);
+      }
+    }
+
     // Keep the vector index consistent with the post-dream store state.
     if (semantic?.embedder && semantic?.vectorIndex) {
       try {

package/lib/mirror.js

@@ -31,6 +31,15 @@ function renderMemory(m) {
     .digest("hex");
   const lines = [];
   lines.push(`## ${esc(m.title)}`);
+  // v0.6.2 tag line: entity_attrs-backed tags (attached by the service as
+  // `entityTags`) rendered as `#tag` space-separated under the title. No tags
+  // → no line. Legacy `- **标签**:` metadata below keeps the memories.tags
+  // column (still written by save/update) readable.
+  const entityTags = Array.isArray(m.entityTags) ? m.entityTags : [];
+  if (entityTags.length) {
+    lines.push("");
+    lines.push(entityTags.map((t) => `#${esc(t)}`).join(" "));
+  }
   lines.push("");
   lines.push(`- **ID**: \`${m.id}\``);
   lines.push(`- **类型**: ${m.type}`);

package/lib/parser/tag.js

@@ -0,0 +1,59 @@
+/**
+ * Tag parser (v0.6.2). Given a memory's content, extract explicit hashtags of
+ * the form `#标签`. The allowed character set is `[a-zA-Z0-9_一-龥-]+` (ASCII
+ * letters/digits/underscore, CJK characters, and hyphen), so `#linux`,
+ * `#deepseek` and `#考研` are all valid tags.
+ *
+ * Rules:
+ *   - multiple tags on one line are all extracted, in source order;
+ *   - duplicates collapse to the first occurrence;
+ *   - tags longer than MAX_TAG_LENGTH (20) characters are dropped as illegal;
+ *   - edge hyphens (leading/trailing, e.g. a sentence-terminating `#tag-`) are
+ *     stripped; a tag that collapses to empty is dropped;
+ *   - markdown `## heading` never matches (the second `#`/space is not in the
+ *     allowed set).
+ *
+ * Pure module: no store, no side effects — persistence (store.setMemoryTags)
+ * is a separate step. sanitizeTags shares the same validation so LLM-extracted
+ * tag arrays (autoDream tag-extractor) are filtered identically.
+ */
+
+export const MAX_TAG_LENGTH = 20;
+
+// `一` (U+4E00) .. `龥` (U+9FA5) is the CJK Unified Ideographs block (the
+// rule's `一-龥`). Matching requires a tag character right after `#` so a bare
+// `#` and markdown `## heading` are naturally excluded (#/space not in set).
+const TAG_RE = /#[a-zA-Z0-9_一-龥-]+/g;
+const EDGE_HYPHEN = /^-+|-+$/g;
+const VALID_TAG = /^[a-zA-Z0-9_一-龥-]+$/;
+
+/** Validate + dedupe an array of tag strings. Non-strings, blanks, over-long
+ *  and illegal-character tags are dropped (fail-safe). A leading `#` is
+ *  tolerated so raw LLM output can be passed through directly. */
+export function sanitizeTags(tags) {
+  if (!Array.isArray(tags)) return [];
+  const seen = new Set();
+  const out = [];
+  for (const t of tags) {
+    if (typeof t !== "string") continue;
+    let tag = t.trim();
+    if (tag.startsWith("#")) tag = tag.slice(1);
+    tag = tag.replace(EDGE_HYPHEN, "");
+    if (!tag || tag.length > MAX_TAG_LENGTH) continue;
+    if (!VALID_TAG.test(tag)) continue;
+    if (seen.has(tag)) continue; // 去重（保留首次出现顺序）
+    seen.add(tag);
+    out.push(tag);
+  }
+  return out;
+}
+
+/** @returns {string[]} validated tags in source order, deduplicated. */
+export function parseTags(content) {
+  if (typeof content !== "string" || content.length === 0) return [];
+  const raw = [];
+  TAG_RE.lastIndex = 0;
+  let m;
+  while ((m = TAG_RE.exec(content)) !== null) raw.push(m[0]);
+  return sanitizeTags(raw);
+}

package/lib/search/tag-boost.js

@@ -0,0 +1,61 @@
+// v0.6.4 Tag-weighted re-rank helpers.
+// Query tags come from `#hashtags` in the query plus any known tags the query
+// mentions; candidates whose tags overlap the query tags or the session's
+// hot-memory tags get their score boosted before the final top-K cut.
+
+/**
+ * Extract tags from a query: explicit `#hashtags` (CJK allowed) plus known
+ * tags whose lowercase form appears in the query. Deduped, order-preserving.
+ */
+export function extractQueryTags(query, knownTags = []) {
+  if (typeof query !== "string" || !query) return [];
+  const set = new Set();
+  const re = /#([a-zA-Z0-9_一-龥-]+)/g;
+  let m;
+  while ((m = re.exec(query)) !== null) set.add(m[1]);
+  const q = query.toLowerCase();
+  for (const t of knownTags) {
+    if (typeof t === "string" && q.includes(t.toLowerCase())) set.add(t);
+  }
+  return Array.from(set);
+}
+
+function hasOverlap(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return false;
+  const setB = new Set(b);
+  return a.some((x) => setB.has(x));
+}
+
+/**
+ * Boost candidate scores by tag overlap with the query and/or session tags.
+ * Each candidate is expected to carry a `tags` array (enriched by the caller).
+ * Returns a new array sorted by boosted score descending; candidates that were
+ * boosted are marked `tagBoost: true`. Unchanged candidates keep their
+ * relative order (stable).
+ */
+export function applyTagBoost(
+  candidates,
+  { queryTags = [], sessionTags = [], factor = 1.15, sessionFactor = 1.08 }
+) {
+  const boosted = candidates.map((c) => {
+    const tags = c.tags ?? [];
+    let score = typeof c.score === "number" ? c.score : 0;
+    let didBoost = false;
+
+    if (queryTags.length && hasOverlap(tags, queryTags)) {
+      score = Math.min(1, score * factor);
+      didBoost = true;
+    }
+    if (sessionTags.length && hasOverlap(tags, sessionTags)) {
+      score = Math.min(1, score * sessionFactor);
+      didBoost = true;
+    }
+
+    const out = { ...c, score };
+    if (didBoost) out.tagBoost = true;
+    return out;
+  });
+
+  boosted.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+  return boosted;
+}

package/lib/service.js

@@ -4,6 +4,7 @@ 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";
+import { extractQueryTags, applyTagBoost } from "./search/tag-boost.js";
 
 const INJECT_TYPES = new Set(["preference", "project", "decision", "summary"]);
 
@@ -327,6 +328,55 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     return hits;
   }
 
+  /**
+   * Search for memories carrying a given tag set (v0.6.2). Multiple tag:
+   * tokens in one query use AND semantics — a memory must carry every tag.
+   * Combinable with the leftover query: an entity:/attr: prefix is intersected
+   * with the tag-matched set, and plain keyword text ranks it (only rows whose
+   * keyword score > 0 survive). Tags are first-class recall, not entity-gated:
+   * the tag match itself does not depend on config.entitySearchEnabled.
+   * @param {string[]} tagTokens
+   * @param {string} q — leftover query after tag: tokens were stripped
+   * @param {object} [options]
+   * @param {number} [options.topK=20]
+   * @returns {any[]}
+   */
+  function searchByTags(tagTokens, q, options) {
+    const { topK = 20 } = options;
+    const tags = (Array.isArray(tagTokens) ? tagTokens : [])
+      .map((t) => String(t).trim()).filter(Boolean);
+    if (!tags.length) return [];
+    let hits = store.findMemoriesByTags(tags);
+    if (!hits.length) return [];
+    // Intersect with entity:/attr: prefixes present in the leftover query.
+    if (config?.entitySearchEnabled) {
+      if (q.startsWith("entity:")) {
+        const ids = new Set(searchByEntity(q.slice(7).trim(), { topK: 10000 }).map((m) => m.id));
+        hits = hits.filter((m) => ids.has(m.id));
+      }
+      if (q.startsWith("attr:")) {
+        const [key, value] = q.slice(5).split("=");
+        const ids = new Set(searchByAttr(key, value, { topK: 10000 }).map((m) => m.id));
+        hits = hits.filter((m) => ids.has(m.id));
+      }
+    }
+    // Leftover plain text ranks the tag-matched set; only rows whose title or
+    // content actually mentions the keyword survive (scoreKeyword's 0.3 base is
+    // a non-match, so the containment check is the real gate); otherwise
+    // preserve insertion order.
+    const keywordOnly = q && !q.startsWith("entity:") && !q.startsWith("attr:");
+    hits = keywordOnly
+      ? hits
+          .map((m) => ({ ...m, score: scoreKeyword(m, q), source: "tag" }))
+          .filter((m) => (m.title ?? "").toLowerCase().includes(q.toLowerCase())
+            || (m.content ?? "").toLowerCase().includes(q.toLowerCase()))
+          .sort((a, b) => b.score - a.score)
+      : hits.map((m) => ({ ...m, source: "tag" }));
+    const result = hits.slice(0, topK);
+    touchRecalled(result);
+    return result;
+  }
+
   /**
    * Semantic-aware memory search: keyword recall (store.search) plus optional
    * vector recall + rerank. mode:
@@ -433,8 +483,18 @@ export function createService({ store, mirror, config, onWrite, logger }) {
 
   async function searchMemories(query, options = {}) {
     const { mode = "auto", topK = 20, threshold, useRerank = true, recordRecall = false } = options;
-    const q = String(query ?? "").trim();
-    if (!q) return [];
+    const raw = String(query ?? "").trim();
+    if (!raw) return [];
+
+    // tag: 前缀（v0.6.2）。先把所有 tag: 令牌从 query 里剥出来，剩余的 q 仍可带
+    // entity:/attr: 前缀或普通关键词 —— searchByTags 负责交集/排序。没有 tag:
+    // 令牌则走下面的 entity:/attr:/文本原逻辑（完全向后兼容）。
+    const tagTokens = [];
+    const q = raw.replace(/\btag:([^\s]+)/g, (_, tok) => {
+      if (tok) tagTokens.push(tok);
+      return "";
+    }).trim();
+    if (tagTokens.length) return searchByTags(tagTokens, q, options);
 
     // entity:/attr: 前缀路由（v0.3.0 Phase 3）。entitySearchEnabled 关闭时走原逻辑。
     if (config?.entitySearchEnabled) {
@@ -539,7 +599,10 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       const ranked = [...byId.values()]
         .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
         .map((r) => ({ ...r, score: Math.max(0, Math.min(1, r.score ?? 0)) }));
-      merged = ranked.slice(0, lim);
+      // Tag boost (v0.6.4) needs the full ranked pool, not just the top-lim
+      // slice, so a tagged candidate just below the line can be re-admitted
+      // after the boost. Without boost this is the legacy lim truncation.
+      merged = config.tagBoostEnabled === true ? ranked : ranked.slice(0, lim);
       if (merged.length < lim && !merged.length) {
         // Vector unavailable entirely: fall back to plain keyword.
         merged = keyword.slice(0, lim);
@@ -565,7 +628,31 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // it is the documented text-only path and must not be altered by
     // embedding state.
     merged = mode === "keyword" ? merged : semanticDeduplicate(merged);
+
+    // Tag-weighted re-rank (v0.6.4): boost candidates whose tags overlap the
+    // query tags or the current session's hot-memory tags — applied BEFORE the
+    // final top-K cut so tagged candidates just below the line can be
+    // re-admitted. Opt-in, and skipped entirely on the keyword-only path. When
+    // a reranker is configured (opt-in), it remains the final authority on
+    // order; the boost still shapes which candidates reach it.
+    if (config.tagBoostEnabled === true && mode !== "keyword" && merged.length) {
+      const ids = merged.map((m) => m.id);
+      const tagsMap = store.getMemoryTagsMap(ids);
+      const enriched = merged.map((m) => ({ ...m, tags: tagsMap.get(m.id) ?? [] }));
+      const knownTags = [...tagsMap.values()].flat();
+      const queryTags = extractQueryTags(q, knownTags);
+      const sessionTags = Array.isArray(options?.sessionTags) ? options.sessionTags : [];
+      if (queryTags.length || sessionTags.length) {
+        merged = applyTagBoost(enriched, {
+          queryTags,
+          sessionTags,
+          factor: config.tagBoostFactor,
+          sessionFactor: config.sessionTagBoostFactor,
+        }).map(({ tags, ...rest }) => rest);
+      }
+    }
     merged = merged.slice(0, lim);
+
     let result = useRerank && reranker && merged.length
       ? await rerankCandidates(q, merged, lim)
       : merged;
@@ -1043,6 +1130,21 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     }));
   }
 
+  /**
+   * Directory view (v0.6.3): group live memories by tag. Delegates to
+   * store.getDirectory (tag-sorted groups, importance/updated DESC members,
+   * live-only filtering) and maps every memory to the wire DTO so the result
+   * is JSON-safe for the API endpoint.
+   * @returns {{groups: {tag: string, memories: object[]}[], untagged: object[]}}
+   */
+  function getDirectory() {
+    const { groups, untagged } = store.getDirectory();
+    return {
+      groups: groups.map((g) => ({ tag: g.tag, memories: toApiList(g.memories) })),
+      untagged: toApiList(untagged)
+    };
+  }
+
   /**
    * Three-way merge of in-flight human mirror edits before a re-render.
    * Runs on every syncMirror, so a human edit made between two store writes is
@@ -1150,8 +1252,14 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       // leaving committed files mislabeled as failed and masking partial state.
       // Absent entries (a type with no memories) count as success: sync prunes
       // the stale file, which is itself a completed physical state.
+      // v0.6.2: attach entity_attrs-backed tags (entityTags) after the human-edit
+      // merge so renderMemory can draw the `#tag` line under each title. The
+      // bulk map is a single query, and a missing row simply renders no line.
+      const reconciled = reconcileHumanEdits(list);
+      const tagsMap = store.getMemoryTagsMap(reconciled.map((m) => m.id));
+      const tagged = reconciled.map((m) => ({ ...m, entityTags: tagsMap.get(m.id) ?? [] }));
       let allOk = true;
-      const results = mirror.sync(reconcileHumanEdits(list)) ?? {};
+      const results = mirror.sync(tagged) ?? {};
       for (const type of Object.keys(TYPE_FILE)) {
         const r = results[type];
         const ok = !r || r.ok === true;
@@ -1371,6 +1479,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     injectCandidates,
     mergeHumanEdits,
     toApiList,
+    getDirectory,
     transaction,
     enqueue,
     setDreamHook(fn) { dreamHook = fn; },
@@ -1585,6 +1694,25 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     saveWikiLinks: (r) => store.saveWikiLinks(r),
     listEntities: (o) => store.listEntities(o),
     getRelations: (id) => store.getRelations(id),
+    // Tag system (v0.6.2). setMemoryTags is the manual/user path: gated by
+    // config.manualTagEnabled (default true), re-renders the mirror and fires
+    // the write hook. applyMemoryTags is the raw write used by the autoDream
+    // tag pass (gated by autoTagEnabled, wrapped in a transaction by the
+    // extractor so the mirror re-renders exactly once).
+    setMemoryTags: (memoryId, tags) => {
+      if (config.manualTagEnabled === false) {
+        return { ok: false, error: "manualTagEnabled is off" };
+      }
+      const stored = store.setMemoryTags(memoryId, tags);
+      afterSync("write");
+      notifyWrite();
+      return { ok: true, tags: stored };
+    },
+    getMemoryTags: (memoryId) => store.getMemoryTags(memoryId),
+    // Read-only gate flag so the Web panel can hide tag editing when the
+    // manual path is disabled (default: manual tagging is on).
+    manualTagEnabled: () => config.manualTagEnabled !== false,
+    applyMemoryTags: (memoryId, tags) => store.setMemoryTags(memoryId, tags),
     saveAttr: (r) => store.saveAttr(r),
     createEntity: (r) => store.createEntity(r),
     findEntityByName: (n) => store.findEntityByName(n),

package/lib/store.js

@@ -1,5 +1,6 @@
 import { DatabaseSync } from "node:sqlite";
 import { randomUUID } from "node:crypto";
+import { sanitizeTags } from "./parser/tag.js";
 
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS memories (
@@ -1684,6 +1685,162 @@ export function createStore(path) {
     return memories;
   }
 
+  // --- tag storage (v0.6.2) ------------------------------------------------
+  // Tags ride the snapshot-style entity_attrs table (attr_key='tags'), so one
+  // memory has exactly one live tags row; setMemoryTags invalidates any prior
+  // live row and inserts a fresh one (idempotent overwrite). entity_id is the
+  // memory id itself (the memory is its own tag entity), memory_id is kept so
+  // the existing memory-scoped attr queries (getAttrsByMemory / findMemoriesByAttr)
+  // and the bulk tag map all work without a special path.
+
+  /** Normalize an arbitrary tags input to a deduplicated string array.
+   *  Delegates to parser/tag.js sanitizeTags (shared validation with parseTags
+   *  and the autoDream tag-extractor): strips a leading `#`, trims, drops
+   *  non-strings/blanks/over-long/illegal-char tags. Kept as a thin alias so
+   *  the tag write path validates identically to the parser path. */
+  function normalizeTags(tags) {
+    return sanitizeTags(tags);
+  }
+
+  /**
+   * Set (overwrite) the live tag set for a memory. Exactly one tags row stays
+   * live per memory: any prior live row is invalidated first, then one fresh
+   * row is written (no-op when tags is empty — the invalidated row is removed
+   * so "clear tags" = no live row). Returns the stored tag array.
+   */
+  function setMemoryTags(memoryId, tags) {
+    const arr = normalizeTags(tags);
+    const now = nowIso();
+    // Atomic: the invalidation and the fresh row must land together, so a
+    // mid-write crash never leaves the old live row gone without a replacement.
+    // SAVEPOINT (not BEGIN) so this nests safely inside service.transaction().
+    db.exec("SAVEPOINT set_memory_tags");
+    try {
+      db.prepare(
+        `UPDATE entity_attrs SET valid_until = ?
+         WHERE attr_key = 'tags' AND memory_id = ? AND valid_until IS NULL`
+      ).run(now, memoryId);
+      if (arr.length) {
+        const id = randomUUID();
+        db.prepare(
+          `INSERT INTO entity_attrs (id, entity_id, attr_key, attr_value, memory_id, valid_from, valid_until, confidence, source)
+           VALUES (?, ?, 'tags', ?, ?, ?, NULL, 1.0, 'manual')`
+        ).run(id, memoryId, JSON.stringify(arr), memoryId, now);
+      }
+      db.exec("RELEASE set_memory_tags");
+    } catch (e) {
+      db.exec("ROLLBACK TO set_memory_tags");
+      db.exec("RELEASE set_memory_tags");
+      throw e;
+    }
+    return arr;
+  }
+
+  /** Live tags for a memory ([] when none / unknown). */
+  function getMemoryTags(memoryId) {
+    const row = db.prepare(
+      `SELECT attr_value FROM entity_attrs
+       WHERE attr_key = 'tags' AND memory_id = ? AND valid_until IS NULL
+       ORDER BY valid_from DESC LIMIT 1`
+    ).get(memoryId);
+    if (!row) return [];
+    try {
+      const arr = JSON.parse(row.attr_value);
+      return Array.isArray(arr) ? arr : [];
+    } catch {
+      return [];
+    }
+  }
+
+  /** Bulk live-tags lookup for mirror rendering. Returns Map<memoryId, string[]>. */
+  function getMemoryTagsMap(ids) {
+    const out = new Map();
+    const list = (Array.isArray(ids) ? ids : []).filter(Boolean);
+    for (let i = 0; i < list.length; i += 100) {
+      const chunk = list.slice(i, i + 100);
+      const rows = db.prepare(
+        `SELECT memory_id, attr_value FROM entity_attrs
+         WHERE attr_key = 'tags' AND valid_until IS NULL
+           AND memory_id IN (${chunk.map(() => "?").join(",")})`
+      ).all(...chunk);
+      for (const row of rows) {
+        try {
+          const arr = JSON.parse(row.attr_value);
+          if (Array.isArray(arr) && arr.length) out.set(row.memory_id, arr);
+        } catch { /* corrupt row: skip */ }
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Memories carrying a live tags row that contains EVERY requested tag
+   * (AND semantics for a multi-tag query). attr_value is a JSON array, so the
+   * match uses quoted `"tag"` substrings — `tag:lin` never collides with
+   * `linux` because JSON array elements are quote-delimited. Only live rows
+   * (valid_until IS NULL) with a memory reference participate; each memory
+   * appears once.
+   */
+  function findMemoriesByTags(tags) {
+    const list = normalizeTags(tags);
+    if (!list.length) return [];
+    const where = list.map(() => `attr_value LIKE ? ESCAPE '\\'`).join(" AND ");
+    const params = list.map((t) => `%"${escapeLike(t)}"%`);
+    const rows = db.prepare(
+      `SELECT DISTINCT memory_id FROM entity_attrs
+       WHERE attr_key = 'tags' AND valid_until IS NULL
+         AND memory_id IS NOT NULL AND memory_id != ''
+         AND (${where})`
+    ).all(...params);
+    // Same live-memory filter as getDirectory/store.search: forgotten/archived/
+    // session-disposed memories are invisible to `tag:` recall.
+    const stmt = db.prepare(
+      "SELECT * FROM memories WHERE id = ? AND forgotten = 0 AND archived = 0 AND session_disposed_at IS NULL"
+    );
+    const memories = [];
+    for (const { memory_id } of rows) {
+      const row = stmt.get(memory_id);
+      if (row) memories.push(toRow(row));
+    }
+    return memories;
+  }
+
+  /**
+   * Directory view (v0.6.3): group live memories by their entity_attrs-backed
+   * tag set. A memory carrying N tags appears under all N tag folders; a memory
+   * with no live tags lands in `untagged`. Only live rows participate —
+   * forgotten, archived and session-disposed memories are excluded. Groups are
+   * ordered by tag (locale-aware), group members and untagged follow the
+   * canonical memory order (importance DESC, updated_at DESC, id).
+   * @returns {{groups: {tag: string, memories: object[]}[], untagged: object[]}}
+   */
+  function getDirectory() {
+    const rows = db.prepare(
+      `SELECT * FROM memories
+       WHERE forgotten = 0 AND archived = 0 AND session_disposed_at IS NULL
+       ORDER BY importance DESC, updated_at DESC, id`
+    ).all();
+    const memories = rows.map(toRow);
+    const tagMap = getMemoryTagsMap(memories.map((m) => m.id));
+    const byTag = new Map(); // tag -> memory[]
+    const untagged = [];
+    for (const m of memories) {
+      const tags = tagMap.get(m.id);
+      if (!tags || tags.length === 0) {
+        untagged.push(m);
+        continue;
+      }
+      for (const tag of tags) {
+        if (!byTag.has(tag)) byTag.set(tag, []);
+        byTag.get(tag).push(m);
+      }
+    }
+    const groups = [...byTag.entries()]
+      .sort((a, b) => a[0].localeCompare(b[0]))
+      .map(([tag, ms]) => ({ tag, memories: ms }));
+    return { groups, untagged };
+  }
+
   /**
    * Record a typed relation between two entities. metadata (optional) is a
    * free-form JSON blob describing the relation. Relations are append-only —
@@ -2055,6 +2212,11 @@ export function createStore(path) {
     getAttrHistory,
     getAttrsByMemory,
     findMemoriesByAttr,
+    setMemoryTags,
+    getMemoryTags,
+    getMemoryTagsMap,
+    findMemoriesByTags,
+    getDirectory,
     saveRelation,
     saveWikiLinks,
     findByTitle,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 7 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.6.1",
+  "version": "0.6.5",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/api.js

@@ -608,8 +608,84 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- memory tags (v0.6.2) ------------------------------------------------
+  // GET  /api/dsh-mneme/memory/tags?id=<memoryId> → live entity_attrs-backed
+  //       tag set for one memory plus the manualTagEnabled gate (so the panel
+  //       can hide tag editing when the manual path is off). Read-only, stays
+  //       open when apiToken is set (like list/search/semantic).
+  // POST /api/dsh-mneme/memory/tags { id, tags } → overwrite the live tag set
+  //       via service.setMemoryTags (manualTagEnabled gate); 409 when the gate
+  //       is closed. Auth-gated like the other write endpoints.
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/memory/tags",
+    handler(req, res) {
+      try {
+        if (req.method === "POST" || req.method === "PUT") {
+          if (!requireAuth(req, res, apiToken)) return;
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            const id = typeof body.id === "string" ? body.id.trim() : "";
+            if (!id) {
+              sendJson(res, 400, { error: "missing-id" });
+              return;
+            }
+            const memory = service.getById?.(id) ?? null;
+            if (!memory) {
+              sendJson(res, 404, { error: "memory-not-found" });
+              return;
+            }
+            const result = service.setMemoryTags(id, Array.isArray(body.tags) ? body.tags : []);
+            if (result?.ok === false) {
+              sendJson(res, 409, { error: result.error || "tags-disabled" });
+              return;
+            }
+            sendJson(res, 200, { ok: true, memoryId: id, tags: result?.tags ?? [] });
+          });
+        }
+        const url = new URL(req.url, "http://localhost");
+        const id = (url.searchParams.get("id") ?? "").trim();
+        if (!id) {
+          sendJson(res, 400, { error: "missing-id" });
+          return;
+        }
+        const memory = service.getById?.(id) ?? null;
+        if (!memory) {
+          sendJson(res, 404, { error: "memory-not-found" });
+          return;
+        }
+        const tags = service.getMemoryTags?.(id) ?? [];
+        sendJson(res, 200, {
+          memoryId: id,
+          tags: Array.isArray(tags) ? tags : [],
+          manualTagEnabled: service.manualTagEnabled?.() ?? true
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- directory view (v0.6.3) ---------------------------------------------
+  // GET /api/dsh-mneme/directory → memories grouped by tag as
+  // { groups: [{ tag, memories: [...] }], untagged: [...] }. Live-only
+  // (forgotten/archived/session-disposed excluded), groups tag-sorted, members
+  // importance+updated DESC. Read-only, stays open when apiToken is set.
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/directory",
+    handler(req, res) {
+      try {
+        const dir = service.getDirectory?.() ?? { groups: [], untagged: [] };
+        sendJson(res, 200, dir);
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   return {
-    routes: 11,
+    routes: 19,
     dispose: () => {
       for (const dispose of disposers) dispose();
     }

package/src/config.js

@@ -175,6 +175,24 @@ export const Config = z.object({
   // regardless of this flag.
   wikiLinkEnabled: z.boolean().default(false),
 
+  // --- tag system (v0.6.2) ---------------------------------------------------
+  // Opt-in: when autoTagEnabled is true, a light LLM pass runs after each
+  // autoDream consolidation and extracts 1-3 tags per retained memory
+  // (autoTagMaxPerRun bounds how many memories are tagged per run). The tag
+  // storage layer (store.setMemoryTags/getMemoryTags + tag: search + mirror
+  // `#tag` line) is always available regardless of this flag.
+  autoTagEnabled: z.boolean().default(false),
+  autoTagMaxPerRun: z.natural().min(1).max(100).default(10),
+  // Manual tagging (service.setMemoryTags / memory tools) is on by default;
+  // set false to disable the manual write path too.
+  manualTagEnabled: z.boolean().default(true),
+
+  // --- tag-weighted re-rank (v0.6.4) -------------------------------------
+  // Opt-in: boost candidates whose tags overlap the query/session tags.
+  tagBoostEnabled: z.boolean().default(false),
+  tagBoostFactor: z.number().min(1).max(2).default(1.15),
+  sessionTagBoostFactor: z.number().min(1).max(2).default(1.08),
+
   // --- sleep mode: idle-triggered deep maintenance (v0.4.0) ---------------
   // Opt-in, off by default. Unlike autoDream (threshold-triggered, lightweight)
   // sleep fires when the store has been quiet for sleepIdleMinutes and deep-