claude-mem-lite 2.26.1 → 2.28.2

package/registry-importer.mjs

@@ -0,0 +1,358 @@
+// claude-mem-lite: Registry importer — tree discovery, frontmatter parsing, keyword extraction, GitHub import pipeline
+// GitHub API helpers (parseGitHubUrl, buildTreeUrl, buildContentUrl, buildHeaders)
+// are in registry-github.mjs.
+
+import { parseGitHubUrl, buildTreeUrl, buildContentUrl, buildRepoUrl, buildHeaders } from './registry-github.mjs';
+import { upsertResource } from './registry.mjs';
+import { debugLog, isPathConfined } from './utils.mjs';
+import { createHash } from 'crypto';
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const MANAGED_DIR = join(homedir(), '.claude-mem-lite', 'managed');
+
+// ─── Tree Discovery ─────────────────────────────────────────────────────────
+
+// Patterns: flat (skills/name/SKILL.md), plugin (plugins/x/skills/y/SKILL.md),
+// agent (agents/name/AGENT.md), root (./SKILL.md)
+const SKILL_RE = /(?:^|\/)(skills\/([^/]+)\/SKILL\.md)$/;
+const AGENT_RE = /(?:^|\/)(agents\/([^/]+)\/AGENT\.md)$/;
+const PLUGIN_SKILL_RE = /^plugins\/([^/]+)\/skills\/([^/]+)\/SKILL\.md$/;
+const ROOT_SKILL_RE = /^SKILL\.md$/;
+
+/**
+ * Discover skills/agents from a GitHub tree API response.
+ * Supports flat (skills/name/SKILL.md), plugin (plugins/x/skills/y/SKILL.md),
+ * and root (./SKILL.md) layouts.
+ * @param {object} treeData GitHub API tree response { tree: [{ path, type }] }
+ * @param {string} pathFilter Only include paths under this prefix (empty = all)
+ * @returns {Array<{ name: string, type: 'skill'|'agent', filePath: string }>}
+ */
+export function discoverFromTree(treeData, pathFilter) {
+  const results = [];
+  if (!treeData?.tree) return results;
+
+  for (const item of treeData.tree) {
+    if (item.type !== 'blob') continue;
+    const p = item.path;
+
+    // Apply path filter
+    if (pathFilter && !p.startsWith(pathFilter)) continue;
+
+    // Plugin-nested skill: plugins/x/skills/y/SKILL.md → name = "x/y"
+    const pluginMatch = p.match(PLUGIN_SKILL_RE);
+    if (pluginMatch) {
+      results.push({ name: `${pluginMatch[1]}/${pluginMatch[2]}`, type: 'skill', filePath: p });
+      continue;
+    }
+
+    // Flat skill: skills/name/SKILL.md → name = "name"
+    const skillMatch = p.match(SKILL_RE);
+    if (skillMatch) {
+      results.push({ name: skillMatch[2], type: 'skill', filePath: p });
+      continue;
+    }
+
+    // Agent: agents/name/AGENT.md → name = "name"
+    const agentMatch = p.match(AGENT_RE);
+    if (agentMatch) {
+      results.push({ name: agentMatch[2], type: 'agent', filePath: p });
+      continue;
+    }
+
+    // Root-level SKILL.md
+    if (ROOT_SKILL_RE.test(p)) {
+      results.push({ name: 'root', type: 'skill', filePath: p });
+      continue;
+    }
+
+    // Generic: any-dir/SKILL.md or any-dir/AGENT.md (non-standard layouts)
+    const genericSkill = p.match(/^([^/]+)\/SKILL\.md$/);
+    if (genericSkill) {
+      results.push({ name: genericSkill[1], type: 'skill', filePath: p });
+      continue;
+    }
+    const genericAgent = p.match(/^([^/]+)\/AGENT\.md$/);
+    if (genericAgent) {
+      results.push({ name: genericAgent[1], type: 'agent', filePath: p });
+      continue;
+    }
+  }
+
+  return results;
+}
+
+// ─── YAML Frontmatter Parser ────────────────────────────────────────────────
+// Lightweight YAML subset parser for skill/agent frontmatter.
+// Known limitations: does not handle YAML arrays (- item), nested objects,
+// or unquoted values containing colons (e.g. bare URLs). For such fields,
+// wrap the value in quotes in the frontmatter: url: "https://..."
+
+/**
+ * Parse YAML frontmatter from SKILL.md / AGENT.md content.
+ * Handles basic key: value, multiline (|, >), JSON arrays ([...]), quoted strings.
+ * @param {string} content Full file content
+ * @returns {{ frontmatter: Record<string, any>, body: string }}
+ */
+export function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return { frontmatter: {}, body: content };
+
+  const raw = match[1];
+  const body = content.slice(match[0].length).trim();
+  const fm = {};
+  let currentKey = null, currentValue = '', inMultiline = false;
+
+  for (const line of raw.split('\n')) {
+    if (inMultiline && (line.startsWith('  ') || line.startsWith('\t') || line.trim() === '')) {
+      currentValue += ' ' + line.trim();
+      continue;
+    }
+    if (inMultiline && currentKey) { fm[currentKey] = currentValue.trim(); inMultiline = false; }
+
+    const kv = line.match(/^(\w[\w-]*)\s*:\s*(.*)/);
+    if (kv) {
+      currentKey = kv[1];
+      let val = kv[2].trim();
+      if (val === '|' || val === '>') { inMultiline = true; currentValue = ''; continue; }
+      if (val.startsWith('[') && val.endsWith(']')) {
+        try { fm[currentKey] = JSON.parse(val); } catch { fm[currentKey] = val; }
+        continue;
+      }
+      if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'")))
+        val = val.slice(1, -1);
+      if (currentKey === 'description' && val) { inMultiline = true; currentValue = val; continue; }
+      fm[currentKey] = val;
+    }
+  }
+  if (inMultiline && currentKey) fm[currentKey] = currentValue.trim();
+  return { frontmatter: fm, body };
+}
+
+// ─── Keyword Extraction ─────────────────────────────────────────────────────
+
+const STOP_WORDS = new Set([
+  'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with',
+  'by', 'from', 'up', 'about', 'into', 'through', 'during', 'before', 'after',
+  'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do',
+  'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'shall',
+  'not', 'no', 'nor', 'so', 'if', 'then', 'than', 'that', 'this', 'these', 'those',
+  'it', 'its', 'as', 'such', 'which', 'who', 'whom', 'what', 'when', 'where', 'how',
+  'all', 'each', 'every', 'both', 'few', 'more', 'most', 'other', 'some', 'any',
+  'can', 'use', 'using', 'used', 'also', 'just', 'very', 'only', 'own', 'same',
+  'make', 'like', 'get', 'set', 'new', 'one', 'two', 'see', 'way', 'well',
+]);
+
+const INTENT_MAP = {
+  test:       [/\btest\b/i, /\btdd\b/i, /\bunit\s*test/i, /\be2e\b/i, /\bspec\b/i, /\bcoverage\b/i],
+  debug:      [/\bdebug\b/i, /\btroubleshoot\b/i, /\bdiagnose\b/i, /\berror\b/i, /\bbug\b/i],
+  deploy:     [/\bdeploy\b/i, /\bci[\s/]*cd\b/i, /\bpipeline\b/i, /\brelease\b/i, /\bship\b/i, /\bpublish\b/i],
+  review:     [/\breview\b/i, /\baudit\b/i, /\blint\b/i, /\binspect\b/i, /code\s*quality/i],
+  generate:   [/\bcreate\b/i, /\bscaffold\b/i, /\bgenerate\b/i, /\bboilerplate\b/i],
+  refactor:   [/\brefactor\b/i, /\boptimize\b/i, /\bclean\s*up\b/i, /\bsimplify\b/i],
+  document:   [/\bdocument\b/i, /\bdocs?\b/i, /\breadme\b/i, /\bjsdoc\b/i],
+  plan:       [/\bplan\b/i, /\bdesign\b/i, /\barchitect\b/i, /\bblueprint\b/i],
+  security:   [/\bsecurity\b/i, /\bvulnerab/i, /\bauthenticat/i, /\bencrypt/i],
+  performance:[/\bperformance\b/i, /\bprofil/i, /\bbenchmark\b/i, /\blatency\b/i],
+  migrate:    [/\bmigrat/i, /\bupgrad/i, /\blegacy\b/i],
+};
+
+const DOMAIN_PATTERNS = {
+  frontend:       [/\breact\b/i, /\bvue\b/i, /\bangular\b/i, /\bsvelte\b/i, /\bnext\.?js\b/i, /\bcss\b/i, /\btailwind\b/i, /\bhtml\b/i],
+  backend:        [/\bexpress\b/i, /\bfastapi\b/i, /\bdjango\b/i, /\bflask\b/i, /\brails\b/i, /\bspring\b/i],
+  database:       [/\bpostgres/i, /\bmysql\b/i, /\bmongodb\b/i, /\bredis\b/i, /\bsqlite\b/i, /\bsql\b/i],
+  infrastructure: [/\bdocker\b/i, /\bkubernetes\b/i, /\bterraform\b/i, /\bansible\b/i, /\bcloud\b/i, /\baws\b/i, /\bgcp\b/i, /\bazure\b/i],
+  javascript:     [/\bjavascript\b/i, /\btypescript\b/i, /\bnode\b/i, /\bnpm\b/i, /\besm\b/i],
+  python:         [/\bpython\b/i, /\bpip\b/i, /\bpydantic\b/i, /\bpoetry\b/i],
+  testing:        [/\bjest\b/i, /\bvitest\b/i, /\bpytest\b/i, /\bcypress\b/i, /\bplaywright\b/i],
+  security:       [/\boauth\b/i, /\bjwt\b/i, /\bssl\b/i, /\btls\b/i, /\brbac\b/i],
+  ml:             [/\bmachine\s*learning\b/i, /\bneural\b/i, /\btensor/i, /\bpytorch\b/i, /\bllm\b/i],
+  mobile:         [/\bios\b/i, /\bandroid\b/i, /react.native/i, /\bflutter\b/i, /\bswift\b/i],
+};
+
+/**
+ * Extract keywords, intent tags, and domain tags from content.
+ * @param {string} content Full text
+ * @returns {{ keywords: string, intentTags: string, domainTags: string }}
+ */
+export function extractKeywords(content) {
+  if (!content) return { keywords: '', intentTags: '', domainTags: '' };
+
+  const text = content.toLowerCase();
+
+  // ── Keywords: stop-word filtered frequency counting, top 10 ────────────
+  const words = text.match(/\b[a-z][a-z0-9]{2,}\b/g) || [];
+  const freq = {};
+  for (const w of words) {
+    if (!STOP_WORDS.has(w)) freq[w] = (freq[w] || 0) + 1;
+  }
+  const keywords = Object.entries(freq)
+    .sort(([, a], [, b]) => b - a)
+    .slice(0, 10)
+    .map(([w]) => w)
+    .join(' ');
+
+  // ── Intent tags ───────────────────────────────────────────────────────
+  const intents = [];
+  for (const [intent, patterns] of Object.entries(INTENT_MAP)) {
+    if (patterns.some(re => re.test(text))) intents.push(intent);
+  }
+  const intentTags = intents.join(' ');
+
+  // ── Domain tags ───────────────────────────────────────────────────────
+  const domains = [];
+  for (const [domain, patterns] of Object.entries(DOMAIN_PATTERNS)) {
+    if (patterns.some(re => re.test(text))) domains.push(domain);
+  }
+  const domainTags = domains.join(' ');
+
+  return { keywords, intentTags, domainTags };
+}
+
+// ─── GitHub Import Pipeline ─────────────────────────────────────────────────
+
+/**
+ * Import skills/agents from a GitHub URL into the registry.
+ * Stage 1 only — pure code, no LLM.
+ * @param {Database} db Registry database
+ * @param {string} url GitHub URL
+ * @param {object} opts Options
+ * @param {Function} opts.fetchFn Override fetch function (for testing)
+ * @param {string} opts.managedDir Override managed directory (for testing)
+ * @returns {Promise<Array<{ name: string, type: string, id: number }>>}
+ */
+export async function importFromGitHub(db, url, opts = {}) {
+  const fetchFn = opts.fetchFn || globalThis.fetch;
+  const managedDir = opts.managedDir || MANAGED_DIR;
+  const headers = buildHeaders();
+
+  // 1. Parse GitHub URL
+  const parsed = parseGitHubUrl(url);
+  if (!parsed) throw new Error('Invalid GitHub URL');
+  const { owner, repo, branch, path: pathFilter } = parsed;
+
+  // 2. Fetch repo metadata (stars, forks, updated_at)
+  const repoResp = await fetchFn(buildRepoUrl(owner, repo), { headers });
+  if (!repoResp.ok) {
+    if (repoResp.status === 404) throw new Error(`Repository not found: ${owner}/${repo}`);
+    if (repoResp.status === 403) throw new Error(`GitHub API rate limit exceeded`);
+    throw new Error(`GitHub API error: ${repoResp.status}`);
+  }
+  const repoMeta = await repoResp.json();
+  const repoStars = repoMeta.stargazers_count || 0;
+  const repoForks = repoMeta.forks_count || 0;
+  const repoUpdatedAt = repoMeta.updated_at || null;
+
+  // 3. Fetch file tree via GitHub API (recursive)
+  const treeResp = await fetchFn(buildTreeUrl(owner, repo, branch), { headers });
+  if (!treeResp.ok) {
+    if (treeResp.status === 404) throw new Error(`Branch not found: ${branch}`);
+    if (treeResp.status === 403) throw new Error(`GitHub API rate limit exceeded`);
+    throw new Error(`GitHub API error: ${treeResp.status}`);
+  }
+  const treeData = await treeResp.json();
+
+  // 4. Discover skills/agents from tree
+  const discovered = discoverFromTree(treeData, pathFilter);
+  if (discovered.length === 0) return [];
+
+  const repoUrl = `https://github.com/${owner}/${repo}`;
+  const results = [];
+
+  // 5. Process each discovered item
+  for (const item of discovered) {
+    try {
+      // 5a. Fetch content via raw GitHub URL
+      const contentUrl = buildContentUrl(owner, repo, branch, item.filePath);
+      const contentResp = await fetchFn(contentUrl, { headers });
+      if (!contentResp.ok) {
+        debugLog('WARN', 'importer', `Failed to fetch ${item.filePath}: ${contentResp.status}`);
+        continue;
+      }
+      const content = await contentResp.text();
+
+      // 5b. Parse frontmatter
+      const { frontmatter, body } = parseFrontmatter(content);
+
+      // Root skill naming: use frontmatter name if present, else repo name for root, else discovered name
+      const rawName = frontmatter.name || (item.name === 'root' ? repo : item.name);
+      const name = rawName.replace(/[^a-zA-Z0-9._-]/g, '_');
+      // Path traversal guard: reject names that would escape managed directory
+      const typeDir = item.type === 'agent' ? 'agents' : 'skills';
+      if (!isPathConfined(join(managedDir, typeDir, name), managedDir)) {
+        debugLog('WARN', 'importer', `Rejected path-traversal name: ${rawName}`);
+        continue;
+      }
+      const description = frontmatter.description || '';
+      const fullText = `${name} ${description} ${body}`;
+
+      // 5c. Extract keywords/intents/domains
+      const { keywords, intentTags, domainTags } = extractKeywords(fullText);
+
+      // 5d. SHA-256 hash for dedup
+      const fileHash = createHash('sha256').update(content).digest('hex');
+      const existing = db.prepare(
+        'SELECT file_hash FROM resources WHERE type = ? AND name = ?'
+      ).get(item.type, name);
+      if (existing && existing.file_hash === fileHash) {
+        debugLog('DEBUG', 'importer', `Skipping ${name} — unchanged`);
+        continue;
+      }
+
+      // 5e. Download to managed directory
+      const destDir = join(managedDir, typeDir, name);
+      mkdirSync(destDir, { recursive: true });
+      const fileName = item.type === 'agent' ? 'AGENT.md' : 'SKILL.md';
+      writeFileSync(join(destDir, fileName), content, 'utf8');
+
+      // 5f. Upsert to registry DB
+      const resourceId = upsertResource(db, {
+        name,
+        type: item.type,
+        status: 'active',
+        source: 'github',
+        repo_url: repoUrl,
+        repo_stars: repoStars,
+        local_path: join(destDir, fileName),
+        file_hash: fileHash,
+        invocation_name: frontmatter['invocation-name'] || frontmatter.invocation_name || '',
+        intent_tags: intentTags,
+        domain_tags: domainTags,
+        action_type: frontmatter.action_type || frontmatter['action-type'] || '',
+        trigger_patterns: frontmatter.trigger_patterns || frontmatter['trigger-patterns'] || '',
+        capability_summary: description,
+        input_type: frontmatter.input_type || frontmatter['input-type'] || '',
+        output_type: frontmatter.output_type || frontmatter['output-type'] || '',
+        prerequisites: frontmatter.prerequisites || '{}',
+        keywords,
+        tech_stack: frontmatter.tech_stack || frontmatter['tech-stack'] || '',
+        use_cases: frontmatter.use_cases || frontmatter['use-cases'] || '',
+        complexity: frontmatter.complexity || 'intermediate',
+        quality_tier: 'community',
+        indexed_at: new Date().toISOString(),
+      });
+
+      // 5g. Update repo_forks and repo_updated_at (not in upsert SQL)
+      db.prepare(
+        'UPDATE resources SET repo_forks = ?, repo_updated_at = ?, quality_tier = ? WHERE id = ?'
+      ).run(repoForks, repoUpdatedAt, 'community', resourceId);
+
+      results.push({ name, type: item.type, id: resourceId });
+      debugLog('INFO', 'importer', `Imported ${item.type}:${name} (id=${resourceId})`);
+    } catch (err) {
+      debugLog('ERROR', 'importer', `Failed to import ${item.name}: ${err.message}`);
+      // Skip individual failures, continue with next
+    }
+  }
+
+  // 6. Rebuild FTS5 index
+  try {
+    db.exec("INSERT INTO resources_fts(resources_fts) VALUES('rebuild')");
+  } catch (err) {
+    debugLog('WARN', 'importer', `FTS rebuild failed: ${err.message}`);
+  }
+
+  // 7. Return imported resources
+  return results;
+}

