memorix 0.6.5 → 0.7.0

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.7.0] — 2026-02-21
+
+### Added
+- **Memory-Driven Skills Engine** (`memorix_skills` MCP tool):
+  - `list` — Discover all `SKILL.md` files across 7 agent directories
+  - `generate` — Auto-generate project-specific skills from observation patterns (gotchas, decisions, how-it-works)
+  - `inject` — Return full skill content directly to agent context
+  - Intelligent scoring: requires skill-worthy observation types, not just volume
+  - Write to any target agent with `write: true, target: "<agent>"`
+- **Transformers.js Embedding Provider**:
+  - Pure JavaScript fallback (`@huggingface/transformers`) — no native deps required
+  - Provider chain: `fastembed` → `transformers.js` → fulltext-only
+  - Quantized model (`q8`) for small footprint
+- **Dashboard Enhancements**:
+  - Canvas donut chart for observation type distribution
+  - Embedding provider status card (enabled/provider/dimensions)
+  - Search result highlighting with `<mark>` tags
+- **17 new tests** for Skills Engine (list, generate, inject, write, scoring, dedup)
+
+### Changed
+- Scoring algorithm requires at least 1 skill-worthy type (gotcha/decision/how-it-works/problem-solution/trade-off) — pure discovery/what-changed entities won't generate skills
+- Volume bonus reduced from 2×obs to 1×obs (capped at 5) to favor quality over quantity
+- Type diversity bonus increased from 2 to 3 points per unique skill-worthy type
+
+### Fixed
+- 422 tests passing (up from 405), 34 test files, zero regressions
+
 ## [0.5.0] — 2026-02-15
 
 ### Added

package/README.md

@@ -97,6 +97,7 @@ Then use `"command": "memorix"` instead of `"command": "npx"` in your config.
 - **MCP Config Migration** — Detect and migrate MCP server configs (merges — never overwrites)
 - **Rules Sync** — Scan → Deduplicate → Conflict detection → Cross-format generation
 - **Skills & Workflows** — Copy skill folders and workflow files across agents
+- **Memory-Driven Skills** — `memorix_skills` auto-generates project-specific `SKILL.md` from observation patterns (gotchas, decisions, how-it-works)
 - **Apply with Safety** — Backup `.bak` → Atomic write → Auto-rollback on failure
 
 ### 🔒 Project Isolation
@@ -112,8 +113,11 @@ Then use `"command": "memorix"` instead of `"command": "npx"` in your config.
 - **Web Dashboard** — `memorix_dashboard` opens a beautiful web UI at `http://localhost:3210`
 - **Project Switcher** — Dropdown to view any project's data without switching IDEs
 - **Knowledge Graph** — Interactive visualization of entities and relations
+- **Type Distribution Chart** — Canvas donut chart showing observation type breakdown
+- **Embedding Status** — Real-time display of vector search provider status (enabled/provider/dimensions)
 - **Retention Scores** — Exponential decay scoring with immunity status
-- **Observation Management** — Expand/collapse details, search, delete with confirmation, data export
+- **Observation Management** — Expand/collapse details, **search with text highlighting**, delete with confirmation, data export
+- **Batch Cleanup** — Auto-detect and bulk-delete low-quality observations
 - **Light/Dark Theme** — Premium glassmorphism design, bilingual (EN/中文)
 
 ### 🪝 Auto-Memory Hooks
@@ -327,15 +331,26 @@ Files: ["src/auth/jwt.ts", "src/config.ts"]
 
 ## 🔮 Optional: Vector Search
 
-Install `fastembed` for hybrid (BM25 + semantic) search:
+Memorix supports **hybrid search** (BM25 + semantic vectors) with a provider priority chain:
+
+| Priority | Provider | How to Enable | Notes |
+|----------|----------|---------------|-------|
+| 1st | `fastembed` | `npm install -g fastembed` | Fastest, native ONNX bindings |
+| 2nd | `transformers.js` | `npm install -g @huggingface/transformers` | Pure JS/WASM, cross-platform |
+| Fallback | Full-text (BM25) | Always available | Already very effective for code |
 
 ```bash
+# Option A: Native speed (recommended if it installs cleanly)
 npm install -g fastembed
+
+# Option B: Universal compatibility (works everywhere, no native deps)
+npm install -g @huggingface/transformers
 ```
 
