@cognistore/mcp-server 0.9.13 → 1.0.0

package/dist/index.js

@@ -21,6 +21,7 @@ var KnowledgeType;
   KnowledgeType2["FIX"] = "fix";
   KnowledgeType2["CONSTRAINT"] = "constraint";
   KnowledgeType2["GOTCHA"] = "gotcha";
+  KnowledgeType2["SYSTEM"] = "system";
 })(KnowledgeType || (KnowledgeType = {}));
 var KnowledgeStatus;
 (function(KnowledgeStatus2) {
@@ -134,7 +135,7 @@ __export(schema_exports, {
 
 // ../../packages/core/dist/db/schema/knowledge.js
 import { sqliteTable, text, integer, real, index } from "drizzle-orm/sqlite-core";
-var knowledgeTypeEnum = ["decision", "pattern", "fix", "constraint", "gotcha"];
+var knowledgeTypeEnum = ["decision", "pattern", "fix", "constraint", "gotcha", "system"];
 var knowledgeEntries = sqliteTable("knowledge_entries", {
   id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
   title: text("title").notNull().default(""),
@@ -376,7 +377,7 @@ function createPlansEmbeddingsTable(sqlite) {
 }
 
 // ../../packages/core/dist/repositories/knowledge.repository.js
-import { eq, sql, and, or, isNull } from "drizzle-orm";
+import { eq, ne, sql, and, or, isNull } from "drizzle-orm";
 var KnowledgeRepository = class {
   db;
   sqlite;
@@ -461,6 +462,7 @@ var KnowledgeRepository = class {
     if (options?.type) {
       conditions.push(eq(knowledgeEntries.type, options.type));
     }
+    conditions.push(ne(knowledgeEntries.type, "system"));
     conditions.push(or(isNull(knowledgeEntries.expiresAt), sql`${knowledgeEntries.expiresAt} > ${(/* @__PURE__ */ new Date()).toISOString()}`));
     const whereClause = and(...conditions);
     const entries = await this.db.select().from(knowledgeEntries).where(whereClause);
@@ -470,27 +472,23 @@ var KnowledgeRepository = class {
     })).filter((r) => r.similarity >= threshold).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
   }
   async listRecent(limit = 20, filters) {
-    const conditions = [];
+    const conditions = [ne(knowledgeEntries.type, "system")];
     if (filters?.type)
       conditions.push(sql`${knowledgeEntries.type} = ${filters.type}`);
     if (filters?.scope)
       conditions.push(sql`${knowledgeEntries.scope} = ${filters.scope}`);
-    if (conditions.length === 0) {
-      return this.db.select().from(knowledgeEntries).orderBy(sql`${knowledgeEntries.createdAt} DESC`).limit(limit);
-    }
-    const where = conditions.length === 1 ? conditions[0] : sql`${conditions[0]} AND ${conditions[1]}`;
-    return this.db.select().from(knowledgeEntries).where(where).orderBy(sql`${knowledgeEntries.createdAt} DESC`).limit(limit);
+    return this.db.select().from(knowledgeEntries).where(and(...conditions)).orderBy(sql`${knowledgeEntries.createdAt} DESC`).limit(limit);
   }
   async listTags() {
-    const result = await this.db.all(sql`SELECT DISTINCT value FROM knowledge_entries, json_each(knowledge_entries.tags)`);
+    const result = await this.db.all(sql`SELECT DISTINCT value FROM knowledge_entries, json_each(knowledge_entries.tags) WHERE knowledge_entries.type != 'system'`);
     return result.map((r) => r.value);
   }
   async topTags(limit = 10) {
-    const result = await this.db.all(sql`SELECT value as tag, COUNT(*) as count FROM knowledge_entries, json_each(knowledge_entries.tags) GROUP BY value ORDER BY count DESC LIMIT ${limit}`);
+    const result = await this.db.all(sql`SELECT value as tag, COUNT(*) as count FROM knowledge_entries, json_each(knowledge_entries.tags) WHERE knowledge_entries.type != 'system' GROUP BY value ORDER BY count DESC LIMIT ${limit}`);
     return result;
   }
   async count() {
-    const [result] = await this.db.select({ count: sql`count(*)` }).from(knowledgeEntries);
+    const [result] = await this.db.select({ count: sql`count(*)` }).from(knowledgeEntries).where(ne(knowledgeEntries.type, "system"));
     return Number(result.count);
   }
   async lastUpdatedAt() {
@@ -501,18 +499,18 @@ var KnowledgeRepository = class {
     const results = await this.db.select({
       type: knowledgeEntries.type,
       count: sql`count(*)`
-    }).from(knowledgeEntries).groupBy(knowledgeEntries.type);
+    }).from(knowledgeEntries).where(ne(knowledgeEntries.type, "system")).groupBy(knowledgeEntries.type);
     return results.map((r) => ({ type: r.type, count: Number(r.count) }));
   }
   async countByScope() {
     const results = await this.db.select({
       scope: knowledgeEntries.scope,
       count: sql`count(*)`
-    }).from(knowledgeEntries).groupBy(knowledgeEntries.scope);
+    }).from(knowledgeEntries).where(ne(knowledgeEntries.type, "system")).groupBy(knowledgeEntries.scope);
     return results.map((r) => ({ scope: r.scope, count: Number(r.count) }));
   }
   async listAll() {
-    return this.db.select().from(knowledgeEntries).orderBy(sql`${knowledgeEntries.createdAt} DESC`);
+    return this.db.select().from(knowledgeEntries).where(ne(knowledgeEntries.type, "system")).orderBy(sql`${knowledgeEntries.createdAt} DESC`);
   }
   async listScopes() {
     const rows = this.sqlite.prepare(`SELECT DISTINCT scope FROM knowledge_entries
@@ -638,6 +636,14 @@ var KnowledgeRepository = class {
   getPlanTaskById(id) {
     return this.sqlite.prepare("SELECT * FROM plan_tasks WHERE id = ?").get(id) ?? null;
   }
+  getTaskPlanId(taskId) {
+    const row = this.sqlite.prepare("SELECT plan_id FROM plan_tasks WHERE id = ?").get(taskId);
+    return row?.plan_id ?? null;
+  }
+  countIncompleteTasks(planId) {
+    const row = this.sqlite.prepare("SELECT COUNT(*) as cnt FROM plan_tasks WHERE plan_id = ? AND status != 'completed'").get(planId);
+    return row?.cnt ?? 0;
+  }
   getPlanTaskStats() {
     const result = this.sqlite.prepare(`
       SELECT
@@ -766,6 +772,11 @@ var KnowledgeService = class {
     const errors = [];
     for (const id of ids) {
       try {
+        const entry = await this.repository.findById(id);
+        if (entry?.type === "system") {
+          errors.push(`Skipped ${id}: system knowledge cannot be deleted`);
+          continue;
+        }
         const result = await this.repository.delete(id);
         if (result) {
           deleted++;
@@ -858,7 +869,17 @@ var KnowledgeService = class {
   }
   updatePlan(id, updates) {
     const row = this.repository.updatePlan(id, updates);
-    return row ? this.toPlan(row) : null;
+    if (!row)
+      return null;
+    if (updates.status === "completed") {
+      const tasks = this.repository.listPlanTasks(id);
+      for (const t of tasks) {
+        if (t.status !== "completed") {
+          this.repository.updatePlanTask(t.id, { status: "completed" });
+        }
+      }
+    }
+    return this.toPlan(row);
   }
   deletePlan(id) {
     return this.repository.deletePlan(id);
@@ -934,7 +955,38 @@ var KnowledgeService = class {
   }
   updatePlanTask(id, updates) {
     const row = this.repository.updatePlanTask(id, updates);
-    return row ? this.toPlanTask(row) : null;
+    if (!row)
+      return null;
+    const task = this.toPlanTask(row);
+    const planId = this.repository.getTaskPlanId(id);
+    const autoActions = [];
+    if (planId) {
+      if (updates.status === "in_progress") {
+        const plan = this.repository.getPlanById(planId);
+        if (plan && (plan.status === "draft" || plan.status === "completed")) {
+          this.repository.updatePlan(planId, { status: "active" });
+          autoActions.push(`Plan auto-activated from ${plan.status} to active`);
+        }
+      }
+      if (updates.status === "completed") {
+        const incomplete = this.repository.countIncompleteTasks(planId);
+        if (incomplete === 0) {
+          this.repository.updatePlan(planId, { status: "completed" });
+          autoActions.push("Plan auto-completed \u2014 all tasks done");
+        }
+      }
+    }
+    const currentPlan = planId ? this.repository.getPlanById(planId) : null;
+    const allTasks = planId ? this.repository.listPlanTasks(planId) : [];
+    const completedCount = allTasks.filter((t) => t.status === "completed").length;
+    const progress = `${completedCount}/${allTasks.length} completed`;
+    return {
+      task,
+      planId: planId ?? "",
+      planStatus: currentPlan?.status ?? "unknown",
+      progress,
+      autoActions
+    };
   }
   deletePlanTask(id) {
     return this.repository.deletePlanTask(id);
@@ -1262,16 +1314,28 @@ var KnowledgeSDK = class {
       throw new ValidationError(`Invalid updates: ${parsed.error.message}`);
     }
     try {
+      const existing = await this.service.getById(id);
+      if (existing?.type === "system" && updates.type && updates.type !== "system") {
+        throw new ValidationError("System knowledge type cannot be changed");
+      }
       return await this.service.update(id, parsed.data);
     } catch (error) {
+      if (error instanceof ValidationError)
+        throw error;
       throw this.wrapError(error, "Failed to update knowledge");
     }
   }
   async deleteKnowledge(id) {
     this.ensureInitialized();
     try {
+      const existing = await this.service.getById(id);
+      if (existing?.type === "system") {
+        throw new ValidationError("System knowledge cannot be deleted");
+      }
       return await this.service.delete(id);
     } catch (error) {
+      if (error instanceof ValidationError)
+        throw error;
       throw this.wrapError(error, "Failed to delete knowledge");
     }
   }
@@ -1390,8 +1454,12 @@ var KnowledgeSDK = class {
     this.ensureInitialized();
     return this.service.listPlans(limit, status);
   }
-  addPlanRelation(planId, knowledgeId, relationType) {
+  async addPlanRelation(planId, knowledgeId, relationType) {
     this.ensureInitialized();
+    const entry = await this.service.getById(knowledgeId);
+    if (entry?.type === "system") {
+      return;
+    }
     this.service.addPlanRelation(planId, knowledgeId, relationType);
   }
   async getPlanRelations(planId) {
@@ -1411,6 +1479,16 @@ var KnowledgeSDK = class {
     this.ensureInitialized();
     return this.service.updatePlanTask(id, updates);
   }
+  updatePlanTasks(updates) {
+    this.ensureInitialized();
+    const results = [];
+    for (const u of updates) {
+      const result = this.service.updatePlanTask(u.taskId, { status: u.status, notes: u.notes });
+      if (result)
+        results.push(result);
+    }
+    return results;
+  }
   deletePlanTask(id) {
     this.ensureInitialized();
     return this.service.deletePlanTask(id);
@@ -1510,28 +1588,34 @@ var KnowledgeSDK = class {
 };
 
 // src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z2 } from "zod";
 var knowledgeTypeValues = ["decision", "pattern", "fix", "constraint", "gotcha"];
 var knowledgeStatusValues = ["draft", "active", "completed", "archived"];
+var READ_ONLY = { readOnlyHint: true, destructiveHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false };
+var DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true };
 function createServer(sdk) {
   const server = new McpServer({
     name: "cognistore",
-    version: "0.1.0"
+    version: "1.0.0"
   });
+  let lastSearchResultIds = [];
   server.tool(
     "addKnowledge",
-    "Store a new knowledge entry with semantic embedding. Content is vectorized for future semantic search.",
+    "Store a knowledge entry. If you have an active plan, ALWAYS pass planId to auto-link as output.",
     {
-      title: z2.string().describe("Short descriptive title for the knowledge entry"),
-      content: z2.string().describe("The knowledge content text to store"),
-      tags: z2.array(z2.string()).describe("Mandatory categorical tags for filtering"),
-      type: z2.enum(knowledgeTypeValues).describe("Type of knowledge entry"),
+      title: z2.string().describe("Short descriptive title"),
+      content: z2.string().describe("The knowledge content text"),
+      tags: z2.array(z2.string()).describe("Categorical tags for filtering"),
+      type: z2.enum(knowledgeTypeValues).describe("Type: decision, pattern, fix, constraint, or gotcha"),
       scope: z2.string().describe('Scope: "global" or "workspace:<project-name>"'),
       source: z2.string().describe("Source of the knowledge"),
       confidenceScore: z2.number().min(0).max(1).optional().describe("Confidence score 0-1"),
-      agentId: z2.string().optional().describe("ID of the agent that created this")
+      agentId: z2.string().optional().describe("ID of the agent that created this"),
+      planId: z2.string().optional().describe("Plan ID to auto-link this knowledge as output. ALWAYS pass this if you have an active plan.")
     },
+    WRITE,
     async (params) => {
       const result = await sdk.addKnowledge({
         title: params.title,
@@ -1543,12 +1627,69 @@ function createServer(sdk) {
         confidenceScore: params.confidenceScore,
         agentId: params.agentId
       });
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      let linked = false;
+      let linkWarning = "";
+      if (params.planId && result.type !== "system") {
+        try {
+          await sdk.addPlanRelation(params.planId, result.id, "output");
+          linked = true;
+        } catch (e) {
+          linkWarning = e instanceof Error ? e.message : "Unknown linking error";
+        }
+      }
+      const response = { entry: result };
+      if (params.planId) {
+        response.linked = linked;
+        response.planId = params.planId;
+        if (linkWarning) response.linkWarning = linkWarning;
+      }
+      return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+    }
+  );
+  server.tool(
+    "addKnowledgeBatch",
+    "Create multiple knowledge entries at once. Pass planId per entry for output linking. Reduces tool calls.",
+    {
+      entries: z2.array(z2.object({
+        title: z2.string(),
+        content: z2.string(),
+        tags: z2.array(z2.string()),
+        type: z2.enum(knowledgeTypeValues),
+        scope: z2.string(),
+        source: z2.string(),
+        planId: z2.string().optional()
+      })).describe("Array of knowledge entries to create")
+    },
+    WRITE,
+    async (params) => {
+      const results = [];
+      for (const e of params.entries) {
+        const entry = await sdk.addKnowledge({
+          title: e.title,
+          content: e.content,
+          tags: e.tags,
+          type: e.type,
+          scope: e.scope,
+          source: e.source
+        });
+        let linked = false;
+        let linkWarning = "";
+        if (e.planId && entry.type !== "system") {
+          try {
+            await sdk.addPlanRelation(e.planId, entry.id, "output");
+            linked = true;
+          } catch (err) {
+            linkWarning = err instanceof Error ? err.message : "Unknown linking error";
+          }
+        }
+        results.push({ entry, linked, ...e.planId ? { planId: e.planId } : {}, ...linkWarning ? { linkWarning } : {} });
+      }
+      return { content: [{ type: "text", text: JSON.stringify({ created: results.length, entries: results }, null, 2) }] };
     }
   );
   server.tool(
     "getKnowledge",
-    "Search knowledge semantically. When a specific scope is provided, global knowledge is always included.",
+    "Search knowledge semantically. SAVE returned entry IDs \u2014 pass them as relatedKnowledgeIds when calling createPlan.",
     {
       query: z2.string().describe("Natural language query to search for"),
       tags: z2.array(z2.string()).optional().describe("Optional tag filters"),
@@ -1557,6 +1698,7 @@ function createServer(sdk) {
       limit: z2.number().optional().describe("Max results (default: 10)"),
       threshold: z2.number().optional().describe("Min similarity 0-1 (default: 0.3)")
     },
+    READ_ONLY,
     async (params) => {
       const results = await sdk.getKnowledge(params.query, {
         tags: params.tags,
@@ -1565,7 +1707,23 @@ function createServer(sdk) {
         limit: params.limit,
         threshold: params.threshold
       });
-      return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+      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."
+          };
+        }
+      } catch {
+      }
+      return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
     }
   );
   server.tool(
@@ -1581,6 +1739,7 @@ function createServer(sdk) {
       source: z2.string().optional().describe("New source"),
       confidenceScore: z2.number().min(0).max(1).optional().describe("New confidence score")
     },
+    WRITE,
     async (params) => {
       const { id, ...updates } = params;
       const result = await sdk.updateKnowledge(id, {
@@ -1592,8 +1751,8 @@ function createServer(sdk) {
         source: updates.source,
         confidenceScore: updates.confidenceScore
       });
-      const text2 = result ? JSON.stringify(result, null, 2) : "Knowledge entry not found";
-      return { content: [{ type: "text", text: text2 }] };
+      if (!result) return { content: [{ type: "text", text: JSON.stringify({ error: "not_found", type: "knowledge_entry", id }) }] };
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
   server.tool(
@@ -1602,17 +1761,18 @@ function createServer(sdk) {
     {
       id: z2.string().describe("UUID of the knowledge entry to delete")
     },
+    DESTRUCTIVE,
     async (params) => {
       const deleted = await sdk.deleteKnowledge(params.id);
-      return {
-        content: [{ type: "text", text: deleted ? "Deleted successfully" : "Not found" }]
-      };
+      if (!deleted) return { content: [{ type: "text", text: JSON.stringify({ error: "not_found", type: "knowledge_entry", id: params.id }) }] };
+      return { content: [{ type: "text", text: JSON.stringify({ deleted: true, id: params.id }) }] };
     }
   );
   server.tool(
     "listTags",
     "List all unique tags across all knowledge entries.",
     {},
+    READ_ONLY,
     async () => {
       const tags = await sdk.listTags();
       return { content: [{ type: "text", text: JSON.stringify(tags) }] };
@@ -1622,6 +1782,7 @@ function createServer(sdk) {
     "healthCheck",
     "Check health of the knowledge base infrastructure (database, Ollama).",
     {},
+    READ_ONLY,
     async () => {
       const health = await sdk.healthCheck();
       return { content: [{ type: "text", text: JSON.stringify(health, null, 2) }] };
@@ -1629,73 +1790,90 @@ function createServer(sdk) {
   );
   server.tool(
     "createPlan",
-    "Create a new plan in the knowledge base. Plans are the ONLY way to persist implementation plans \u2014 never use local files. Status starts as draft.",
+    "Create a plan with tasks. Plan auto-activates when the first task starts. Returns planId \u2014 SAVE IT and pass to addKnowledge calls.",
     {
       title: z2.string().describe("Plan title (short, descriptive)"),
       content: z2.string().describe("Full plan content (steps, approach, considerations)"),
       tags: z2.array(z2.string()).describe("Tags for categorization"),
       scope: z2.string().describe('Scope: "global" or "workspace:<project-name>"'),
       source: z2.string().describe("Source/context of the plan"),
-      relatedKnowledgeIds: z2.array(z2.string()).optional().describe("IDs of knowledge entries consulted during planning (input relations)"),
+      relatedKnowledgeIds: z2.array(z2.string()).optional().describe("IDs of knowledge entries consulted during planning (auto-linked as input)"),
       tasks: z2.array(z2.object({
         description: z2.string(),
         priority: z2.enum(["low", "medium", "high"]).optional()
-      })).optional().describe("Initial tasks for the plan todo list")
+      })).optional().describe("Tasks for the plan. ALWAYS include tasks for multi-step work.")
     },
+    WRITE,
     async (params) => {
+      const inputIds = /* @__PURE__ */ new Set([
+        ...params.relatedKnowledgeIds || [],
+        ...lastSearchResultIds
+      ]);
       const result = await sdk.createPlan({
         title: params.title,
         content: params.content,
         tags: params.tags,
         scope: params.scope,
         source: params.source,
-        relatedKnowledgeIds: params.relatedKnowledgeIds,
+        relatedKnowledgeIds: inputIds.size > 0 ? [...inputIds] : void 0,
         tasks: params.tasks
       });
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      lastSearchResultIds = [];
+      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.`
+      };
+      return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
     }
   );
   server.tool(
     "updatePlan",
-    "Update an existing plan. Use to change status (draft \u2192 active \u2192 completed \u2192 archived), title, content, tags, or scope.",
+    "Update a plan. Status lifecycle: draft \u2192 active \u2192 completed. Plan auto-activates and auto-completes via task updates \u2014 usually you do not need to call this manually.",
     {
       planId: z2.string().describe("UUID of the plan to update"),
       title: z2.string().optional().describe("New title"),
       content: z2.string().optional().describe("New content"),
       tags: z2.array(z2.string()).optional().describe("New tags"),
       scope: z2.string().optional().describe("New scope"),
-      status: z2.enum(knowledgeStatusValues).optional().describe("New status"),
+      status: z2.enum(knowledgeStatusValues).optional().describe("New status (usually auto-managed)"),
       source: z2.string().optional().describe("New source")
     },
+    WRITE,
     async (params) => {
       const { planId, ...updates } = params;
       const result = sdk.updatePlan(planId, updates);
-      const text2 = result ? JSON.stringify(result, null, 2) : "Plan not found";
-      return { content: [{ type: "text", text: text2 }] };
+      if (!result) return { content: [{ type: "text", text: JSON.stringify({ error: "not_found", type: "plan", id: planId }) }] };
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
   server.tool(
     "addPlanRelation",
-    'Link a knowledge entry to a plan. Use "input" for entries consulted during planning, "output" for entries created/updated during execution.',
+    "Link a knowledge entry to a plan. Input = consulted during planning, output = created during execution. Usually auto-handled \u2014 use only for manual linking.",
     {
       planId: z2.string().describe("UUID of the plan"),
       knowledgeId: z2.string().describe("UUID of the knowledge entry to link"),
-      relationType: z2.enum(["input", "output"]).describe('"input" = consulted during planning, "output" = created/updated during execution')
+      relationType: z2.enum(["input", "output"]).describe('"input" = consulted, "output" = produced')
     },
+    WRITE,
     async (params) => {
-      sdk.addPlanRelation(params.planId, params.knowledgeId, params.relationType);
-      return { content: [{ type: "text", text: JSON.stringify({ success: true, ...params }) }] };
+      try {
+        sdk.addPlanRelation(params.planId, params.knowledgeId, params.relationType);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, ...params }) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: "link_failed", message: e instanceof Error ? e.message : "Unknown error", ...params }) }] };
+      }
     }
   );
   server.tool(
     "addPlanTask",
-    "Add a task to a plan todo list. Position is auto-calculated.",
+    "Add a task to a plan. Position is auto-calculated.",
     {
       planId: z2.string().describe("UUID of the plan"),
       description: z2.string().describe("Task description"),
       priority: z2.enum(["low", "medium", "high"]).optional().describe("Priority (default: medium)"),
       notes: z2.string().optional().describe("Optional notes")
     },
+    WRITE,
     async (params) => {
       const task = sdk.createPlanTask(params);
       return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
@@ -1703,7 +1881,7 @@ function createServer(sdk) {
   );
   server.tool(
     "updatePlanTask",
-    "Update a plan task. Mark in_progress when starting, completed when done. Add notes for context.",
+    "Update a task status. Plan auto-activates on first in_progress and auto-completes when all tasks are done.",
     {
       taskId: z2.string().describe("UUID of the task"),
       status: z2.enum(["pending", "in_progress", "completed"]).optional().describe("New status"),
@@ -1711,22 +1889,126 @@ function createServer(sdk) {
       priority: z2.enum(["low", "medium", "high"]).optional().describe("New priority"),
       notes: z2.string().nullable().optional().describe("Notes about progress or blockers")
     },
+    WRITE,
     async (params) => {
       const { taskId, ...updates } = params;
-      const task = sdk.updatePlanTask(taskId, updates);
-      const text2 = task ? JSON.stringify(task, null, 2) : "Task not found";
-      return { content: [{ type: "text", text: text2 }] };
+      const result = sdk.updatePlanTask(taskId, updates);
+      if (!result) return { content: [{ type: "text", text: JSON.stringify({ error: "not_found", type: "plan_task", id: taskId }) }] };
+      const response = {
+        task: result.task,
+        plan: { id: result.planId, status: result.planStatus, progress: result.progress },
+        ...result.autoActions.length > 0 ? { autoActions: result.autoActions } : {},
+        reminder: `Plan ID: "${result.planId}". Pass this planId to addKnowledge calls for output linking.`
+      };
+      return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+    }
+  );
+  server.tool(
+    "updatePlanTasks",
+    "Update multiple tasks at once. Reduces tool calls. Plan auto-activates and auto-completes automatically.",
+    {
+      updates: z2.array(z2.object({
+        taskId: z2.string().describe("UUID of the task"),
+        status: z2.enum(["pending", "in_progress", "completed"]).optional(),
+        notes: z2.string().nullable().optional()
+      })).describe("Array of task updates")
+    },
+    WRITE,
+    async (params) => {
+      const results = sdk.updatePlanTasks(params.updates);
+      const allAutoActions = results.flatMap((r) => r.autoActions);
+      const lastResult = results[results.length - 1];
+      const response = {
+        updated: results.length,
+        tasks: results.map((r) => ({ id: r.task.id, status: r.task.status, description: r.task.description })),
+        plan: lastResult ? { id: lastResult.planId, status: lastResult.planStatus, progress: lastResult.progress } : void 0,
+        ...allAutoActions.length > 0 ? { autoActions: allAutoActions } : {},
+        reminder: lastResult ? `Plan ID: "${lastResult.planId}". Pass this planId to addKnowledge calls.` : void 0
+      };
+      return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
     }
   );
   server.tool(
     "listPlanTasks",
-    "List all tasks for a plan, ordered by position. Use to check progress or resume work.",
+    "List all tasks for a plan, ordered by position. Shows progress.",
     {
       planId: z2.string().describe("UUID of the plan")
     },
+    READ_ONLY,
     async (params) => {
       const tasks = sdk.listPlanTasks(params.planId);
-      return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
+      const completed = tasks.filter((t) => t.status === "completed").length;
+      const response = {
+        tasks,
+        progress: `${completed}/${tasks.length} completed`,
+        reminder: `Plan ID: "${params.planId}". Pass this planId to addKnowledge calls for output linking.`
+      };
+      return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+    }
+  );
+  server.resource(
+    "knowledge-context",
+    new ResourceTemplate("cognistore://context/{scope}", { list: void 0 }),
+    { description: "Workspace-scoped knowledge base context with recent entries and active plans" },
+    async (uri, variables) => {
+      const scope = variables.scope || "global";
+      const scopeFilter = scope === "global" ? void 0 : `workspace:${scope}`;
+      let knowledgeSection = "";
+      try {
+        const results = await sdk.getKnowledge("*", { scope: scopeFilter, limit: 10, threshold: 0 });
+        if (results.length > 0) {
+          knowledgeSection = "## Recent Knowledge\n\n" + results.map(
+            (r) => `- **${r.entry.title}** (${r.entry.type}, ${r.entry.scope})
+  ${r.entry.content.slice(0, 200)}${r.entry.content.length > 200 ? "..." : ""}`
+          ).join("\n\n");
+        } else {
+          knowledgeSection = "## Recent Knowledge\n\nNo entries found for this scope.";
+        }
+      } catch {
+        knowledgeSection = "## Recent Knowledge\n\nUnable to fetch entries.";
+      }
+      let plansSection = "";
+      try {
+        const plans = sdk.listPlans(10, "active");
+        const scopedPlans = scopeFilter ? plans.filter((p) => p.scope === scopeFilter || p.scope === "global") : plans;
+        if (scopedPlans.length > 0) {
+          const planEntries = scopedPlans.map((p) => {
+            const tasks = sdk.listPlanTasks(p.id);
+            const completed = tasks.filter((t) => t.status === "completed").length;
+            return `- **${p.title}** (${p.status}, ${completed}/${tasks.length} tasks done)
+  ${p.content.slice(0, 150)}${p.content.length > 150 ? "..." : ""}`;
+          });
+          plansSection = "## Active Plans\n\n" + planEntries.join("\n\n");
+        } else {
+          plansSection = "## Active Plans\n\nNo active plans for this scope.";
+        }
+      } catch {
+        plansSection = "## Active Plans\n\nUnable to fetch plans.";
+      }
+      let tagsSection = "";
+      try {
+        const tags = await sdk.listTags();
+        if (tags.length > 0) {
+          tagsSection = `## Tags
+
+${tags.slice(0, 20).join(", ")}`;
+        }
+      } catch {
+      }
+      const content = `# CogniStore Context \u2014 ${scope}
+
+${knowledgeSection}
+
+${plansSection}
+
+${tagsSection}`.trim();
+      return {
+        contents: [{
+          uri: uri.href,
+          text: content,
+          mimeType: "text/markdown"
+        }]
+      };
     }
   );
   return server;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognistore/mcp-server",
-  "version": "0.9.13",
+  "version": "1.0.0",
   "private": false,
   "type": "module",
   "description": "MCP server for CogniStore — integrates with Claude Code and GitHub Copilot",