package/registry.mjs

@@ -15,7 +15,7 @@ const RESOURCES_SCHEMA = `
     type          TEXT NOT NULL CHECK(type IN ('skill','agent')),
     status        TEXT NOT NULL DEFAULT 'active'
                   CHECK(status IN ('active','disabled','error','indexing')),
-    source        TEXT NOT NULL CHECK(source IN ('preinstalled','user')),
+    source        TEXT NOT NULL CHECK(source IN ('preinstalled','user','github')),
     repo_url      TEXT,
     repo_stars    INTEGER DEFAULT 0,
     local_path    TEXT NOT NULL,
@@ -47,7 +47,11 @@ const RESOURCES_SCHEMA = `
     recommendation_mode TEXT DEFAULT 'proactive',
     indexed_at    TEXT,
     created_at    TEXT DEFAULT (datetime('now')),
-    updated_at    TEXT DEFAULT (datetime('now'))
+    updated_at    TEXT DEFAULT (datetime('now')),
+    enrichment_status TEXT DEFAULT NULL,
+    enriched_at INTEGER DEFAULT NULL,
+    repo_updated_at TEXT DEFAULT NULL,
+    repo_forks INTEGER DEFAULT 0
   );
 
   CREATE UNIQUE INDEX IF NOT EXISTS idx_res_type_name
