@luisarg/memory-mcp 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -1,14 +1,12 @@
 import Schema from "@deepseek-ai/schemastery";
 import { Context } from "@deepseek-ai/cordis";
-
 //#region src/index.d.ts
-declare const name = "memory-mcp";
-interface Config {
+export declare const name = "memory-mcp";
+export interface Config {
   memoryPath: string;
   serverDir: string;
 }
-declare const Config: Schema<Config>;
-declare function apply(ctx: Context, config: Config): void;
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;
 //#endregion
-export { Config, apply, name };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;cAOa,IAAA;UAEI,MAAA;EAFJ,UAAI,EAAA,MAAA;EAEA,SAAM,EAAA,MAAA;AAKvB;AAwCgB,cAxCH,MAwCc,EAxCN,MAwCuB,CAxChB,MAwCsB,CAAA;iBAAlC,KAAA,MAAW,iBAAiB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;qBAOa;iBAEI;EACf;EACA;;qBAGW,QAAQ,OAAO;wBAwCZ,MAAM,KAAK,SAAS,QAAQ"}

package/dist/index.js

@@ -3,7 +3,6 @@ import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import Schema from "@deepseek-ai/schemastery";
-
 //#region src/index.ts
 const name = "memory-mcp";
 const Config = Schema.object({
@@ -49,7 +48,7 @@ function apply(ctx, config) {
 	for (const file of ["launcher.mjs", "requirements.txt"]) if (ensureFile(serverDir, bundled, file)) console.log(`[memory-mcp] installed ${file} -> ${serverDir}`);
 	if (!existsSync(join(serverDir, "server.py"))) console.warn(`[memory-mcp] memory-vault-server not found at ${serverDir} and not bundled — set DSH_MEMORY_SERVER_DIR (or run \`node scripts/bundle-assets.mjs\` in a checkout)`);
 }
-
 //#endregion
 export { Config, apply, name };
+
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["Config: Schema<Config>"],"sources":["../src/index.ts"],"sourcesContent":["import { cpSync, existsSync, mkdirSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { dirname, isAbsolute, join } from 'node:path'\nimport { fileURLToPath } from 'node:url'\nimport type { Context } from '@deepseek-ai/cordis'\nimport Schema from '@deepseek-ai/schemastery'\n\nexport const name = 'memory-mcp'\n\nexport interface Config {\n  memoryPath: string\n  serverDir: string\n}\n\nexport const Config: Schema<Config> = Schema.object({\n  memoryPath: Schema.string().default(process.env.DSH_MEMORY_PATH ?? ''),\n  serverDir: Schema.string().default(process.env.DSH_MEMORY_SERVER_DIR ?? ''),\n})\n\nconst packageRoot = dirname(dirname(fileURLToPath(import.meta.url)))\n\n/** Harness home, resolved like the harness itself ($DSH_HOME, or ~/.dsh). */\nfunction dshHome(): string {\n  const env = process.env.DSH_HOME?.trim()\n  return env && env.length > 0 ? env : join(homedir(), '.dsh')\n}\n\n/** Absolute paths stay; empty/relative values resolve under the harness home. */\nfunction resolveUnderHome(value: string, segment: string): string {\n  const v = value.trim()\n  if (v.length === 0) return join(dshHome(), segment)\n  return isAbsolute(v) ? v : join(dshHome(), v)\n}\n\n/** Copy the bundled dir into `target` when `key` is missing there. */\nfunction ensure(target: string, bundled: string, key: string): boolean {\n  if (existsSync(join(target, key))) return false\n  if (!existsSync(bundled)) return false\n  mkdirSync(target, { recursive: true })\n  cpSync(bundled, target, { recursive: true })\n  return true\n}\n\n/** Copy one bundled file into `target` when missing (upgrades add files 0.1.1 → 0.1.2). */\nfunction ensureFile(target: string, bundled: string, file: string): boolean {\n  const dest = join(target, file)\n  if (existsSync(dest)) return false\n  const src = join(bundled, file)\n  if (!existsSync(src)) return false\n  mkdirSync(target, { recursive: true })\n  cpSync(src, dest)\n  return true\n}\n\nexport function apply(ctx: Context, config: Config) {\n  const serverDir = resolveUnderHome(config.serverDir, 'memory-vault-server')\n  const memoryPath = resolveUnderHome(config.memoryPath, 'memory-vault')\n\n  // Self-contained install: first boot copies the bundled server and vault\n  // starter under the harness home when they are missing. Env-overridden\n  // paths are respected (never overwritten, never copied over).\n  if (ensure(serverDir, join(packageRoot, 'server'), 'server.py')) {\n    console.log(`[memory-mcp] installed memory-vault-server -> ${serverDir}`)\n  }\n  if (ensure(memoryPath, join(packageRoot, 'vault'), 'type-registry.yaml')) {\n    console.log(`[memory-mcp] installed vault starter -> ${memoryPath}`)\n  }\n  // launcher.mjs runs the server via uv or the pip-venv fallback; upgrades of\n  // existing installs (server.py already present) still need the new files.\n  const bundled = join(packageRoot, 'server')\n  for (const file of ['launcher.mjs', 'requirements.txt']) {\n    if (ensureFile(serverDir, bundled, file)) {\n      console.log(`[memory-mcp] installed ${file} -> ${serverDir}`)\n    }\n  }\n  if (!existsSync(join(serverDir, 'server.py'))) {\n    console.warn(\n      `[memory-mcp] memory-vault-server not found at ${serverDir} and not bundled — ` +\n      'set DSH_MEMORY_SERVER_DIR (or run `node scripts/bundle-assets.mjs` in a checkout)',\n    )\n  }\n}\n"],"mappings":";;;;;;;AAOA,MAAa,OAAO;AAOpB,MAAaA,SAAyB,OAAO,OAAO;CAClD,YAAY,OAAO,QAAQ,CAAC,QAAQ,QAAQ,IAAI,mBAAmB,GAAG;CACtE,WAAW,OAAO,QAAQ,CAAC,QAAQ,QAAQ,IAAI,yBAAyB,GAAG;CAC5E,CAAC;AAEF,MAAM,cAAc,QAAQ,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAC,CAAC;;AAGpE,SAAS,UAAkB;CACzB,MAAM,MAAM,QAAQ,IAAI,UAAU,MAAM;AACxC,QAAO,OAAO,IAAI,SAAS,IAAI,MAAM,KAAK,SAAS,EAAE,OAAO;;;AAI9D,SAAS,iBAAiB,OAAe,SAAyB;CAChE,MAAM,IAAI,MAAM,MAAM;AACtB,KAAI,EAAE,WAAW,EAAG,QAAO,KAAK,SAAS,EAAE,QAAQ;AACnD,QAAO,WAAW,EAAE,GAAG,IAAI,KAAK,SAAS,EAAE,EAAE;;;AAI/C,SAAS,OAAO,QAAgB,SAAiB,KAAsB;AACrE,KAAI,WAAW,KAAK,QAAQ,IAAI,CAAC,CAAE,QAAO;AAC1C,KAAI,CAAC,WAAW,QAAQ,CAAE,QAAO;AACjC,WAAU,QAAQ,EAAE,WAAW,MAAM,CAAC;AACtC,QAAO,SAAS,QAAQ,EAAE,WAAW,MAAM,CAAC;AAC5C,QAAO;;;AAIT,SAAS,WAAW,QAAgB,SAAiB,MAAuB;CAC1E,MAAM,OAAO,KAAK,QAAQ,KAAK;AAC/B,KAAI,WAAW,KAAK,CAAE,QAAO;CAC7B,MAAM,MAAM,KAAK,SAAS,KAAK;AAC/B,KAAI,CAAC,WAAW,IAAI,CAAE,QAAO;AAC7B,WAAU,QAAQ,EAAE,WAAW,MAAM,CAAC;AACtC,QAAO,KAAK,KAAK;AACjB,QAAO;;AAGT,SAAgB,MAAM,KAAc,QAAgB;CAClD,MAAM,YAAY,iBAAiB,OAAO,WAAW,sBAAsB;CAC3E,MAAM,aAAa,iBAAiB,OAAO,YAAY,eAAe;AAKtE,KAAI,OAAO,WAAW,KAAK,aAAa,SAAS,EAAE,YAAY,CAC7D,SAAQ,IAAI,iDAAiD,YAAY;AAE3E,KAAI,OAAO,YAAY,KAAK,aAAa,QAAQ,EAAE,qBAAqB,CACtE,SAAQ,IAAI,2CAA2C,aAAa;CAItE,MAAM,UAAU,KAAK,aAAa,SAAS;AAC3C,MAAK,MAAM,QAAQ,CAAC,gBAAgB,mBAAmB,CACrD,KAAI,WAAW,WAAW,SAAS,KAAK,CACtC,SAAQ,IAAI,0BAA0B,KAAK,MAAM,YAAY;AAGjE,KAAI,CAAC,WAAW,KAAK,WAAW,YAAY,CAAC,CAC3C,SAAQ,KACN,iDAAiD,UAAU,wGAE5D"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { cpSync, existsSync, mkdirSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { dirname, isAbsolute, join } from 'node:path'\nimport { fileURLToPath } from 'node:url'\nimport type { Context } from '@deepseek-ai/cordis'\nimport Schema from '@deepseek-ai/schemastery'\n\nexport const name = 'memory-mcp'\n\nexport interface Config {\n  memoryPath: string\n  serverDir: string\n}\n\nexport const Config: Schema<Config> = Schema.object({\n  memoryPath: Schema.string().default(process.env.DSH_MEMORY_PATH ?? ''),\n  serverDir: Schema.string().default(process.env.DSH_MEMORY_SERVER_DIR ?? ''),\n})\n\nconst packageRoot = dirname(dirname(fileURLToPath(import.meta.url)))\n\n/** Harness home, resolved like the harness itself ($DSH_HOME, or ~/.dsh). */\nfunction dshHome(): string {\n  const env = process.env.DSH_HOME?.trim()\n  return env && env.length > 0 ? env : join(homedir(), '.dsh')\n}\n\n/** Absolute paths stay; empty/relative values resolve under the harness home. */\nfunction resolveUnderHome(value: string, segment: string): string {\n  const v = value.trim()\n  if (v.length === 0) return join(dshHome(), segment)\n  return isAbsolute(v) ? v : join(dshHome(), v)\n}\n\n/** Copy the bundled dir into `target` when `key` is missing there. */\nfunction ensure(target: string, bundled: string, key: string): boolean {\n  if (existsSync(join(target, key))) return false\n  if (!existsSync(bundled)) return false\n  mkdirSync(target, { recursive: true })\n  cpSync(bundled, target, { recursive: true })\n  return true\n}\n\n/** Copy one bundled file into `target` when missing (upgrades add files 0.1.1 → 0.1.2). */\nfunction ensureFile(target: string, bundled: string, file: string): boolean {\n  const dest = join(target, file)\n  if (existsSync(dest)) return false\n  const src = join(bundled, file)\n  if (!existsSync(src)) return false\n  mkdirSync(target, { recursive: true })\n  cpSync(src, dest)\n  return true\n}\n\nexport function apply(ctx: Context, config: Config) {\n  const serverDir = resolveUnderHome(config.serverDir, 'memory-vault-server')\n  const memoryPath = resolveUnderHome(config.memoryPath, 'memory-vault')\n\n  // Self-contained install: first boot copies the bundled server and vault\n  // starter under the harness home when they are missing. Env-overridden\n  // paths are respected (never overwritten, never copied over).\n  if (ensure(serverDir, join(packageRoot, 'server'), 'server.py')) {\n    console.log(`[memory-mcp] installed memory-vault-server -> ${serverDir}`)\n  }\n  if (ensure(memoryPath, join(packageRoot, 'vault'), 'type-registry.yaml')) {\n    console.log(`[memory-mcp] installed vault starter -> ${memoryPath}`)\n  }\n  // launcher.mjs runs the server via uv or the pip-venv fallback; upgrades of\n  // existing installs (server.py already present) still need the new files.\n  const bundled = join(packageRoot, 'server')\n  for (const file of ['launcher.mjs', 'requirements.txt']) {\n    if (ensureFile(serverDir, bundled, file)) {\n      console.log(`[memory-mcp] installed ${file} -> ${serverDir}`)\n    }\n  }\n  if (!existsSync(join(serverDir, 'server.py'))) {\n    console.warn(\n      `[memory-mcp] memory-vault-server not found at ${serverDir} and not bundled — ` +\n      'set DSH_MEMORY_SERVER_DIR (or run `node scripts/bundle-assets.mjs` in a checkout)',\n    )\n  }\n}\n"],"mappings":";;;;;;AAOA,MAAa,OAAO;AAOpB,MAAa,SAAyB,OAAO,OAAO;CAClD,YAAY,OAAO,OAAO,CAAC,CAAC,QAAQ,QAAQ,IAAI,mBAAmB,EAAE;CACrE,WAAW,OAAO,OAAO,CAAC,CAAC,QAAQ,QAAQ,IAAI,yBAAyB,EAAE;AAC5E,CAAC;AAED,MAAM,cAAc,QAAQ,QAAQ,cAAc,YAAY,GAAG,CAAC,CAAC;;AAGnE,SAAS,UAAkB;CACzB,MAAM,MAAM,QAAQ,IAAI,UAAU,KAAK;CACvC,OAAO,OAAO,IAAI,SAAS,IAAI,MAAM,KAAK,QAAQ,GAAG,MAAM;AAC7D;;AAGA,SAAS,iBAAiB,OAAe,SAAyB;CAChE,MAAM,IAAI,MAAM,KAAK;CACrB,IAAI,EAAE,WAAW,GAAG,OAAO,KAAK,QAAQ,GAAG,OAAO;CAClD,OAAO,WAAW,CAAC,IAAI,IAAI,KAAK,QAAQ,GAAG,CAAC;AAC9C;;AAGA,SAAS,OAAO,QAAgB,SAAiB,KAAsB;CACrE,IAAI,WAAW,KAAK,QAAQ,GAAG,CAAC,GAAG,OAAO;CAC1C,IAAI,CAAC,WAAW,OAAO,GAAG,OAAO;CACjC,UAAU,QAAQ,EAAE,WAAW,KAAK,CAAC;CACrC,OAAO,SAAS,QAAQ,EAAE,WAAW,KAAK,CAAC;CAC3C,OAAO;AACT;;AAGA,SAAS,WAAW,QAAgB,SAAiB,MAAuB;CAC1E,MAAM,OAAO,KAAK,QAAQ,IAAI;CAC9B,IAAI,WAAW,IAAI,GAAG,OAAO;CAC7B,MAAM,MAAM,KAAK,SAAS,IAAI;CAC9B,IAAI,CAAC,WAAW,GAAG,GAAG,OAAO;CAC7B,UAAU,QAAQ,EAAE,WAAW,KAAK,CAAC;CACrC,OAAO,KAAK,IAAI;CAChB,OAAO;AACT;AAEA,SAAgB,MAAM,KAAc,QAAgB;CAClD,MAAM,YAAY,iBAAiB,OAAO,WAAW,qBAAqB;CAC1E,MAAM,aAAa,iBAAiB,OAAO,YAAY,cAAc;CAKrE,IAAI,OAAO,WAAW,KAAK,aAAa,QAAQ,GAAG,WAAW,GAC5D,QAAQ,IAAI,iDAAiD,WAAW;CAE1E,IAAI,OAAO,YAAY,KAAK,aAAa,OAAO,GAAG,oBAAoB,GACrE,QAAQ,IAAI,2CAA2C,YAAY;CAIrE,MAAM,UAAU,KAAK,aAAa,QAAQ;CAC1C,KAAK,MAAM,QAAQ,CAAC,gBAAgB,kBAAkB,GACpD,IAAI,WAAW,WAAW,SAAS,IAAI,GACrC,QAAQ,IAAI,0BAA0B,KAAK,MAAM,WAAW;CAGhE,IAAI,CAAC,WAAW,KAAK,WAAW,WAAW,CAAC,GAC1C,QAAQ,KACN,iDAAiD,UAAU,uGAE7D;AAEJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luisarg/memory-mcp",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "description": "DSH MCP client for the memory vault",
   "repository": {
@@ -30,14 +30,14 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "test": "vitest run --passWithNoTests",
-    "prepare": "tsdown && node ../../scripts/bundle-assets.mjs"
+    "prepare": "tsdown"
   },
   "dependencies": {
-    "@deepseek-ai/cordis": "4.0.1",
-    "@deepseek-ai/schemastery": "3.18.1"
+    "@deepseek-ai/cordis": "4.0.2",
+    "@deepseek-ai/schemastery": "3.18.2"
   },
   "devDependencies": {
-    "typescript": "^5.9.2",
-    "tsdown": "^0.15.6"
+    "typescript": "^7.0.2",
+    "tsdown": "^0.23.0"
   }
 }

package/server/launcher.mjs

@@ -12,6 +12,7 @@
 
 import { spawn, spawnSync } from 'node:child_process'
 import { existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
@@ -57,7 +58,10 @@ function main() {
   const withUv = hasUv()
   const { command, args } = resolveRunner(withUv)
   if (!withUv) ensurePipEnv()
-  const child = spawn(command, args, { cwd: DIR, env: process.env, stdio: 'inherit' })
+  // Default the uv cache under the OS temp dir (Windows has no /tmp); an
+  // explicit UV_CACHE_DIR from the patch layer or env still wins.
+  const env = { UV_CACHE_DIR: join(tmpdir(), 'uv-cache'), ...process.env }
+  const child = spawn(command, args, { cwd: DIR, env, stdio: 'inherit' })
   for (const sig of ['SIGTERM', 'SIGINT']) process.on(sig, () => child.kill(sig))
   child.on('error', (err) => {
     console.error(`[memory-vault-server] spawn failed (${command}): ${err.message}`)

package/server/rebuild_index.py

@@ -0,0 +1,191 @@
+"""Rebuild the SQLite FTS5 index from the OKF Markdown bundle (index-only).
+
+Walks `projects/<project>/<type>/*.md` and `raw/*.md`, parses each file and
+inserts rows directly into SQLite. Markdown stays the source of truth: this
+script never rewrites .md files (upsert_entry's write path would duplicate
+them with today's date on a fresh DB).
+
+Idempotent: row ids derive from file paths, dedup keys from content, so
+re-running converges. Run after importing a bundle into a new vault dir
+(memory.db* may be deleted first; the script also works on a populated DB):
+
+    uv run --directory memory-vault-server python rebuild_index.py \
+        --memory-path /path/to/vault
+
+DB-only data (profiles) is NOT covered — migrate profiles separately.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import os
+import sys
+from pathlib import Path
+
+_store_mod = None  # set in main() once MEMORY_PATH points at the target bundle
+
+
+def _id_for(relpath: Path) -> str:
+    """Stable row id derived from the file path (idempotent re-runs)."""
+    digest = hashlib.sha1(str(relpath).encode()).hexdigest()[:24]
+    return f"rebuild-{digest}"
+
+
+def _collect(memory_path: Path):
+    """Walk the bundle -> (entries, errors); entries are
+    (singular, project, relpath, parsed) tuples, DB-only types skipped."""
+    entries: list[tuple[str, str, Path, dict]] = []
+    errors: list[str] = []
+    dir_to_singular = _store_mod._DIR_TO_SINGULAR
+    parse = _store_mod._parse_okf_file
+
+    def handle(path: Path, parsed: dict | None, default_project: str, singular: str):
+        if parsed is None:
+            errors.append(f"unparseable: {path.relative_to(memory_path)}")
+            return
+        # Defensive: trust the directory, not the parsed label.
+        parsed["entry_type"] = singular
+        parsed["project"] = parsed.get("project") or default_project
+        entries.append((singular, parsed["project"], path.relative_to(memory_path), parsed))
+
+    projects_dir = memory_path / "projects"
+    if projects_dir.is_dir():
+        # Projects may nest (e.g. `@deepseek-ai/dsh-root`): any directory whose
+        # name is a type dir is indexed; its project is the dir path below
+        # `projects/`, joined with "/".
+        def scan(prefix: Path, project: str):
+            for d in sorted(child for child in prefix.iterdir() if child.is_dir()):
+                singular = dir_to_singular.get(d.name)
+                if singular is None:
+                    if d.name != ".obsidian":
+                        scan(d, f"{project}/{d.name}" if project else d.name)
+                    continue
+                if singular == "profile":
+                    continue
+                for f in sorted(d.glob("*.md")):
+                    if f.name == "index.md":
+                        continue
+                    handle(f, parse(f), project, singular)
+
+        for proj_dir in sorted(p for p in projects_dir.iterdir() if p.is_dir()):
+            scan(proj_dir, proj_dir.name)
+
+    raw_dir = memory_path / "raw"
+    if raw_dir.is_dir():
+        for f in sorted(raw_dir.glob("*.md")):
+            handle(f, parse(f), "", "source")
+
+    return entries, errors
+
+
+def rebuild(memory_path: Path) -> tuple[int, int, list[str]]:
+    """Insert all bundle entries into the index -> (inserted, updated, errors)."""
+    store = _store_mod.MemoryStore(storage_path=memory_path)
+    store.initialize()
+
+    entries, errors = _collect(memory_path)
+    if not entries:
+        print("No entries found in bundle; nothing to do.", file=sys.stderr)
+        return 0, 0, errors
+
+    n_inserted = n_updated = 0
+    for singular, project, relpath, e in entries:
+        try:
+            dedup_key = (
+                store._make_dedup_key(singular, project, e["content"])
+                if singular != "source"
+                else _id_for(relpath)
+            )
+            existing = store.db.execute(
+                "SELECT id FROM entries WHERE dedup_key = ?", (dedup_key,)
+            ).fetchone()
+            if existing:
+                if existing["id"] != _id_for(relpath):
+                    # Same content already indexed (bundle duplicates collapse):
+                    # adopt this file's id so re-runs converge, keep row content.
+                    store.db.execute(
+                        "UPDATE entries SET id = ?, created_at = ?, updated_at = ? WHERE dedup_key = ?",
+                        (_id_for(relpath), e["created_at"], e["updated_at"], dedup_key),
+                    )
+                    store.db.commit()
+                n_updated += 1
+                continue
+            store._insert_row(
+                _id_for(relpath),
+                singular,
+                project,
+                e["content"],
+                e["tags"],
+                float(e["confidence"] or 1.0),
+                e["openspec_change_id"],
+                dedup_key,
+                e["created_at"],
+                e["updated_at"],
+            )
+            n_inserted += 1
+        except Exception as exc:  # noqa: BLE001 — one bad file must not stop the rebuild
+            errors.append(f"failed: {project}/{relpath}: {exc}")
+    return n_inserted, n_updated, errors
+
+
+def regen_missing_indexes(memory_path: Path, store) -> int:
+    """Regenerate `<project>/index.md` only where it is missing (nested too)."""
+    projects_dir = memory_path / "projects"
+    if not projects_dir.is_dir():
+        return 0
+    n = 0
+
+    def scan(prefix: Path):
+        for d in sorted(child for child in prefix.iterdir() if child.is_dir()):
+            if d.name in _store_mod._DIR_TO_SINGULAR or d.name == ".obsidian":
+                continue  # type dir or editor cache — not a project
+            if not (d / "index.md").exists():
+                project = str(d.relative_to(projects_dir)).replace(os.sep, "/")
+                store._regenerate_project_index(project)
+                n += 1
+            scan(d)
+
+    for proj_dir in sorted(p for p in projects_dir.iterdir() if p.is_dir()):
+        if not (proj_dir / "index.md").exists():
+            store._regenerate_project_index(proj_dir.name)
+            n += 1
+        scan(proj_dir)
+    return n
+
+
+def main(argv: list[str] | None = None) -> int:
+    global _store_mod
+    parser = argparse.ArgumentParser(description="Rebuild SQLite index from OKF bundle")
+    parser.add_argument(
+        "--memory-path",
+        default=None,
+        help="OKF bundle directory (default: $MEMORY_PATH or repo memory-vault)",
+    )
+    args = parser.parse_args(argv)
+
+    # store.py builds its type maps from MEMORY_PATH at import time — point it
+    # at the target bundle before importing.
+    if args.memory_path:
+        os.environ["MEMORY_PATH"] = str(Path(args.memory_path).resolve())
+    import store as _store_mod
+
+    memory_path = Path(os.environ.get("MEMORY_PATH", "")).resolve()
+    if not memory_path.is_dir():
+        print(f"error: {memory_path} is not a directory", file=sys.stderr)
+        return 2
+
+    print(f"Rebuilding index from {memory_path} ...")
+    n_ins, n_upd, errors = rebuild(memory_path)
+    store = _store_mod.MemoryStore(storage_path=memory_path)
+    store.initialize()
+    n_index = regen_missing_indexes(memory_path, store)
+    print(f"Inserted: {n_ins}, already-indexed: {n_upd}, index.md regenerated: {n_index}")
+    for err in errors:
+        print(f"  {err}", file=sys.stderr)
+    print(f"Errors: {len(errors)}")
+    return 0 if not errors else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/server/server.py

@@ -1,8 +1,13 @@
 """MCP server exposing memory store tools via the Model Context Protocol.
 
-Eight tools (per openspec/specs/memory-mcp-server/spec.md):
+Ten tools (per openspec/specs/memory-mcp-server/spec.md):
     search_memory, store_decision, store_fact, store_learning,
-    store_convention, store_profile, export_memories, get_profile, ping.
+    store_convention, store_profile, store_source, export_memories,
+    get_profile, ping.
+
+Note: `type-registry.yaml` also declares `context` and `idea`. They are valid
+`entries.entry_type` values and legal filters here, but no `store_*` tool
+creates them — nothing writes them today.
 
 All reads are explicit (no background polling). Server validates storage
 accessibility at startup.
@@ -190,7 +195,13 @@ def _tool_definitions() -> list[Tool]:
     return [
         Tool(
             name="search_memory",
-            description="Search memory entries across projects. Omit project to search all projects.",
+            description=(
+                "Search memory entries across projects. Omit project to search all projects. "
+                "The query is tokenized and OR-matched (any term hits), ranked by relevance. "
+                "Tags are OR-matched too: passing ['ci','release'] returns entries with either tag. "
+                "Filters narrow the result set; at most 50 entries are returned. "
+                "Source entries are excluded unless entry_type='source' with no other filter."
+            ),
             inputSchema={
                 "type": "object",
                 "properties": {
@@ -203,78 +214,143 @@ def _tool_definitions() -> list[Tool]:
         ),
         Tool(
             name="store_decision",
-            description="Store a decision entry",
+            description=(
+                "Store a decision: an architectural or design choice that was made and why. "
+                "Deduplicated by content hash, so re-storing the same text updates instead of "
+                "duplicating."
+            ),
             inputSchema={
                 "type": "object",
                 "required": ["project", "content"],
                 "properties": {
                     "project": {"type": "string"},
-                    "content": {"type": "string"},
-                    "description": {"type": "string"},
-                    "tags": {"type": "array", "items": {"type": "string"}},
+                    "content": {
+                        "type": "string",
+                        "description": "One paragraph, no headings or bullet lists.",
+                    },
+                    "description": {
+                        "type": "string",
+                        "description": "One-sentence queryable summary; derived from content if omitted.",
+                    },
+                    "tags": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Lowercase-kebab tags, e.g. architecture/python/testing.",
+                    },
                     "openspec_change_id": {"type": "string"},
                 },
             },
         ),
         Tool(
             name="store_fact",
-            description="Store a fact entry",
+            description=(
+                "Store a fact: a stable, verifiable statement about the project (version, "
+                "constraint, path, endpoint). Deduplicated by content hash. Prefer one atomic "
+                "fact per call over a bundle of several."
+            ),
             inputSchema={
                 "type": "object",
                 "required": ["project", "content"],
                 "properties": {
                     "project": {"type": "string"},
-                    "content": {"type": "string"},
-                    "description": {"type": "string"},
-                    "tags": {"type": "array", "items": {"type": "string"}},
+                    "content": {
+                        "type": "string",
+                        "description": "One paragraph, no headings or bullet lists.",
+                    },
+                    "description": {
+                        "type": "string",
+                        "description": "One-sentence queryable summary; derived from content if omitted.",
+                    },
+                    "tags": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Lowercase-kebab tags, e.g. architecture/python/testing.",
+                    },
                     "confidence": {"type": "number", "minimum": 0.0, "maximum": 1.0},
                 },
             },
         ),
         Tool(
             name="store_learning",
-            description="Store a learning entry",
+            description=(
+                "Store a learning: a non-obvious lesson, debugging insight, or solution found — "
+                "something that cost effort and would otherwise be rediscovered. Deduplicated by "
+                "content hash."
+            ),
             inputSchema={
                 "type": "object",
                 "required": ["project", "content"],
                 "properties": {
                     "project": {"type": "string"},
-                    "content": {"type": "string"},
-                    "description": {"type": "string"},
-                    "tags": {"type": "array", "items": {"type": "string"}},
+                    "content": {
+                        "type": "string",
+                        "description": "One paragraph, no headings or bullet lists.",
+                    },
+                    "description": {
+                        "type": "string",
+                        "description": "One-sentence queryable summary; derived from content if omitted.",
+                    },
+                    "tags": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Lowercase-kebab tags, e.g. architecture/python/testing.",
+                    },
                 },
             },
         ),
         Tool(
             name="store_convention",
-            description="Store a convention entry",
+            description=(
+                "Store a convention: an agreed style rule, naming pattern, or coding standard. "
+                "Deduplicated by content hash."
+            ),
             inputSchema={
                 "type": "object",
                 "required": ["project", "content"],
                 "properties": {
                     "project": {"type": "string"},
-                    "content": {"type": "string"},
-                    "description": {"type": "string"},
-                    "tags": {"type": "array", "items": {"type": "string"}},
+                    "content": {
+                        "type": "string",
+                        "description": "One paragraph, no headings or bullet lists.",
+                    },
+                    "description": {
+                        "type": "string",
+                        "description": "One-sentence queryable summary; derived from content if omitted.",
+                    },
+                    "tags": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Lowercase-kebab tags, e.g. architecture/python/testing.",
+                    },
                 },
             },
         ),
         Tool(
             name="store_profile",
-            description="Store or update a user profile entry for a project",
+            description=(
+                "Replace the tech profile for a project. One profile per project: the content "
+                "overwrites the previous one, it does not append. Pass the complete profile text."
+            ),
             inputSchema={
                 "type": "object",
                 "required": ["project", "content"],
                 "properties": {
                     "project": {"type": "string"},
-                    "content": {"type": "string"},
+                    "content": {
+                        "type": "string",
+                        "description": "The full profile — replaces the stored one.",
+                    },
                     "tags": {"type": "array", "items": {"type": "string"}},
                 },
             },
         ),
         Tool(
             name="store_source",
-            description="Store a source reference (article, transcript, PDF, video, link)",
+            description=(
+                "Store an external source reference (article, transcript, PDF, video, link) under "
+                "raw/. Immutable: a later store with the same URL returns the existing entry, and "
+                "reusing a title slug with different content is rejected."
+            ),
             inputSchema={
                 "type": "object",
                 "required": ["url", "title", "description", "source_kind"],
@@ -294,7 +370,10 @@ def _tool_definitions() -> list[Tool]:
         ),
         Tool(
             name="export_memories",
-            description="Export all memory entries for a project (no limit)",
+            description=(
+                "Export every stored entry for one project, newest first, with no result limit. "
+                "Use for a full project dump, not for lookups — search_memory is cheaper."
+            ),
             inputSchema={
                 "type": "object",
                 "required": ["project"],
@@ -306,7 +385,11 @@ def _tool_definitions() -> list[Tool]:
         ),
         Tool(
             name="get_profile",
-            description="Retrieve the global tech profile for a project",
+            description=(
+                "Retrieve the stored tech profile for a project. Returns profile entries by "
+                "default; pass entry_type to query another type instead (then it is a "
+                "most-recent-first lookup capped at 10)."
+            ),
             inputSchema={
                 "type": "object",
                 "required": ["project"],

package/server/store.py

@@ -263,7 +263,10 @@ class MemoryStore:
         db_path = self.storage_path / "memory.db"
         if db_path.exists() and db_path.stat().st_size > 0:
             try:
-                test_conn = sqlite3.connect(str(db_path))
+                # timeout=30: with WAL a live vault may be written by another
+                # client (DSH + opencode). Without it the probe waits only 5 s
+                # and a busy lock surfaces as "corrupt database".
+                test_conn = sqlite3.connect(str(db_path), timeout=30)
                 row = test_conn.execute("PRAGMA integrity_check").fetchone()
                 test_conn.close()
                 if row[0].lower() != "ok":
@@ -271,7 +274,7 @@ class MemoryStore:
             except sqlite3.DatabaseError as e:
                 raise RuntimeError(f"corrupt database: {e}") from e
 
-        self._db = sqlite3.connect(str(db_path))
+        self._db = sqlite3.connect(str(db_path), timeout=30)
         self._db.row_factory = sqlite3.Row
         self.db.execute("PRAGMA journal_mode=WAL")
         self.db.execute("PRAGMA foreign_keys=ON")
@@ -767,12 +770,15 @@ class MemoryStore:
         project: str,
         entry_type: str | None = None,
     ) -> list[dict]:
-        """Retrieve profile entries for a project."""
-        sql = "SELECT * FROM entries WHERE project = ?"
-        params: list = [project]
-        if entry_type:
-            sql += " AND entry_type = ?"
-            params.append(entry_type)
+        """Retrieve the profile for a project.
+
+        Defaults to ``profile`` entries: the tool is named get_profile, so an
+        unfiltered call returning the 10 most recent rows of any type was a
+        silent wrong answer. Pass ``entry_type`` to use it as a recency query.
+        """
+        entry_type = entry_type or "profile"
+        sql = "SELECT * FROM entries WHERE project = ? AND entry_type = ?"
+        params: list = [project, entry_type]
         sql += " ORDER BY updated_at DESC LIMIT 10"
         rows = self.db.execute(sql, params).fetchall()
         return [dict(r) for r in rows]

package/server/test_get_profile.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Self-check: get_profile answers with the profile, not with recent noise.
+
+Regression guard for the bug where an unfiltered get_profile returned the 10
+most recently updated rows of ANY type, so a caller asking for the profile of a
+busy project got unrelated decisions and facts.
+
+Run: python3 memory-vault-server/test_get_profile.py
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+SERVER_DIR = Path(__file__).resolve().parent
+REPO_VAULT = SERVER_DIR.parent / "memory-vault"
+sys.path.insert(0, str(SERVER_DIR))
+
+
+def main() -> int:
+    with tempfile.TemporaryDirectory() as tmp:
+        # store.py resolves the type registry from MEMORY_PATH at import time,
+        # so seed the throwaway vault before importing it.
+        vault = Path(tmp)
+        (vault / "projects").mkdir()
+        shutil.copy(REPO_VAULT / "type-registry.yaml", vault / "type-registry.yaml")
+        os.environ["MEMORY_PATH"] = str(vault)
+        import store as store_mod
+
+        s = store_mod.MemoryStore(storage_path=vault)
+        s.initialize()
+
+        s.upsert_profile(project="proj", content="PROFILE: python + sqlite")
+        # Written afterwards, so these outrank the profile in updated_at:
+        # the old code returned them and called it a profile.
+        s.upsert_entry("decision", "proj", "DECISION: use sqlite for storage")
+        s.upsert_entry("fact", "proj", "FACT: python 3.11 is required")
+
+        got = s.get_profile(project="proj")
+        assert len(got) == 1, f"expected only the profile row, got {len(got)}: {got}"
+        assert got[0]["entry_type"] == "profile", got[0]["entry_type"]
+        assert "PROFILE" in got[0]["content"], got[0]["content"]
+
+        # entry_type=None must behave exactly like the default.
+        assert s.get_profile(project="proj", entry_type=None) == got
+
+        # Explicit entry_type still works (and is now a plain recency lookup).
+        facts = s.get_profile(project="proj", entry_type="fact")
+        assert len(facts) == 1 and facts[0]["entry_type"] == "fact", facts
+
+        # A project with no profile yields nothing rather than unrelated rows.
+        s.upsert_entry("fact", "other", "FACT: unrelated project")
+        assert s.get_profile(project="other") == [], "profile leaked across projects"
+
+        # The MCP tool handler agrees (binds the tool default to the store fix).
+        # Needs the pinned `mcp` version from requirements.txt; skip when the
+        # ambient one is older instead of failing the whole check.
+        try:
+            import server
+
+            found = json.loads(server.handle_get_profile(s, {"project": "proj"}))
+            assert len(found) == 1 and found[0]["entry_type"] == "profile", found
+        except ImportError as exc:
+            print(f"skip: MCP handler assertion ({exc})")
+
+        s._db.close()
+
+    print("ok: get_profile returns the profile, not the most recent rows")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())