@cognistore/mcp-server 1.0.9 → 1.0.14

package/dist/index.js

@@ -44,8 +44,8 @@ var TaskPriority;
 })(TaskPriority || (TaskPriority = {}));
 
 // ../../packages/shared/dist/constants/defaults.js
-var DEFAULT_EMBEDDING_MODEL = "all-minilm";
-var DEFAULT_EMBEDDING_DIMENSIONS = 384;
+var DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
+var DEFAULT_EMBEDDING_DIMENSIONS = 256;
 var DEFAULT_SIMILARITY_THRESHOLD = 0.3;
 var DEFAULT_SEARCH_LIMIT = 10;
 var DEFAULT_OLLAMA_HOST = "http://localhost:11434";
@@ -58,12 +58,13 @@ var knowledgeTypeSchema = z.nativeEnum(KnowledgeType);
 var knowledgeStatusSchema = z.nativeEnum(KnowledgeStatus);
 var taskStatusSchema = z.nativeEnum(TaskStatus);
 var taskPrioritySchema = z.nativeEnum(TaskPriority);
+var scopeSchema = z.string().regex(/^(global|workspace:[a-zA-Z0-9._-]+)$/, 'Scope must be "global" or "workspace:<project-name>" (alphanumeric, dots, hyphens, underscores)');
 var createKnowledgeSchema = z.object({
   title: z.string().min(1, "Title is required"),
   content: z.string().min(1, "Content is required"),
   tags: z.array(z.string().min(1)).min(1, "At least one tag is required"),
   type: knowledgeTypeSchema,
-  scope: z.string().min(1, "Scope is required"),
+  scope: scopeSchema,
   source: z.string().min(1, "Source is required"),
   confidenceScore: z.number().min(0).max(1).optional().default(1),
   expiresAt: z.date().nullable().optional().default(null),
@@ -75,7 +76,7 @@ var updateKnowledgeSchema = z.object({
   content: z.string().min(1).optional(),
   tags: z.array(z.string().min(1)).min(1).optional(),
   type: knowledgeTypeSchema.optional(),
-  scope: z.string().min(1).optional(),
+  scope: scopeSchema.optional(),
   source: z.string().min(1).optional(),
   confidenceScore: z.number().min(0).max(1).optional(),
   expiresAt: z.date().nullable().optional(),
@@ -85,7 +86,7 @@ var updateKnowledgeSchema = z.object({
 var searchOptionsSchema = z.object({
   tags: z.array(z.string()).optional(),
   type: knowledgeTypeSchema.optional(),
-  scope: z.string().optional(),
+  scope: scopeSchema.optional(),
   limit: z.number().int().min(1).max(100).optional().default(DEFAULT_SEARCH_LIMIT),
   threshold: z.number().min(0).max(1).optional().default(DEFAULT_SIMILARITY_THRESHOLD)
 });
@@ -93,15 +94,19 @@ var createPlanSchema = z.object({
   title: z.string().min(1, "Title is required"),
   content: z.string().min(1, "Content is required"),
   tags: z.array(z.string().min(1)).min(1, "At least one tag is required"),
-  scope: z.string().min(1, "Scope is required"),
+  scope: scopeSchema,
   source: z.string().min(1, "Source is required"),
-  status: knowledgeStatusSchema.optional().default(KnowledgeStatus.DRAFT)
+  status: knowledgeStatusSchema.optional().default(KnowledgeStatus.DRAFT),
+  tasks: z.array(z.object({
+    description: z.string().min(1),
+    priority: z.enum(["low", "medium", "high"]).optional()
+  })).optional()
 });
 var updatePlanSchema = z.object({
   title: z.string().min(1).optional(),
   content: z.string().min(1).optional(),
   tags: z.array(z.string().min(1)).min(1).optional(),
-  scope: z.string().min(1).optional(),
+  scope: scopeSchema.optional(),
   status: knowledgeStatusSchema.optional(),
   source: z.string().min(1).optional()
 });
@@ -126,11 +131,15 @@ var schema_exports = {};
 __export(schema_exports, {
   createEmbeddingsTable: () => createEmbeddingsTable,
   deleteEmbedding: () => deleteEmbedding,
+  deletePlanEmbedding: () => deletePlanEmbedding,
   insertEmbedding: () => insertEmbedding,
+  insertPlanEmbedding: () => insertPlanEmbedding,
   knowledgeEntries: () => knowledgeEntries,
   knowledgeTypeEnum: () => knowledgeTypeEnum,
   searchKnn: () => searchKnn,
-  updateEmbedding: () => updateEmbedding
+  searchPlansKnn: () => searchPlansKnn,
+  updateEmbedding: () => updateEmbedding,
+  updatePlanEmbedding: () => updatePlanEmbedding
 });
 
 // ../../packages/core/dist/db/schema/knowledge.js
@@ -158,7 +167,7 @@ var knowledgeEntries = sqliteTable("knowledge_entries", {
 
 // ../../packages/core/dist/db/schema/sqlite-vec.js
 var VIRTUAL_TABLE_NAME = "knowledge_embeddings";
-function createEmbeddingsTable(sqlite, dimensions = 384) {
+function createEmbeddingsTable(sqlite, dimensions = DEFAULT_EMBEDDING_DIMENSIONS) {
   sqlite.exec(`
     CREATE VIRTUAL TABLE IF NOT EXISTS ${VIRTUAL_TABLE_NAME} USING vec0(
       id TEXT PRIMARY KEY,
@@ -187,6 +196,25 @@ function searchKnn(sqlite, queryEmbedding, k) {
   `);
   return stmt.all(Buffer.from(new Float32Array(queryEmbedding).buffer), k);
 }
+var PLANS_TABLE_NAME = "plans_embeddings";
+function insertPlanEmbedding(sqlite, id, embedding) {
+  sqlite.prepare(`INSERT INTO ${PLANS_TABLE_NAME}(id, embedding) VALUES (?, ?)`).run(id, Buffer.from(new Float32Array(embedding).buffer));
+}
+function updatePlanEmbedding(sqlite, id, embedding) {
+  sqlite.prepare(`UPDATE ${PLANS_TABLE_NAME} SET embedding = ? WHERE id = ?`).run(Buffer.from(new Float32Array(embedding).buffer), id);
+}
+function deletePlanEmbedding(sqlite, id) {
+  sqlite.prepare(`DELETE FROM ${PLANS_TABLE_NAME} WHERE id = ?`).run(id);
+}
+function searchPlansKnn(sqlite, queryEmbedding, k) {
+  const stmt = sqlite.prepare(`
+    SELECT id, distance
+    FROM ${PLANS_TABLE_NAME}
+    WHERE embedding MATCH ?
+      AND k = ?
+  `);
+  return stmt.all(Buffer.from(new Float32Array(queryEmbedding).buffer), k);
+}
 
 // ../../packages/core/dist/db/migrate.js
 import { readdirSync, readFileSync, existsSync } from "fs";
@@ -275,7 +303,7 @@ function runMigrations(sqlite, migrationsDir) {
     if (tableExists) {
       sqlite.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run("0.8.0", (/* @__PURE__ */ new Date()).toISOString());
       applied.add("0.8.0");
-      console.log("Migration: bootstrapped existing DB as v0.8.0");
+      console.error("Migration: bootstrapped existing DB as v0.8.0");
     }
   }
   let migrations;
@@ -287,7 +315,7 @@ function runMigrations(sqlite, migrationsDir) {
     }));
   } else {
     migrations = Object.entries(EMBEDDED_MIGRATIONS).map(([version, sql2]) => ({ version, sql: sql2 })).sort((a, b) => compareSemver(a.version, b.version));
-    console.log("Migration: using embedded migrations (bundled mode)");
+    console.error("Migration: using embedded migrations (bundled mode)");
   }
   for (const { version, sql: sql2 } of migrations) {
     if (applied.has(version))
@@ -306,7 +334,7 @@ function runMigrations(sqlite, migrationsDir) {
       }
     }
     sqlite.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(version, (/* @__PURE__ */ new Date()).toISOString());
-    console.log(`Migration: ${version} applied`);
+    console.error(`Migration: ${version} applied`);
   }
 }
 function runSeeds(sqlite, seedsDir, isFreshInstall) {
@@ -319,7 +347,7 @@ function runSeeds(sqlite, seedsDir, isFreshInstall) {
     const sqlPath = resolve(seedsDir, file);
     const sqlContent = readFileSync(sqlPath, "utf-8");
     sqlite.exec(sqlContent);
-    console.log(`Seed: ${file} applied`);
+    console.error(`Seed: ${file} applied`);
   }
 }
 function compareSemver(a, b) {
@@ -359,17 +387,18 @@ function createDbClient(dbPath) {
   const seedsDir = resolve2(__dirname, "seeds");
   runMigrations(sqlite, migrationsDir);
   runSeeds(sqlite, seedsDir, isFreshInstall);
-  createEmbeddingsTable(sqlite);
-  createPlansEmbeddingsTable(sqlite);
+  const dims = Number(process.env.EMBEDDING_DIMENSIONS) || DEFAULT_EMBEDDING_DIMENSIONS;
+  createEmbeddingsTable(sqlite, dims);
+  createPlansEmbeddingsTable(sqlite, dims);
   const db = drizzle(sqlite, { schema: schema_exports });
   return { db, sqlite };
 }
-function createPlansEmbeddingsTable(sqlite) {
+function createPlansEmbeddingsTable(sqlite, dimensions = DEFAULT_EMBEDDING_DIMENSIONS) {
   try {
     sqlite.exec(`
       CREATE VIRTUAL TABLE IF NOT EXISTS plans_embeddings USING vec0(
         id TEXT PRIMARY KEY,
-        embedding float[384] distance_metric=cosine
+        embedding float[${dimensions}] distance_metric=cosine
       );
     `);
   } catch {
@@ -525,7 +554,7 @@ var KnowledgeRepository = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     this.sqlite.prepare("INSERT INTO plans (id, title, content, tags, scope, status, source, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(id, input.title, input.content, JSON.stringify(input.tags), input.scope, input.status ?? "draft", input.source, now, now);
     try {
-      this.sqlite.prepare("INSERT INTO plans_embeddings (id, embedding) VALUES (?, ?)").run(id, new Float32Array(input.embedding).buffer);
+      insertPlanEmbedding(this.sqlite, id, input.embedding);
     } catch {
     }
     return this.getPlanById(id);
@@ -554,7 +583,7 @@ var KnowledgeRepository = class {
   deletePlan(id) {
     const result = this.sqlite.prepare("DELETE FROM plans WHERE id = ?").run(id);
     try {
-      this.sqlite.prepare("DELETE FROM plans_embeddings WHERE id = ?").run(id);
+      deletePlanEmbedding(this.sqlite, id);
     } catch {
     }
     return result.changes > 0;
@@ -562,11 +591,62 @@ var KnowledgeRepository = class {
   listAllPlans() {
     return this.sqlite.prepare("SELECT * FROM plans ORDER BY created_at DESC").all();
   }
-  listPlans(limit = 20, status) {
+  listPlans(limit = 20, status, scope) {
+    const conditions = [];
+    const params = [];
     if (status) {
-      return this.sqlite.prepare("SELECT * FROM plans WHERE status = ? ORDER BY created_at DESC LIMIT ?").all(status, limit);
+      conditions.push("status = ?");
+      params.push(status);
+    }
+    if (scope) {
+      conditions.push("scope = ?");
+      params.push(scope);
     }
-    return this.sqlite.prepare("SELECT * FROM plans ORDER BY created_at DESC LIMIT ?").all(limit);
+    const where = conditions.length ? "WHERE " + conditions.join(" AND ") : "";
+    params.push(limit);
+    return this.sqlite.prepare(`SELECT * FROM plans ${where} ORDER BY created_at DESC LIMIT ?`).all(...params);
+  }
+  findSimilarActivePlans(embedding, scope, threshold = 0.5) {
+    try {
+      const candidates = this.sqlite.prepare("SELECT id FROM plans WHERE scope = ? AND status IN ('draft', 'active')").all(scope);
+      if (!candidates.length)
+        return [];
+      const ids = candidates.map((c) => c.id);
+      const placeholders = ids.map(() => "?").join(",");
+      const rows = this.sqlite.prepare(`SELECT id, embedding FROM plans_embeddings WHERE id IN (${placeholders})`).all(...ids);
+      if (!rows.length)
+        return [];
+      const queryVec = new Float32Array(embedding);
+      return rows.map((row) => {
+        const vec = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+        const sim = cosineSimilarity(queryVec, vec);
+        return { id: row.id, similarity: sim };
+      }).filter((r) => r.similarity >= threshold).sort((a, b) => b.similarity - a.similarity).map((r) => ({
+        plan: this.sqlite.prepare("SELECT * FROM plans WHERE id = ?").get(r.id),
+        similarity: r.similarity
+      }));
+    } catch {
+      return [];
+    }
+  }
+  archiveStaleDrafts(maxAgeHours = 24) {
+    const cutoff = new Date(Date.now() - maxAgeHours * 60 * 60 * 1e3).toISOString();
+    return this.sqlite.prepare("UPDATE plans SET status = 'archived', updated_at = ? WHERE status = 'draft' AND updated_at < ?").run((/* @__PURE__ */ new Date()).toISOString(), cutoff).changes;
+  }
+  deletePlanTasks(planId) {
+    return this.sqlite.prepare("DELETE FROM plan_tasks WHERE plan_id = ?").run(planId).changes;
+  }
+  updatePlanEmbeddingById(id, embedding) {
+    try {
+      updatePlanEmbedding(this.sqlite, id, embedding);
+    } catch {
+    }
+  }
+  insertEmbeddingById(id, embedding) {
+    insertEmbedding(this.sqlite, id, embedding);
+  }
+  insertPlanEmbeddingById(id, embedding) {
+    insertPlanEmbedding(this.sqlite, id, embedding);
   }
   // ─── Plan Relations ─────────────────────────────────────────
   addPlanRelation(planId, knowledgeId, relationType) {
@@ -659,6 +739,17 @@ var KnowledgeRepository = class {
   logOperation(operation) {
     this.sqlite.prepare("INSERT INTO operations_log (operation, created_at) VALUES (?, ?)").run(operation, (/* @__PURE__ */ new Date()).toISOString());
   }
+  logOperationBatch(operation, count) {
+    if (count <= 0)
+      return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = this.sqlite.prepare("INSERT INTO operations_log (operation, created_at) VALUES (?, ?)");
+    const insertMany = this.sqlite.transaction((n) => {
+      for (let i = 0; i < n; i++)
+        stmt.run(operation, now);
+    });
+    insertMany(count);
+  }
   getOperationCounts() {
     const now = /* @__PURE__ */ new Date();
     const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1e3).toISOString();
@@ -708,33 +799,85 @@ var KnowledgeRepository = class {
     const cutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString();
     return this.sqlite.prepare("DELETE FROM operations_log WHERE created_at < ?").run(cutoff).changes;
   }
+  /**
+   * Delete embeddings for completed/archived plans older than maxAgeDays.
+   * These plans are never searched semantically (only draft/active are).
+   */
+  cleanupCompletedPlanEmbeddings(maxAgeDays = 30) {
+    const cutoff = new Date(Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3).toISOString();
+    const oldPlans = this.sqlite.prepare(`SELECT id FROM plans WHERE status IN ('completed', 'archived') AND updated_at < ?`).all(cutoff);
+    if (oldPlans.length === 0)
+      return 0;
+    let removed = 0;
+    const deleteStmt = this.sqlite.prepare("DELETE FROM plans_embeddings WHERE id = ?");
+    for (const plan of oldPlans) {
+      const result = deleteStmt.run(plan.id);
+      removed += result.changes;
+    }
+    return removed;
+  }
 };
+function cosineSimilarity(a, b) {
+  let dot = 0, magA = 0, magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(magA) * Math.sqrt(magB);
+  return denom === 0 ? 0 : dot / denom;
+}
 
 // ../../packages/core/dist/services/knowledge.service.js
 var KnowledgeService = class {
   repository;
   embeddingProvider;
+  lastArchiveRunMs = 0;
   constructor(repository, embeddingProvider) {
     this.repository = repository;
     this.embeddingProvider = embeddingProvider;
   }
-  logOp(op) {
+  logOp(op, count = 1) {
     try {
-      this.repository.logOperation(op);
+      if (count <= 1)
+        this.repository.logOperation(op);
+      else
+        this.repository.logOperationBatch(op, count);
     } catch {
     }
   }
+  buildEmbeddingText(title, content, tags) {
+    return `${title} ${content} ${tags.join(" ")}`;
+  }
   async add(input) {
-    const tagsText = input.tags.join(" ");
-    const embedding = await this.embeddingProvider.embed(tagsText);
-    const entry = await this.repository.create({ ...input, embedding });
+    const { skipDedup, ...rest } = input;
+    const embeddingText = this.buildEmbeddingText(rest.title, rest.content, rest.tags);
+    const embedding = await this.embeddingProvider.embed(embeddingText);
+    if (!skipDedup) {
+      try {
+        const similar = await this.repository.searchBySimilarity(embedding, {
+          scope: rest.scope,
+          type: rest.type,
+          limit: 1,
+          threshold: 0.85
+        });
+        if (similar.length > 0) {
+          const existing = similar[0].entry;
+          const updated = await this.repository.update(existing.id, { ...rest, embedding });
+          this.logOp("write");
+          return { ...this.toKnowledgeEntry(updated), deduplicated: true };
+        }
+      } catch {
+      }
+    }
+    const entry = await this.repository.create({ ...rest, embedding });
     this.logOp("write");
     return this.toKnowledgeEntry(entry);
   }
   async search(query, options) {
     const queryEmbedding = await this.embeddingProvider.embed(query);
     const results = await this.repository.searchBySimilarity(queryEmbedding, options);
-    this.logOp("read");
+    this.logOp("read", results.length);
     return results.map((r) => ({
       entry: this.toKnowledgeEntry(r.entry),
       similarity: r.similarity
@@ -746,8 +889,12 @@ var KnowledgeService = class {
   }
   async update(id, updates) {
     let embedding;
-    if (updates.tags && updates.tags.length > 0) {
-      embedding = await this.embeddingProvider.embed(updates.tags.join(" "));
+    if (updates.content || updates.title || updates.tags) {
+      const current = await this.repository.findById(id);
+      const title = updates.title || current?.title || "";
+      const content = updates.content || current?.content || "";
+      const tags = updates.tags || (current?.tags ?? []);
+      embedding = await this.embeddingProvider.embed(this.buildEmbeddingText(title, content, tags));
     }
     const entry = await this.repository.update(id, { ...updates, embedding });
     if (entry)
@@ -764,6 +911,43 @@ var KnowledgeService = class {
     const entries = await this.repository.listAll();
     return entries.map((e) => this.toKnowledgeEntry(e));
   }
+  /**
+   * Re-embed all knowledge entries and plans with the current embedding provider.
+   * Used when switching embedding models (e.g. all-minilm 384d → nomic-embed-text 768d).
+   * Assumes vec tables have already been dropped and recreated with new dimensions.
+   */
+  async reembedAll() {
+    let count = 0;
+    const entries = await this.repository.listAll();
+    for (const entry of entries) {
+      try {
+        const tags = Array.isArray(entry.tags) ? entry.tags : JSON.parse(entry.tags ?? "[]");
+        const text2 = this.buildEmbeddingText(entry.title, entry.content, tags);
+        const embedding = await this.embeddingProvider.embed(text2);
+        try {
+          this.repository.insertEmbeddingById(entry.id, embedding);
+        } catch {
+        }
+        count++;
+      } catch (e) {
+        console.warn(`[CogniStore] Re-embed failed for entry ${entry.id}:`, e);
+      }
+    }
+    const plans = this.repository.listAllPlans();
+    for (const plan of plans) {
+      try {
+        const embedding = await this.embeddingProvider.embed(`${plan.title} ${plan.content}`);
+        try {
+          this.repository.insertPlanEmbeddingById(plan.id, embedding);
+        } catch {
+        }
+        count++;
+      } catch (e) {
+        console.warn(`[CogniStore] Re-embed failed for plan ${plan.id}:`, e);
+      }
+    }
+    return count;
+  }
   async listScopes() {
     return this.repository.listScopes();
   }
@@ -847,8 +1031,50 @@ var KnowledgeService = class {
   }
   // ─── Plans (separate entity) ────────────────────────────────
   async createPlan(input) {
-    const { tasks, ...planInput } = input;
-    const embedding = await this.embeddingProvider.embed(input.tags.join(" "));
+    const { tasks, skipDedup, ...planInput } = input;
+    const embedding = await this.embeddingProvider.embed(`${input.title} ${input.content}`);
+    const now = Date.now();
+    if (now - this.lastArchiveRunMs > 36e5) {
+      try {
+        this.repository.archiveStaleDrafts(24);
+        this.lastArchiveRunMs = now;
+      } catch {
+      }
+    }
+    const similarPlans = skipDedup ? [] : this.repository.findSimilarActivePlans(embedding, input.scope, 0.5);
+    if (similarPlans.length > 0) {
+      const { plan: existingRow } = similarPlans[0];
+      const isActive = existingRow.status === "active";
+      if (isActive) {
+        if (tasks && tasks.length > 0) {
+          for (const task of tasks) {
+            this.repository.createPlanTask({ planId: existingRow.id, description: task.description, priority: task.priority });
+          }
+        }
+        const plan2 = this.toPlan(existingRow);
+        return { ...plan2, deduplicated: true, deduplicatedAction: "tasks_added_to_active_plan" };
+      } else {
+        this.repository.updatePlan(existingRow.id, {
+          title: input.title,
+          content: input.content,
+          tags: input.tags,
+          source: input.source
+        });
+        if (tasks && tasks.length > 0) {
+          this.repository.deletePlanTasks(existingRow.id);
+          for (let i = 0; i < tasks.length; i++) {
+            this.repository.createPlanTask({ planId: existingRow.id, description: tasks[i].description, priority: tasks[i].priority, position: i });
+          }
+        }
+        try {
+          this.repository.updatePlanEmbeddingById(existingRow.id, embedding);
+        } catch {
+        }
+        const updated = this.repository.getPlanById(existingRow.id);
+        const plan2 = this.toPlan(updated);
+        return { ...plan2, deduplicated: true, deduplicatedAction: "draft_plan_updated" };
+      }
+    }
     const row = this.repository.createPlan({ ...planInput, embedding });
     const plan = this.toPlan(row);
     if (tasks && tasks.length > 0) {
@@ -888,10 +1114,13 @@ var KnowledgeService = class {
     const rows = this.repository.listAllPlans();
     return rows.map((r) => this.toPlan(r));
   }
-  listPlans(limit = 20, status) {
-    const rows = this.repository.listPlans(limit, status);
+  listPlans(limit = 20, status, scope) {
+    const rows = this.repository.listPlans(limit, status, scope);
     return rows.map((r) => this.toPlan(r));
   }
+  archiveStaleDrafts(maxAgeHours = 24) {
+    return this.repository.archiveStaleDrafts(maxAgeHours);
+  }
   async importPlans(plans) {
     let imported = 0;
     let skipped = 0;
@@ -1007,6 +1236,9 @@ var KnowledgeService = class {
   cleanupOldOperations() {
     return this.repository.cleanupOldOperations();
   }
+  cleanupCompletedPlanEmbeddings(maxAgeDays = 30) {
+    return this.repository.cleanupCompletedPlanEmbeddings(maxAgeDays);
+  }
   // ─── Converters ─────────────────────────────────────────────
   toKnowledgeEntry(row) {
     return {
@@ -1061,16 +1293,25 @@ var OllamaEmbeddingClient = class {
   model;
   dimensions;
   maxRetries;
+  maxInputChars;
   constructor(config) {
     this.host = config?.host ?? (process.env.OLLAMA_HOST ?? DEFAULT_OLLAMA_HOST);
     this.model = config?.model ?? (process.env.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL);
     this.dimensions = config?.dimensions ?? (Number(process.env.EMBEDDING_DIMENSIONS) || DEFAULT_EMBEDDING_DIMENSIONS);
     this.maxRetries = config?.maxRetries ?? 3;
+    this.maxInputChars = config?.maxInputChars ?? 2e3;
+  }
+  truncateText(text2, maxChars) {
+    if (text2.length <= maxChars)
+      return text2;
+    const truncated = text2.slice(0, maxChars);
+    const lastSpace = truncated.lastIndexOf(" ");
+    return lastSpace > maxChars * 0.5 ? truncated.slice(0, lastSpace) : truncated;
   }
   async embed(text2) {
     const body = {
       model: this.model,
-      prompt: text2
+      prompt: this.truncateText(text2, this.maxInputChars)
     };
     const response = await this.fetchWithRetry(`${this.host}/api/embeddings`, {
       method: "POST",
@@ -1085,8 +1326,11 @@ var OllamaEmbeddingClient = class {
     if (!data.embedding || !Array.isArray(data.embedding)) {
       throw new Error("Invalid embedding response from Ollama");
     }
-    if (data.embedding.length !== this.dimensions) {
-      throw new Error(`Embedding dimension mismatch: expected ${this.dimensions}, got ${data.embedding.length}. Check that OLLAMA_MODEL and EMBEDDING_DIMENSIONS are compatible.`);
+    if (data.embedding.length < this.dimensions) {
+      throw new Error(`Embedding dimension mismatch: expected at least ${this.dimensions}, got ${data.embedding.length}. Check that OLLAMA_MODEL and EMBEDDING_DIMENSIONS are compatible.`);
+    }
+    if (data.embedding.length > this.dimensions) {
+      return this.truncateAndNormalize(data.embedding, this.dimensions);
     }
     return data.embedding;
   }
@@ -1149,6 +1393,17 @@ var OllamaEmbeddingClient = class {
       dimensions: this.dimensions
     };
   }
+  /**
+   * Matryoshka truncation: slice to first targetDims dimensions, then L2-normalize.
+   * L2 normalization is critical for cosine similarity quality after truncation.
+   */
+  truncateAndNormalize(embedding, targetDims) {
+    const truncated = embedding.slice(0, targetDims);
+    const norm = Math.sqrt(truncated.reduce((sum, v) => sum + v * v, 0));
+    if (norm === 0)
+      return truncated;
+    return truncated.map((v) => v / norm);
+  }
   async fetchWithRetry(url, init) {
     let lastError;
     for (let attempt = 0; attempt < this.maxRetries; attempt++) {
@@ -1263,6 +1518,7 @@ var KnowledgeSDK = class {
       } catch (error) {
         throw new EmbeddingError(`Failed to ensure embedding model: ${error instanceof Error ? error.message : String(error)}`);
       }
+      await this.detectAndMigrateDimensions();
       const repository = new KnowledgeRepository(this.db, this.sqlite);
       this.service = new KnowledgeService(repository, this.ollamaClient);
       this.initialized = true;
@@ -1418,13 +1674,13 @@ var KnowledgeSDK = class {
   // ─── Plans (separate entity) ─────────────────────────────────
   async createPlan(input) {
     this.ensureInitialized();
-    const { relatedKnowledgeIds, tasks, ...rest } = input;
+    const { relatedKnowledgeIds, ...rest } = input;
     const parsed = createPlanSchema.safeParse(rest);
     if (!parsed.success) {
       throw new ValidationError(`Invalid plan input: ${parsed.error.message}`);
     }
     try {
-      const plan = await this.service.createPlan({ ...parsed.data, tasks });
+      const plan = await this.service.createPlan(parsed.data);
       if (relatedKnowledgeIds) {
         for (const kid of relatedKnowledgeIds) {
           try {
@@ -1450,9 +1706,9 @@ var KnowledgeSDK = class {
     this.ensureInitialized();
     return this.service.deletePlan(id);
   }
-  listPlans(limit = 20, status) {
+  listPlans(limit = 20, status, scope) {
     this.ensureInitialized();
-    return this.service.listPlans(limit, status);
+    return this.service.listPlans(limit, status, scope);
   }
   async addPlanRelation(planId, knowledgeId, relationType) {
     this.ensureInitialized();
@@ -1501,6 +1757,14 @@ var KnowledgeSDK = class {
     this.ensureInitialized();
     return this.service.getPlanTaskStats();
   }
+  /**
+   * Re-embed all knowledge entries and plans with the current embedding model.
+   * Used during upgrade when switching embedding models (dimensions change).
+   */
+  async reembedAll() {
+    this.ensureInitialized();
+    return this.service.reembedAll();
+  }
   // ─── Operations ─────────────────────────────────────────────
   getOperationCounts() {
     this.ensureInitialized();
@@ -1515,6 +1779,11 @@ var KnowledgeSDK = class {
       return 0;
     return this.service.cleanupOldOperations();
   }
+  cleanupCompletedPlanEmbeddings(maxAgeDays = 30) {
+    if (!this.initialized || !this.service)
+      return 0;
+    return this.service.cleanupCompletedPlanEmbeddings(maxAgeDays);
+  }
   async healthCheck() {
     const ollamaHealth = await checkOllamaHealth(this.ollamaClient);
     let dbConnected = false;
@@ -1563,6 +1832,14 @@ var KnowledgeSDK = class {
       throw this.wrapError(error, "Failed to cleanup database");
     }
   }
+  /**
+   * Run a passive WAL checkpoint to keep the WAL file small.
+   * PASSIVE mode does not block readers or writers.
+   */
+  walCheckpoint() {
+    this.ensureInitialized();
+    this.sqlite.pragma("wal_checkpoint(PASSIVE)");
+  }
   ensureInitialized() {
     if (!this.initialized || !this.service) {
       throw new ConnectionError("SDK not initialized. Call initialize() first.");
@@ -1579,6 +1856,38 @@ var KnowledgeSDK = class {
     this.db = null;
     this.service = null;
   }
+  /**
+   * Detect if stored embeddings have different dimensions than config.
+   * If mismatch found (e.g., 768→256 Matryoshka migration), drop vec tables,
+   * recreate at new dimensions, and re-embed all entries.
+   */
+  async detectAndMigrateDimensions() {
+    const targetDims = this.config.ollama.dimensions;
+    try {
+      const sampleRow = this.sqlite.prepare("SELECT embedding FROM knowledge_embeddings LIMIT 1").get();
+      if (!sampleRow)
+        return;
+      const currentDims = sampleRow.embedding.byteLength / 4;
+      if (currentDims === targetDims)
+        return;
+      console.error(`[CogniStore] Embedding dimension mismatch: DB has ${currentDims}d, config wants ${targetDims}d. Re-embedding all entries...`);
+      this.sqlite.exec("DROP TABLE IF EXISTS knowledge_embeddings");
+      this.sqlite.exec("DROP TABLE IF EXISTS plans_embeddings");
+      createEmbeddingsTable(this.sqlite, targetDims);
+      this.sqlite.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS plans_embeddings USING vec0(
+          id TEXT PRIMARY KEY,
+          embedding float[${targetDims}] distance_metric=cosine
+        )
+      `);
+      const repository = new KnowledgeRepository(this.db, this.sqlite);
+      const tempService = new KnowledgeService(repository, this.ollamaClient);
+      const count = await tempService.reembedAll();
+      console.error(`[CogniStore] Re-embedded ${count} entries at ${targetDims} dimensions`);
+    } catch (error) {
+      console.error(`[CogniStore] Dimension migration failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
   wrapError(error, context) {
     if (error instanceof Error && error.name.endsWith("Error")) {
       return error;
@@ -1685,19 +1994,26 @@ function createServer(sdk) {
       });
       lastSearchResultIds = results.map((r) => r.entry.id);
       const response = { results };
-      try {
-        const activePlans = sdk.listPlans(1, "active");
-        const draftPlans = sdk.listPlans(1, "draft");
-        const currentPlan = activePlans[0] || draftPlans[0];
-        if (currentPlan) {
-          response.activePlan = {
-            id: currentPlan.id,
-            title: currentPlan.title,
-            status: currentPlan.status,
-            hint: "Pass this planId to addKnowledge calls for output linking."
-          };
+      if (params.scope) {
+        try {
+          const activePlans = sdk.listPlans(1, "active", params.scope);
+          const draftPlans = sdk.listPlans(1, "draft", params.scope);
+          const currentPlan = activePlans[0] || draftPlans[0];
+          if (currentPlan) {
+            const tasks = sdk.listPlanTasks(currentPlan.id);
+            const completedTasks = tasks.filter((t) => t.status === "completed").length;
+            response.activePlan = {
+              id: currentPlan.id,
+              title: currentPlan.title,
+              status: currentPlan.status,
+              scope: currentPlan.scope,
+              taskCount: tasks.length,
+              completedTasks,
+              hint: `You have an active plan (${completedTasks}/${tasks.length} tasks done). Use updatePlan(planId, ...) to modify it or updatePlanTask() to track progress. Do NOT call createPlan() \u2014 it will auto-deduplicate into this plan.`
+            };
+          }
+        } catch {
         }
-      } catch {
       }
       return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
     }
@@ -1795,9 +2111,12 @@ function createServer(sdk) {
         tasks: params.tasks
       });
       lastSearchResultIds = [];
+      const deduplicated = result.deduplicated === true;
+      const deduplicatedAction = result.deduplicatedAction;
+      const reminder = deduplicated ? `Existing plan "${result.title}" was reused (${deduplicatedAction === "tasks_added_to_active_plan" ? "new tasks added to active plan" : "draft plan updated"}). Plan ID: "${result.id}". Pass this planId to addKnowledge calls.` : `Your plan ID is "${result.id}". Pass planId: "${result.id}" to every addKnowledge call for output linking. Plan auto-activates when you start the first task.`;
       const response = {
         ...result,
-        reminder: `Your plan ID is "${result.id}". Pass planId: "${result.id}" to every addKnowledge call for output linking. Plan auto-activates when you start the first task.`
+        reminder
       };
       return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
     }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@cognistore/mcp-server",
-  "version": "1.0.9",
+  "version": "1.0.14",
   "private": false,
   "type": "module",
   "description": "MCP server for CogniStore — integrates with Claude Code and GitHub Copilot",
   "license": "BUSL-1.1",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Sithion/cognistore",
+    "url": "git+https://github.com/Sithion/cognistore.git",
     "directory": "apps/mcp-server"
   },
   "main": "./dist/index.js",