@@ -182,10 +186,43 @@ export function ensureRegistryDb(dbPath) {
     if (!resCols.has('quality_tier')) db.exec("ALTER TABLE resources ADD COLUMN quality_tier TEXT DEFAULT 'community'");
     if (!resCols.has('popularity_score')) db.exec("ALTER TABLE resources ADD COLUMN popularity_score REAL DEFAULT 0");
     if (!resCols.has('personal_score')) db.exec("ALTER TABLE resources ADD COLUMN personal_score REAL DEFAULT 0");
+    if (!resCols.has('enrichment_status')) db.exec("ALTER TABLE resources ADD COLUMN enrichment_status TEXT DEFAULT NULL");
+    if (!resCols.has('enriched_at')) db.exec("ALTER TABLE resources ADD COLUMN enriched_at INTEGER DEFAULT NULL");
+    if (!resCols.has('repo_updated_at')) db.exec("ALTER TABLE resources ADD COLUMN repo_updated_at TEXT DEFAULT NULL");
+    if (!resCols.has('repo_forks')) db.exec("ALTER TABLE resources ADD COLUMN repo_forks INTEGER DEFAULT 0");
     // Auto-set quality_tier for installed preinstalled resources
     db.exec("UPDATE resources SET quality_tier = 'installed' WHERE source = 'preinstalled' AND quality_tier = 'community'");
   } catch (e) { debugCatch(e, 'resources-column-migration'); }
 