-- **Without it** — BM25 full-text search (already very effective for code)
-- **With it** — Queries like "authentication" also match "login flow" via semantic similarity
-- Local ONNX inference, zero API calls, zero privacy risk
+- **Without either** — BM25 full-text search works great out of the box
+- **With any provider** — Queries like "authentication" also match "login flow" via semantic similarity
+- Both run **locally** — zero API calls, zero privacy risk, zero cost
+- The dashboard shows which provider is active in real-time
 
 ---
 
@@ -379,7 +394,8 @@ src/
 ├── memory/                # Graph, observations, retention, entity extraction
 ├── store/                 # Orama search engine + disk persistence
 ├── compact/               # 3-layer Progressive Disclosure engine
-├── embedding/             # Optional fastembed vector provider
+├── embedding/             # Vector providers (fastembed → transformers.js → fallback)
+├── skills/                # Memory-driven project skills engine (list → generate → inject)
 ├── hooks/                 # Auto-memory hooks (normalizer + pattern detector)
 ├── workspace/             # Cross-agent MCP/workflow/skills sync
 ├── rules/                 # Cross-agent rules sync (7 adapters)

package/dist/cli/index.js

@@ -476,7 +476,100 @@ var init_fastembed_provider = __esm({
   }
 });
 
+// src/embedding/transformers-provider.ts
+var transformers_provider_exports = {};
+__export(transformers_provider_exports, {
+  TransformersProvider: () => TransformersProvider
+});
+var cache2, MAX_CACHE_SIZE2, TransformersProvider;
+var init_transformers_provider = __esm({
+  "src/embedding/transformers-provider.ts"() {
+    "use strict";
+    init_esm_shims();
+    cache2 = /* @__PURE__ */ new Map();
+    MAX_CACHE_SIZE2 = 5e3;
+    TransformersProvider = class _TransformersProvider {
+      name = "transformers-minilm";
+      dimensions = 384;
+      extractor;
+      // Pipeline instance
+      constructor(extractor) {
+        this.extractor = extractor;
+      }
+      /**
+       * Initialize the Transformers.js provider.
+       * Downloads model on first use (~22MB quantized), cached locally after.
+       */
+      static async create() {
+        const { pipeline } = await import("@huggingface/transformers");
+        const extractor = await pipeline(
+          "feature-extraction",
+          "Xenova/all-MiniLM-L6-v2",
+          { dtype: "q8" }
+          // Quantized for small footprint
+        );
+        return new _TransformersProvider(extractor);
+      }
+      async embed(text) {
+        const cached = cache2.get(text);
+        if (cached) return cached;
+        const output = await this.extractor(text, {
+          pooling: "mean",
+          normalize: true
+        });
+        const result = Array.from(output.tolist()[0]);
+        if (result.length !== this.dimensions) {
+          throw new Error(`Expected ${this.dimensions}d embedding, got ${result.length}d`);
+        }
+        this.cacheSet(text, result);
+        return result;
+      }
+      async embedBatch(texts) {
+        const results = new Array(texts.length);
+        const uncachedIndices = [];
+        const uncachedTexts = [];
+        for (let i = 0; i < texts.length; i++) {
+          const cached = cache2.get(texts[i]);
+          if (cached) {
+            results[i] = cached;
+          } else {
+            uncachedIndices.push(i);
+            uncachedTexts.push(texts[i]);
+          }
+        }
+        if (uncachedTexts.length > 0) {
+          const output = await this.extractor(uncachedTexts, {
+            pooling: "mean",
+            normalize: true
+          });
+          const allVecs = output.tolist();
+          for (let i = 0; i < allVecs.length; i++) {
+            const vec = Array.from(allVecs[i]);
+            const originalIdx = uncachedIndices[i];
+            results[originalIdx] = vec;
+            this.cacheSet(uncachedTexts[i], vec);
+          }
+        }
+        return results;
+      }
+      cacheSet(key, value) {
+        if (cache2.size >= MAX_CACHE_SIZE2) {
+          const firstKey = cache2.keys().next().value;
+          if (firstKey !== void 0) cache2.delete(firstKey);
+        }
+        cache2.set(key, value);
+      }
+    };
+  }
+});
+
 // src/embedding/provider.ts