+  // Migrate: add 'github' to source CHECK constraint (required for smart import)
+  // Must disable FK checks during table recreation (RENAME triggers FK validation)
+  try {
+    const resSchema = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='resources'`).get();
+    if (resSchema?.sql && !resSchema.sql.includes("'github'")) {
+      db.pragma('foreign_keys = OFF');
+      try {
+        db.transaction(() => {
+          const hasOld = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name='resources_old'`).get();
+          if (hasOld) db.exec(`DROP TABLE resources_old`);
+          // Drop FTS triggers first (reference resources table)
+          db.exec(`DROP TRIGGER IF EXISTS res_fts_insert`);
+          db.exec(`DROP TRIGGER IF EXISTS res_fts_update`);
+          db.exec(`DROP TRIGGER IF EXISTS res_fts_delete`);
+          db.exec(`ALTER TABLE resources RENAME TO resources_old`);
+          db.exec(RESOURCES_SCHEMA);
+          // Copy all existing data
+          const cols = db.prepare("PRAGMA table_info(resources_old)").all().map(c => c.name);
+          const newCols = new Set(db.prepare("PRAGMA table_info(resources)").all().map(c => c.name));
+          const common = cols.filter(c => newCols.has(c)).join(', ');
+          db.exec(`INSERT INTO resources (${common}) SELECT ${common} FROM resources_old`);
+          db.exec(`DROP TABLE resources_old`);
+        })();
+      } finally {
+        db.pragma('foreign_keys = ON');
+      }
+    }
+  } catch (e) { debugCatch(e, 'resources-source-check-migration'); }
+
   // FTS5: create if not exists
   const hasFts = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name='resources_fts'`).get();
   if (!hasFts) {

package/schema.mjs

@@ -13,7 +13,7 @@ export const DB_PATH = join(DB_DIR, 'claude-mem-lite.db');
 export const REGISTRY_DB_PATH = join(DB_DIR, 'resource-registry.db');
 
 // Increment when schema changes (tables, columns, indexes, FTS, migrations)
-export const CURRENT_SCHEMA_VERSION = 19;
+export const CURRENT_SCHEMA_VERSION = 20;
 
 const CORE_SCHEMA = `
   CREATE TABLE IF NOT EXISTS sdk_sessions (
@@ -173,11 +173,11 @@ export function initSchema(db) {
   db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_project ON sdk_sessions(project)`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_obs_not_compressed ON observations(created_at_epoch DESC) WHERE COALESCE(compressed_into, 0) = 0`);
 
-  // FTS5 migration: add lesson_learned column to observations_fts (one-time)
-  // Detect old FTS5 table missing lesson_learned and recreate with full column set
+  // FTS5 migration: recreate observations_fts when columns are missing (one-time)
+  // Detect old FTS5 table missing lesson_learned or search_aliases and recreate with full column set
   try {
     const ftsDdl = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='observations_fts'`).get();
-    if (ftsDdl && !ftsDdl.sql.includes('lesson_learned')) {
+    if (ftsDdl && (!ftsDdl.sql.includes('lesson_learned') || !ftsDdl.sql.includes('search_aliases'))) {
       db.exec(`DROP TRIGGER IF EXISTS observations_ai`);
       db.exec(`DROP TRIGGER IF EXISTS observations_ad`);
       db.exec(`DROP TRIGGER IF EXISTS observations_au`);
@@ -284,7 +284,7 @@ export function initSchema(db) {
           // Strategy 2: substring match for aliases (e.g., "claude-mem-lite" → match project containing "mem")
           // Extract the most distinctive token from the short name for fuzzy matching
           if (!canonical) {
-            const tokens = shortName.split(/[-_.]/).filter(t => t.length >= 3);
+            const tokens = shortName.split(/[-_.]/).filter(t => t.length >= 5);
             for (const token of tokens) {
               canonical = db.prepare(
                 `SELECT project FROM observations WHERE project LIKE ? AND project LIKE '%--_%'

package/scoring-sql.mjs

@@ -18,14 +18,14 @@ export const DEFAULT_DECAY_HALF_LIFE_MS = 14 * 86400000;
 // Single source of truth for FTS5 BM25 weight expressions.
 // Column order must match ensureFTS() calls in schema.mjs.
 
-/** observations_fts BM25 weights: title=10, subtitle=5, narrative=5, text=3, facts=3, concepts=2, lesson_learned=8 */
-export const OBS_BM25 = 'bm25(observations_fts, 10, 5, 5, 3, 3, 2, 8)';
+/** observations_fts BM25 weights: title=10, subtitle=5, narrative=5, text=3, facts=3, concepts=2, lesson_learned=8, search_aliases=5 */
+export const OBS_BM25 = 'bm25(observations_fts, 10, 5, 5, 3, 3, 2, 8, 5)';
 
 /** session_summaries_fts BM25 weights: request=5, investigated=3, learned=3, completed=3, next_steps=2, notes=1, remaining_items=1 */
 export const SESS_BM25 = 'bm25(session_summaries_fts, 5, 3, 3, 3, 2, 1, 1)';
 
 /** FTS5 columns for observations (must match BM25 weight order) */
-export const OBS_FTS_COLUMNS = ['title', 'subtitle', 'narrative', 'text', 'facts', 'concepts', 'lesson_learned'];
+export const OBS_FTS_COLUMNS = ['title', 'subtitle', 'narrative', 'text', 'facts', 'concepts', 'lesson_learned', 'search_aliases'];
 
 /** SQL CASE for type-differentiated recency decay half-lives (milliseconds) */
 export const TYPE_DECAY_CASE = `(

package/scripts/post-tool-use.sh

@@ -8,7 +8,7 @@
 [[ -n "$CLAUDE_MEM_HOOK_RUNNING" ]] && exit 0
 
 # Read stdin (tool hook JSON)
-input=$(cat)
+input=$(head -c 262144)
 
 # Extract tool_name via bash regex — no subprocess
 if [[ "$input" =~ \"tool_name\"[[:space:]]*:[[:space:]]*\"([^\"]+)\" ]]; then

package/scripts/pre-skill-bridge.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// claude-mem-lite: PreToolUse Skill bridge — loads managed skills from registry
+// Intercepts Skill("name") calls for skills in ~/.claude-mem-lite/managed/
+// Lightweight standalone (~30ms): only imports better-sqlite3, fs, path, os
+
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve, sep } from 'path';
+import { homedir } from 'os';
+
+const REGISTRY_DB_PATH = join(homedir(), '.claude-mem-lite', 'resource-registry.db');
+const MANAGED_BASE = join(homedir(), '.claude-mem-lite');
+const MANAGED_MARKER = '/.claude-mem-lite/managed/';
+
+try {
+  // Skip if recursive hook
+  if (process.env.CLAUDE_MEM_HOOK_RUNNING) process.exit(0);
+
+  // Read stdin
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  // Parse event
+  let skillName;
+  try {
+    const event = JSON.parse(input);
+    skillName = event.tool_input?.skill;
+  } catch { process.exit(0); }
+
+  if (!skillName || typeof skillName !== 'string') process.exit(0);
+
+  // Skip if registry DB doesn't exist
+  if (!existsSync(REGISTRY_DB_PATH)) process.exit(0);
+
+  // Open DB readonly
+  const Database = (await import('better-sqlite3')).default;
+  let db;
+  try {
+    db = new Database(REGISTRY_DB_PATH, { readonly: true });
+    db.pragma('busy_timeout = 1000');
+  } catch { process.exit(0); }
+
+  try {
+    // Query: find by name or invocation_name, ONLY if managed path
+    const row = db.prepare(`
+      SELECT name, local_path FROM resources
+      WHERE status = 'active'
+        AND (name = ? OR invocation_name = ?)
+        AND local_path LIKE ?
+      LIMIT 1
+    `).get(skillName, skillName, `%${MANAGED_MARKER}%`);
+
+    if (!row || !row.local_path) process.exit(0);
+
+    // Resolve path: directory skills → SKILL.md (agents always have full .md paths)
+    let skillPath = row.local_path;
+    if (!skillPath.endsWith('.md')) {
+      const candidate = join(skillPath, 'SKILL.md');
+      if (existsSync(candidate)) skillPath = candidate;
+    }
+
+    if (!existsSync(skillPath)) process.exit(0);
+
+    // Path confinement check — prevent LIKE bypass via '../' in local_path
+    const resolvedPath = resolve(skillPath);
+    if (resolvedPath !== MANAGED_BASE && !resolvedPath.startsWith(MANAGED_BASE + sep)) process.exit(0);
+
+    // Read and output
+    const content = readFileSync(skillPath, 'utf8');
+    // Token budget: ~4 chars per token, 4000 token limit = 16000 chars
+    if (content.length > 16000) {
+      const summary = content.slice(0, 800);
+      console.log(`<skill-bridge name="${row.name}" source="managed" truncated="true">\n${summary}\n...\n</skill-bridge>\n\nSkill content truncated. Use mem_use(name="${row.name}") to load full content.`);
+    } else {
+      console.log(`<skill-bridge name="${row.name}" source="managed">\n${content}\n</skill-bridge>\n\nThis skill was loaded from the managed registry. Follow the instructions above.`);
+    }
+  } catch {
+    // Silent failure — never block Skill tool
+  } finally {
+    try { db.close(); } catch {}
+  }
+} catch {
+  // Top-level catch — exit 0 no matter what
+}

package/scripts/prompt-search-utils.mjs

@@ -34,10 +34,25 @@ export const INTENTS = [
 ];
 
 export function detectIntent(text) {
+  // Collect all matching intents (patterns may overlap)
+  const matches = [];
   for (const intent of INTENTS) {
-    if (intent.pattern.test(text)) return intent;
+    if (intent.pattern.test(text)) matches.push(intent);
   }
-  return null;
+  if (matches.length === 0) return null;
+  if (matches.length === 1) return matches[0];
+
+  // Disambiguation: specifically when bugfix and recall both match, use
+  // position-based resolution — the pattern appearing earlier in text wins.
+  // "I remember we fixed..." → recall leads. "fix the bug from before" → bugfix leads.
+  const first = matches[0];
+  const second = matches[1];
+  if (first.type === 'bugfix' && second.useRecent) {
+    const bugPos = text.search(first.pattern);
+    const recallPos = text.search(second.pattern);
+    if (recallPos < bugPos) return second;
+  }
+  return first;
 }
 
 // ─── Result Dedup ───────────────────────────────────────────────────────────
@@ -65,6 +80,36 @@ export function shouldSkipByDedup(newIds, injectedFile) {
   } catch { return false; }
 }
 
+// ─── Registry Skill Name Matching ───────────────────────────────────────────
+
+/**
+ * Check if prompt text contains a known managed skill name.
+ * Returns the matched name or null.
+ * @param {string} text - user prompt
+ * @param {Set<string>} skillNames - set of known managed skill names (lowercase)
+ * @returns {string|null}
+ */
+export function matchRegistrySkillName(text, skillNames) {
+  if (!text || skillNames.size === 0) return null;
+  const lower = text.toLowerCase();
+
+  // Sort names longest-first to match "code-review-expert" before "code-review"
+  const sorted = [...skillNames].sort((a, b) => b.length - a.length);
+
+  for (const name of sorted) {
+    const idx = lower.indexOf(name);
+    if (idx === -1) continue;
+
+    // Check word boundaries: char before and after must be non-alphanumeric (or start/end)
+    const before = idx === 0 ? ' ' : lower[idx - 1];
+    const after = idx + name.length >= lower.length ? ' ' : lower[idx + name.length];
+    if (/[a-z0-9]/.test(before) || /[a-z0-9]/.test(after)) continue;
+
+    return name;
+  }
+  return null;
+}
+
 // ─── File Path Detection ─────────────────────────────────────────────────────
 
 /** Detect file paths in text */