+var provider_exports = {};
+__export(provider_exports, {
+  getEmbeddingProvider: () => getEmbeddingProvider,
+  isVectorSearchAvailable: () => isVectorSearchAvailable,
+  resetProvider: () => resetProvider
+});
 async function getEmbeddingProvider() {
   if (initialized) return provider;
   initialized = true;
@@ -487,9 +580,24 @@ async function getEmbeddingProvider() {
     return provider;
   } catch {
   }
+  try {
+    const { TransformersProvider: TransformersProvider2 } = await Promise.resolve().then(() => (init_transformers_provider(), transformers_provider_exports));
+    provider = await TransformersProvider2.create();
+    console.error(`[memorix] Embedding provider: ${provider.name} (${provider.dimensions}d)`);
+    return provider;
+  } catch {
+  }
   console.error("[memorix] No embedding provider available \u2014 using fulltext search only");
   return null;
 }
+async function isVectorSearchAvailable() {
+  const p3 = await getEmbeddingProvider();
+  return p3 !== null;
+}
+function resetProvider() {
+  provider = null;
+  initialized = false;
+}
 var provider, initialized;
 var init_provider = __esm({
   "src/embedding/provider.ts"() {
@@ -3749,6 +3857,320 @@ var init_retention = __esm({
   }
 });
 
+// src/skills/engine.ts
+var engine_exports = {};
+__export(engine_exports, {
+  SkillsEngine: () => SkillsEngine
+});
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir10 } from "os";
+var SKILLS_DIRS, SKILL_WORTHY_TYPES, MIN_OBS_FOR_SKILL, MIN_SCORE_FOR_SKILL, SkillsEngine;
+var init_engine3 = __esm({
+  "src/skills/engine.ts"() {
+    "use strict";
+    init_esm_shims();
+    SKILLS_DIRS = {
+      codex: [".codex/skills", ".agents/skills"],
+      cursor: [".cursor/skills", ".cursor/skills-cursor"],
+      windsurf: [".windsurf/skills"],
+      "claude-code": [".claude/skills"],
+      copilot: [".github/skills", ".copilot/skills"],
+      antigravity: [".agent/skills", ".gemini/skills", ".gemini/antigravity/skills"],
+      kiro: [".kiro/skills"]
+    };
+    SKILL_WORTHY_TYPES = /* @__PURE__ */ new Set([
+      "gotcha",
+      "decision",
+      "how-it-works",
+      "problem-solution",
+      "trade-off"
+    ]);
+    MIN_OBS_FOR_SKILL = 3;
+    MIN_SCORE_FOR_SKILL = 5;
+    SkillsEngine = class {
+      constructor(projectRoot, options) {
+        this.projectRoot = projectRoot;
+        this.skipGlobal = options?.skipGlobal ?? false;
+      }
+      skipGlobal;
+      // ============================================================
+      // List: Discover all available skills
+      // ============================================================
+      /**
+       * List all available skills from all agents + generated suggestions.
+       */
+      listSkills() {
+        const skills = [];
+        const seen = /* @__PURE__ */ new Set();
+        const home = homedir10();
+        for (const [agent, dirs] of Object.entries(SKILLS_DIRS)) {
+          for (const dir of dirs) {
+            const paths = [join11(this.projectRoot, dir)];
+            if (!this.skipGlobal) {
+              paths.push(join11(home, dir));
+            }
+            for (const skillsRoot of paths) {
+              if (!existsSync5(skillsRoot)) continue;
+              try {
+                const entries = readdirSync2(skillsRoot, { withFileTypes: true });
+                for (const entry of entries) {
+                  if (!entry.isDirectory()) continue;
+                  const name = entry.name;
+                  if (seen.has(name)) continue;
+                  const skillMd = join11(skillsRoot, name, "SKILL.md");
+                  if (!existsSync5(skillMd)) continue;
+                  try {
+                    const content = readFileSync3(skillMd, "utf-8");
+                    const description = this.parseDescription(content);
+                    skills.push({
+                      name,
+                      description,
+                      sourcePath: join11(skillsRoot, name),
+                      sourceAgent: agent,
+                      content,
+                      generated: false
+                    });
+                    seen.add(name);
+                  } catch {
+                  }
+                }
+              } catch {
+              }
+            }
+          }
+        }
+        return skills;
+      }
+      // ============================================================
+      // Generate: Create skills from observation patterns
+      // ============================================================
+      /**
+       * Analyze observations and generate SKILL.md content for entities with
+       * rich knowledge accumulation.
+       */
+      generateFromObservations(observations2) {
+        const clusters = this.clusterByEntity(observations2);
+        for (const cluster of clusters.values()) {
+          cluster.score = this.scoreCluster(cluster);
+        }
+        const results = [];
+        const sortedClusters = [...clusters.values()].filter((c) => c.score >= MIN_SCORE_FOR_SKILL).sort((a, b) => b.score - a.score).slice(0, 10);
+        for (const cluster of sortedClusters) {
+          const skill = this.clusterToSkill(cluster);
+          if (skill) results.push(skill);
+        }
+        return results;
+      }
+      /**
+       * Write a generated skill to the target agent's skills directory.
+       */
+      writeSkill(skill, target) {
+        const dirs = SKILLS_DIRS[target];
+        if (!dirs || dirs.length === 0) return null;
+        const targetDir = join11(this.projectRoot, dirs[0], skill.name);
+        try {
+          mkdirSync3(targetDir, { recursive: true });
+          writeFileSync2(join11(targetDir, "SKILL.md"), skill.content, "utf-8");
+          return join11(dirs[0], skill.name, "SKILL.md");
+        } catch {
+          return null;
+        }
+      }
+      // ============================================================
+      // Inject: Return skill content for direct agent consumption
+      // ============================================================
+      /**
+       * Get full content of a skill by name (for direct injection).
+       */
+      injectSkill(name) {
+        const all = this.listSkills();
+        return all.find((s) => s.name.toLowerCase() === name.toLowerCase()) || null;
+      }
+      // ============================================================
+      // Internal helpers
+      // ============================================================
+      parseDescription(content) {
+        const match = content.match(/^---[\s\S]*?description:\s*["']?(.+?)["']?\s*$/m);
+        return match ? match[1] : "";
+      }
+      clusterByEntity(observations2) {
+        const clusters = /* @__PURE__ */ new Map();
+        for (const obs of observations2) {
+          const entity = obs.entityName || "unknown";
+          let cluster = clusters.get(entity);
+          if (!cluster) {
+            cluster = { entity, observations: [], types: /* @__PURE__ */ new Set(), score: 0 };
+            clusters.set(entity, cluster);
+          }
+          cluster.observations.push(obs);
+          cluster.types.add(obs.type);
+        }
+        return clusters;
+      }
+      scoreCluster(cluster) {
+        let score = 0;
+        const obs = cluster.observations;
+        if (obs.length < MIN_OBS_FOR_SKILL) return 0;
+        let hasSkillWorthyType = false;
+        for (const type of cluster.types) {
+          if (SKILL_WORTHY_TYPES.has(type)) {
+            hasSkillWorthyType = true;
+            break;
+          }
+        }
+        if (!hasSkillWorthyType) return 0;
+        score += Math.min(obs.length, 5);
+        for (const type of cluster.types) {
+          if (SKILL_WORTHY_TYPES.has(type)) score += 3;
+        }
+        const gotchas = obs.filter((o) => o.type === "gotcha").length;
+        score += gotchas * 3;
+        const decisions = obs.filter((o) => o.type === "decision").length;
+        score += decisions * 2;
+        const totalFacts = obs.reduce((sum, o) => sum + (o.facts?.length || 0), 0);
+        score += Math.min(totalFacts, 5);
+        const totalFiles = new Set(obs.flatMap((o) => o.filesModified || [])).size;
+        score += Math.min(totalFiles, 5);
+        return score;
+      }
+      clusterToSkill(cluster) {
+        const { entity, observations: observations2 } = cluster;
+        const safeName = entity.replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+        const gotchas = observations2.filter((o) => o.type === "gotcha");
+        const decisions = observations2.filter((o) => o.type === "decision");
+        const howItWorks = observations2.filter((o) => o.type === "how-it-works");
+        const problems = observations2.filter((o) => o.type === "problem-solution");
+        const tradeoffs = observations2.filter((o) => o.type === "trade-off");
+        const others = observations2.filter(
+          (o) => !["gotcha", "decision", "how-it-works", "problem-solution", "trade-off"].includes(o.type)
+        );
+        const allFacts = [...new Set(observations2.flatMap((o) => o.facts || []))];
+        const allConcepts = [...new Set(observations2.flatMap((o) => o.concepts || []))];
+        const allFiles = [...new Set(observations2.flatMap((o) => o.filesModified || []))];
+        const lines = [];
+        const description = this.generateDescription(cluster);
+        lines.push("---");
+        lines.push(`description: ${description}`);
+        lines.push("---");
+        lines.push("");
+        lines.push(`# ${entity}`);
+        lines.push("");
+        lines.push(`> Auto-generated from ${observations2.length} project observations by Memorix.`);
+        lines.push("> Adapt to your actual project context before relying on this skill.");
+        lines.push("");
+        if (allFiles.length > 0) {
+          lines.push("## Key Files");
+          lines.push("");
+          for (const f of allFiles.slice(0, 15)) {
+            lines.push(`- \`${f}\``);
+          }
+          lines.push("");
+        }
+        if (gotchas.length > 0) {
+          lines.push("## \u26A0\uFE0F Critical Gotchas");
+          lines.push("");
+          for (const g of gotchas) {
+            lines.push(`### ${g.title}`);
+            if (g.narrative) lines.push("", g.narrative);
+            if (g.facts && g.facts.length > 0) {
+              lines.push("", ...g.facts.map((f) => `- ${f}`));
+            }
+            lines.push("");
+          }
+        }
+        if (decisions.length > 0) {
+          lines.push("## \u{1F3D7}\uFE0F Architecture Decisions");
+          lines.push("");
+          for (const d of decisions) {
+            lines.push(`### ${d.title}`);
+            if (d.narrative) lines.push("", d.narrative);
+            if (d.facts && d.facts.length > 0) {
+              lines.push("", ...d.facts.map((f) => `- ${f}`));
+            }
+            lines.push("");
+          }
+        }
+        if (howItWorks.length > 0) {
+          lines.push("## \u{1F4D6} How It Works");
+          lines.push("");
+          for (const h of howItWorks) {
+            lines.push(`### ${h.title}`);
+            if (h.narrative) lines.push("", h.narrative);
+            lines.push("");
+          }
+        }
+        if (problems.length > 0) {
+          lines.push("## \u{1F527} Common Problems & Solutions");
+          lines.push("");
+          for (const p3 of problems) {
+            lines.push(`### ${p3.title}`);
+            if (p3.narrative) lines.push("", p3.narrative);
+            if (p3.facts && p3.facts.length > 0) {
+              lines.push("", ...p3.facts.map((f) => `- ${f}`));
+            }
+            lines.push("");
+          }
+        }
+        if (tradeoffs.length > 0) {
+          lines.push("## \u2696\uFE0F Trade-offs");
+          lines.push("");
+          for (const t of tradeoffs) {
+            lines.push(`### ${t.title}`);
+            if (t.narrative) lines.push("", t.narrative);
+            lines.push("");
+          }
+        }
+        if (others.length > 0) {
+          lines.push("## \u{1F4DD} Notes");
+          lines.push("");
+          for (const o of others.slice(0, 5)) {
+            lines.push(`- **${o.title}**: ${o.narrative?.split("\n")[0] || ""}`);
+          }
+          lines.push("");
+        }
+        if (allConcepts.length > 0) {
+          lines.push("## \u{1F3F7}\uFE0F Related Concepts");
+          lines.push("");
+          lines.push(allConcepts.map((c) => `\`${c}\``).join(", "));
+          lines.push("");
+        }
+        if (allFacts.length > 0) {
+          lines.push("## \u{1F4CC} Quick Facts");
+          lines.push("");
+          for (const f of allFacts.slice(0, 15)) {
+            lines.push(`- ${f}`);
+          }
+          lines.push("");
+        }
+        const content = lines.join("\n");
+        return {
+          name: safeName,
+          description,
+          sourcePath: "",
+          sourceAgent: "codex",
+          // generated skills follow SKILL.md standard
+          content,
+          generated: true
+        };
+      }
+      generateDescription(cluster) {
+        const parts = [];
+        const typeCounts = {};
+        for (const obs of cluster.observations) {
+          typeCounts[obs.type] = (typeCounts[obs.type] || 0) + 1;
+        }
+        if (typeCounts["gotcha"]) parts.push(`${typeCounts["gotcha"]} gotcha(s)`);
+        if (typeCounts["decision"]) parts.push(`${typeCounts["decision"]} decision(s)`);
+        if (typeCounts["how-it-works"]) parts.push(`${typeCounts["how-it-works"]} explanation(s)`);
+        if (typeCounts["problem-solution"]) parts.push(`${typeCounts["problem-solution"]} fix(es)`);
+        const summary = parts.length > 0 ? parts.join(", ") : `${cluster.observations.length} observations`;
+        return `Project patterns for ${cluster.entity}: ${summary}`;
+      }
+    };
+  }
+});
+
 // src/dashboard/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -3836,13 +4258,26 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir) {
           typeCounts[t] = (typeCounts[t] || 0) + 1;
         }
         const sorted = [...observations2].sort((a, b) => (b.id || 0) - (a.id || 0)).slice(0, 10);
+        let embeddingStatus = { enabled: false, provider: "", dimensions: 0 };
+        try {
+          const { isEmbeddingEnabled: isEmbeddingEnabled2 } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
+          const { getEmbeddingProvider: getEmbeddingProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
+          const provider2 = await getEmbeddingProvider2();
+          embeddingStatus = {
+            enabled: isEmbeddingEnabled2(),
+            provider: provider2?.name || "",
+            dimensions: provider2?.dimensions || 0
+          };
+        } catch {
+        }
         sendJson(res, {
           entities: graph.entities.length,
           relations: graph.relations.length,
           observations: observations2.length,
           nextId: nextId2,
           typeCounts,
-          recentObservations: sorted
+          recentObservations: sorted,
+          embedding: embeddingStatus
         });
         break;
       }
@@ -4643,6 +5078,114 @@ Entity: ${entityName} | Type: ${type} | Project: ${project.id}${enrichment}`
       };
     }
   );
+  server.registerTool(
+    "memorix_skills",
+    {
+      title: "Project Skills",
+      description: `Memory-driven project skills. Action "list": show all available skills from all agents. Action "generate": auto-generate project-specific skills from observation patterns (gotchas, decisions, how-it-works). Action "inject": return a specific skill's full content for direct use. Generated skills follow the SKILL.md standard and can be synced across agents.`,
+      inputSchema: {
+        action: z.enum(["list", "generate", "inject"]).describe('Action: "list" to discover skills, "generate" to create from memory, "inject" to get skill content'),
+        name: z.string().optional().describe('Skill name (required for "inject")'),
+        target: z.enum(AGENT_TARGETS).optional().describe('Target agent to write generated skills to (optional for "generate")'),
+        write: z.boolean().optional().describe("Whether to write generated skills to disk (default: false, preview only)")
+      }
+    },
+    async ({ action, name, target, write }) => {
+      const { SkillsEngine: SkillsEngine2 } = await Promise.resolve().then(() => (init_engine3(), engine_exports));
+      const engine = new SkillsEngine2(project.rootPath);
+      if (action === "list") {
+        const skills = engine.listSkills();
+        if (skills.length === 0) {
+          return {
+            content: [{ type: "text", text: 'No skills found in any agent directory.\n\nSkills are discovered from:\n- `.cursor/skills/*/SKILL.md`\n- `.agents/skills/*/SKILL.md`\n- `.agent/skills/*/SKILL.md`\n- `.windsurf/skills/*/SKILL.md`\n- etc.\n\nUse action "generate" to auto-create skills from your project observations.' }]
+          };
+        }
+        const lines2 = [
+          `## Available Skills (${skills.length})`,
+          ""
+        ];
+        for (const sk of skills) {
+          lines2.push(`- **${sk.name}** (${sk.sourceAgent}): ${sk.description || "(no description)"}`);
+        }
+        lines2.push("", '> Use `action: "inject", name: "<skill-name>"` to get full skill content.');
+        return {
+          content: [{ type: "text", text: lines2.join("\n") }]
+        };
+      }
+      if (action === "inject") {
+        if (!name) {
+          return {
+            content: [{ type: "text", text: 'Error: `name` is required for inject action. Use `action: "list"` first to see available skills.' }],
+            isError: true
+          };
+        }
+        const skill = engine.injectSkill(name);
+        if (!skill) {
+          return {
+            content: [{ type: "text", text: `Skill "${name}" not found. Use \`action: "list"\` to see available skills.` }],
+            isError: true
+          };
+        }
+        return {
+          content: [{ type: "text", text: `## Skill: ${skill.name}
+**Source**: ${skill.sourceAgent}
+**Path**: ${skill.sourcePath}
+
+---
+
+${skill.content}` }]
+        };
+      }
+      const { loadObservationsJson: loadObservationsJson2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
+      const allObs = await loadObservationsJson2(projectDir2);
+      const obsData = allObs.map((o) => ({
+        id: o.id || 0,
+        entityName: o.entityName || "unknown",
+        type: o.type || "discovery",
+        title: o.title || "",
+        narrative: o.narrative || "",
+        facts: o.facts,
+        concepts: o.concepts,
+        filesModified: o.filesModified,
+        createdAt: o.createdAt
+      }));
+      const generated = engine.generateFromObservations(obsData);
+      if (generated.length === 0) {
+        return {
+          content: [{ type: "text", text: "No skill-worthy patterns found yet.\n\nSkills are auto-generated when entities accumulate enough observations (3+), especially gotchas, decisions, and how-it-works notes.\n\nKeep using memorix_store to build up project knowledge!" }]
+        };
+      }
+      const lines = [
+        `## Generated Skills (${generated.length})`,
+        "",
+        "Based on observation patterns in your project memory:",
+        ""
+      ];
+      for (const sk of generated) {
+        lines.push(`### ${sk.name}`);
+        lines.push(`- **Description**: ${sk.description}`);
+        lines.push(`- **Observations**: ${sk.content.split("\n").length} lines of knowledge`);
+        if (write && target) {
+          const path8 = engine.writeSkill(sk, target);
+          if (path8) {
+            lines.push(`- \u2705 **Written**: \`${path8}\``);
+          } else {
+            lines.push(`- \u274C Failed to write`);
+          }
+        }
+        lines.push("");
+      }
+      if (!write) {
+        lines.push('> Preview only. Add `write: true, target: "<agent>"` to save skills to disk.');
+      }
+      if (generated.length > 0) {
+        lines.push("", "---", "### Preview: " + generated[0].name, "", "```markdown", generated[0].content, "```");
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
   let dashboardRunning = false;
   server.registerTool(
     "memorix_dashboard",