@vheins/local-memory-mcp 0.14.4 → 0.14.6

package/dist/mcp/server.js

@@ -60,7 +60,7 @@ import {
   toContextSlug,
   updateSessionFromInitialize,
   updateSessionRoots
-} from "../chunk-U67YH7MG.js";
+} from "../chunk-GGZWQVNO.js";
 
 // src/mcp/server.ts
 import readline from "readline";
@@ -189,6 +189,7 @@ function invalidCompletionParams(message) {
 
 // src/mcp/tools/memory.store.ts
 import { randomUUID } from "crypto";
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function hasMetadataLikeTitle(title) {
   const normalized = title.trim();
   return /^\[[^\]]{0,200}(agent:|role:|model:|\d{4}-\d{2}-\d{2}|source_)[^\]]*\]/i.test(normalized);
@@ -201,21 +202,28 @@ function generateShortCode() {
   }
   return code;
 }
-async function handleMemoryStore(params, db2, vectors2) {
-  const validated = MemoryStoreSchema.parse(params);
-  if (hasMetadataLikeTitle(validated.title)) {
+function resolveMemorySupersedes(value, db2) {
+  if (!value) return null;
+  if (UUID_REGEX.test(value)) return value;
+  const memory = db2.memories.getByCode(value);
+  if (!memory) throw new Error(`supersedes: memory with code '${value}' not found`);
+  return memory.id;
+}
+async function storeSingleMemory(params, db2, vectors2) {
+  if (hasMetadataLikeTitle(params.title)) {
     throw new Error(
       "Title appears to contain metadata. Keep title concise and move agent/role/date details into metadata or dedicated fields."
     );
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const createdAtTime = new Date(now).getTime();
-  const expires_at = validated.ttlDays != null ? new Date(createdAtTime + validated.ttlDays * 864e5).toISOString() : null;
-  if (!validated.supersedes && validated.type !== "task_archive") {
+  const expires_at = params.ttlDays != null ? new Date(createdAtTime + params.ttlDays * 864e5).toISOString() : null;
+  const resolvedSupersedes = resolveMemorySupersedes(params.supersedes, db2);
+  if (!resolvedSupersedes && params.type !== "task_archive") {
     const conflict = await db2.memoryVectors.checkConflicts(
-      validated.content,
-      validated.scope.repo,
-      validated.type,
+      params.content,
+      params.scope.repo,
+      params.type,
       vectors2,
       0.55
     );
@@ -225,45 +233,34 @@ async function handleMemoryStore(params, db2, vectors2) {
           success: false,
           error: "MEMORY_CONFLICT",
           message: `This memory content overlaps significantly with an existing memory (ID: ${conflict.id}).`,
-          conflicting_memory: {
-            id: conflict.id,
-            title: conflict.title,
-            content: conflict.content
-          },
+          conflicting_memory: { id: conflict.id, title: conflict.title, content: conflict.content },
           instruction: "Use 'memory-update' on the existing ID, or provide 'supersedes' if this new memory replaces it. If the old memory is no longer relevant, you can delete it first."
         },
-        `Rejected due to conflict with ${conflict.id}. Hint: Use 'supersedes' if this replaces the old memory, or 'memory-update' if you're updating it. If the old memory is no longer relevant, delete it first using 'memory-delete'.`,
-        {
-          structuredContentPathHint: "conflicting_memory"
-        }
+        `Rejected due to conflict: "${conflict.title}" (${conflict.id.slice(0, 8)}...). Hint: Use 'supersedes' if this replaces the old memory, or 'memory-update' if updating. If no longer relevant, delete first.`
       );
     }
   }
-  if (validated.supersedes) {
-    const oldMemory = db2.memories.getById(validated.supersedes);
+  if (resolvedSupersedes) {
+    const oldMemory = db2.memories.getById(resolvedSupersedes);
     if (oldMemory) {
       db2.memories.update(oldMemory.id, { status: "archived" });
-      logger.info("[Tool] memory.store - archived superseded memory", {
-        oldId: oldMemory.id,
-        newId: validated.supersedes
-      });
     }
   }
-  const tags = validated.tags ?? [];
-  if (validated.scope.language && !tags.includes(validated.scope.language.toLowerCase())) {
-    tags.push(validated.scope.language.toLowerCase());
+  const tags = params.tags ?? [];
+  if (params.scope.language && !tags.includes(params.scope.language.toLowerCase())) {
+    tags.push(params.scope.language.toLowerCase());
   }
   const entry = {
     id: randomUUID(),
-    code: validated.code || generateShortCode(),
-    type: validated.type,
-    title: validated.title,
-    content: validated.content,
-    importance: validated.importance,
-    agent: validated.agent,
-    role: validated.role,
-    model: validated.model,
-    scope: validated.scope,
+    code: params.code || generateShortCode(),
+    type: params.type,
+    title: params.title,
+    content: params.content,
+    importance: params.importance,
+    agent: params.agent,
+    role: params.role,
+    model: params.model,
+    scope: params.scope,
     created_at: now,
     updated_at: now,
     completed_at: null,
@@ -271,11 +268,11 @@ async function handleMemoryStore(params, db2, vectors2) {
     recall_count: 0,
     last_used_at: null,
     expires_at,
-    supersedes: validated.supersedes ?? null,
+    supersedes: resolvedSupersedes,
     status: "active",
     tags,
-    metadata: validated.metadata ?? {},
-    is_global: validated.is_global
+    metadata: params.metadata ?? {},
+    is_global: params.is_global
   };
   db2.memories.insert(entry);
   try {
@@ -283,13 +280,6 @@ async function handleMemoryStore(params, db2, vectors2) {
   } catch (error) {
     logger.warn("Failed to generate vector embedding", { error: String(error) });
   }
-  logger.info("[Tool] memory.store", {
-    repo: validated.scope.repo,
-    id: entry.id,
-    title: entry.title,
-    type: entry.type,
-    importance: entry.importance
-  });
   return createMcpResponse(
     {
       success: true,
@@ -303,16 +293,134 @@ async function handleMemoryStore(params, db2, vectors2) {
     {
       contentSummary: `Stored [${entry.code}] "${entry.title}" in repo "${entry.scope.repo}".`,
       structuredContentPathHint: "code",
-      includeSerializedStructuredContent: validated.structured
+      includeSerializedStructuredContent: params.structured
     }
   );
 }
+async function handleMemoryStore(params, db2, vectors2) {
+  const validated = MemoryStoreSchema.parse(params);
+  if (validated.memories) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entries = [];
+    const storedCodes = [];
+    for (const mem of validated.memories) {
+      if (hasMetadataLikeTitle(mem.title)) {
+        throw new Error(
+          "Title appears to contain metadata. Keep title concise and move agent/role/date details into metadata or dedicated fields."
+        );
+      }
+      const createdAtTime = new Date(now).getTime();
+      const expires_at = mem.ttlDays != null ? new Date(createdAtTime + mem.ttlDays * 864e5).toISOString() : null;
+      const resolvedSupersedes = resolveMemorySupersedes(mem.supersedes, db2);
+      if (!resolvedSupersedes && mem.type !== "task_archive") {
+        const conflict = await db2.memoryVectors.checkConflicts(
+          mem.content,
+          mem.scope.repo,
+          mem.type,
+          vectors2,
+          0.55
+        );
+        if (conflict) {
+          return createMcpResponse(
+            {
+              success: false,
+              error: "MEMORY_CONFLICT",
+              message: `This memory content overlaps significantly with an existing memory (ID: ${conflict.id}).`,
+              conflicting_memory: { id: conflict.id, title: conflict.title, content: conflict.content },
+              instruction: "Use 'memory-update' on the existing ID, or provide 'supersedes' if this new memory replaces it."
+            },
+            `Rejected due to conflict: "${conflict.title}" (${conflict.id.slice(0, 8)}...). Hint: Use 'supersedes' or 'memory-update'.`
+          );
+        }
+      }
+      if (resolvedSupersedes) {
+        const oldMemory = db2.memories.getById(resolvedSupersedes);
+        if (oldMemory) {
+          db2.memories.update(oldMemory.id, { status: "archived" });
+        }
+      }
+      const tags = mem.tags ?? [];
+      if (mem.scope.language && !tags.includes(mem.scope.language.toLowerCase())) {
+        tags.push(mem.scope.language.toLowerCase());
+      }
+      const code = mem.code || generateShortCode();
+      entries.push({
+        id: randomUUID(),
+        code,
+        type: mem.type,
+        title: mem.title,
+        content: mem.content,
+        importance: mem.importance,
+        agent: mem.agent,
+        role: mem.role,
+        model: mem.model,
+        scope: mem.scope,
+        created_at: now,
+        updated_at: now,
+        completed_at: null,
+        hit_count: 0,
+        recall_count: 0,
+        last_used_at: null,
+        expires_at,
+        supersedes: resolvedSupersedes,
+        status: "active",
+        tags,
+        metadata: mem.metadata ?? {},
+        is_global: mem.is_global
+      });
+      storedCodes.push(code);
+    }
+    db2.memories.bulkInsertMemories(entries);
+    for (const entry of entries) {
+      try {
+        await vectors2.upsert(entry.id, entry.content);
+      } catch (error) {
+        logger.warn("Failed to generate vector embedding", { error: String(error) });
+      }
+    }
+    const codesStr = storedCodes.length > 0 ? `: ${storedCodes.join(", ")}` : "";
+    return createMcpResponse(
+      { success: true, repo: validated.memories[0]?.scope.repo, createdCount: validated.memories.length, codes: storedCodes },
+      `Stored ${validated.memories.length} memories${codesStr}.`,
+      { includeSerializedStructuredContent: validated.structured }
+    );
+  }
+  return storeSingleMemory(
+    {
+      code: validated.code,
+      type: validated.type,
+      title: validated.title,
+      content: validated.content,
+      importance: validated.importance,
+      agent: validated.agent,
+      role: validated.role,
+      model: validated.model,
+      scope: validated.scope,
+      ttlDays: validated.ttlDays,
+      supersedes: validated.supersedes,
+      tags: validated.tags,
+      metadata: validated.metadata,
+      is_global: validated.is_global,
+      structured: validated.structured
+    },
+    db2,
+    vectors2
+  );
+}
 
 // src/mcp/tools/memory.update.ts
+var UUID_REGEX2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function hasMetadataLikeTitle2(title) {
   const normalized = title.trim();
   return /^\[[^\]]{0,200}(agent:|role:|model:|\d{4}-\d{2}-\d{2}|source_)[^\]]*\]/i.test(normalized);
 }
+function resolveMemorySupersedes2(value, db2) {
+  if (!value) return null;
+  if (UUID_REGEX2.test(value)) return value;
+  const memory = db2.memories.getByCode(value);
+  if (!memory) throw new Error(`supersedes: memory with code '${value}' not found`);
+  return memory.id;
+}
 async function handleMemoryUpdate(params, db2, vectors2) {
   const validated = MemoryUpdateSchema.parse(params);
   let resolvedId = validated.id;
@@ -346,7 +454,7 @@ async function handleMemoryUpdate(params, db2, vectors2) {
   if (validated.agent !== void 0) updates.agent = validated.agent;
   if (validated.role !== void 0) updates.role = validated.role;
   if (validated.status !== void 0) updates.status = validated.status;
-  if (validated.supersedes !== void 0) updates.supersedes = validated.supersedes;
+  if (validated.supersedes !== void 0) updates.supersedes = resolveMemorySupersedes2(validated.supersedes, db2);
   if (validated.tags !== void 0) updates.tags = validated.tags;
   if (validated.metadata !== void 0) updates.metadata = validated.metadata;
   if (validated.is_global !== void 0) updates.is_global = validated.is_global;
@@ -365,7 +473,7 @@ async function handleMemoryUpdate(params, db2, vectors2) {
       repo: existing.scope.repo,
       updatedFields: Object.keys(updates)
     },
-    `Updated memory ${resolvedId} in repo "${existing.scope.repo}". Fields: ${Object.keys(updates).join(", ") || "none"}.`,
+    `Updated memory [${existing.code}] in repo "${existing.scope.repo}". Fields: ${Object.keys(updates).join(", ") || "none"}.`,
     {
       structuredContentPathHint: "updatedFields",
       includeSerializedStructuredContent: validated.structured
@@ -647,14 +755,21 @@ function capitalize2(str) {
 
 // src/mcp/tools/task.manage.ts
 import { randomUUID as randomUUID2 } from "crypto";
-var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var UUID_REGEX3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function resolveParentId(value, repo, storage) {
   if (!value) return null;
-  if (UUID_REGEX.test(value)) return value;
+  if (UUID_REGEX3.test(value)) return value;
   const parent = storage.tasks.getTaskByCode(repo, value);
   if (!parent) throw new Error(`parent_id: task with code '${value}' not found in repo '${repo}'`);
   return parent.id;
 }
+function resolveDependsOn(value, repo, storage) {
+  if (!value) return null;
+  if (UUID_REGEX3.test(value)) return value;
+  const task = storage.tasks.getTaskByCode(repo, value);
+  if (!task) throw new Error(`depends_on: task with code '${value}' not found in repo '${repo}'`);
+  return task.id;
+}
 function describeTaskListFilter(status) {
   if (!status) return "active";
   if (status === "all") return "all";
@@ -837,15 +952,18 @@ async function handleTaskCreate(args, storage) {
   const { repo, tasks: bulkTasks, ...singleTask } = parsed;
   if (bulkTasks) {
     const createdTasks = [];
+    const tasksToInsert = [];
     const now2 = (/* @__PURE__ */ new Date()).toISOString();
     const codesInRequest = /* @__PURE__ */ new Set();
+    const allCodes = bulkTasks.map((t) => t.task_code);
+    const existingCodes = storage.tasks.getExistingTaskCodes(repo, allCodes);
     const initialStats = storage.taskStats.getTaskStats(repo);
     let pendingInRequestCount = 0;
     for (const taskData of bulkTasks) {
       if (codesInRequest.has(taskData.task_code)) {
         throw new Error(`Duplicate task_code in request: '${taskData.task_code}'`);
       }
-      if (storage.tasks.isTaskCodeDuplicate(repo, taskData.task_code)) {
+      if (existingCodes.has(taskData.task_code)) {
         throw new Error(`Duplicate task_code: '${taskData.task_code}' already exists in repository '${repo}'`);
       }
       codesInRequest.add(taskData.task_code);
@@ -891,18 +1009,19 @@ async function handleTaskCreate(args, storage) {
         changed_files: [],
         metadata: taskData.metadata || {},
         parent_id: resolveParentId(taskData.parent_id, repo, storage),
-        depends_on: taskData.depends_on || null
+        depends_on: resolveDependsOn(taskData.depends_on, repo, storage)
       };
-      storage.tasks.insertTask(task2);
+      tasksToInsert.push(task2);
       createdTasks.push(task2.task_code);
       if (normalizedStatus === "pending") {
         pendingInRequestCount++;
       }
-      task2._temp_id = task2.id;
     }
+    storage.tasks.bulkInsertTasks(tasksToInsert);
+    const taskCodesStr = createdTasks.length > 0 ? `: ${createdTasks.join(", ")}` : "";
     return createMcpResponse(
       { success: true, repo, createdCount: bulkTasks.length, taskCodes: createdTasks },
-      `Created ${bulkTasks.length} tasks in repo "${repo}".`,
+      `Created ${bulkTasks.length} tasks in repo "${repo}"${taskCodesStr}.`,
       { includeSerializedStructuredContent: parsed.structured || false }
     );
   }
@@ -969,7 +1088,7 @@ async function handleTaskCreate(args, storage) {
     changed_files: [],
     metadata: metadata || {},
     parent_id: resolveParentId(parent_id, repo, storage),
-    depends_on: depends_on || null
+    depends_on: resolveDependsOn(depends_on, repo, storage)
   };
   storage.tasks.insertTask(task);
   return createMcpResponse(
@@ -1139,6 +1258,9 @@ async function handleTaskUpdate(args, storage, vectors2) {
     if (updates.parent_id !== void 0) {
       finalUpdates.parent_id = resolveParentId(updates.parent_id, repo, storage);
     }
+    if (updates.depends_on !== void 0) {
+      finalUpdates.depends_on = resolveDependsOn(updates.depends_on, repo, storage);
+    }
     if (updates.phase !== void 0 || updates.tags !== void 0) {
       let currentTags = updates.tags || existingTask.tags || [];
       currentTags = currentTags.filter((t) => !t.startsWith("phase:"));
@@ -1183,8 +1305,11 @@ async function handleTaskUpdate(args, storage, vectors2) {
     updatedTasks.push({ id: targetId, code: updates.task_code || existingTask.task_code });
     updatedCount++;
   }
+  const taskCodesStr = updatedTasks.length > 0 ? ` Tasks: ${updatedTasks.map((t) => t.code).join(", ")}.` : "";
+  const fieldsStr = Object.keys(updates).length > 0 ? ` Fields: ${Object.keys(updates).join(", ")}.` : "";
   const isCompleted = updates.status === "completed" && updatedCount > 0;
-  let summaryText = isCompleted ? `Updated ${updatedCount} task(s) in repo "${repo}". \u2705 Task marked as completed with commit ${updates.commit_id} (${(updates.changed_files || []).length} files changed).` : `Updated ${updatedCount} task(s) in repo "${repo}".`;
+  let summaryText = isCompleted ? `Updated ${updatedCount} task(s) in repo "${repo}". Task marked as completed with commit ${updates.commit_id} (${(updates.changed_files || []).length} files changed).` : `Updated ${updatedCount} task(s) in repo "${repo}".`;
+  summaryText += `${taskCodesStr}${fieldsStr}`;
   if (releasedClaims || expiredHandoffs) {
     summaryText += ` Auto-closed coordination: released ${releasedClaims} claim(s), expired ${expiredHandoffs} handoff(s).`;
   }
@@ -1233,18 +1358,22 @@ async function handleTaskDelete(args, storage) {
     throw new Error("Either 'id', 'ids', or 'task_code' must be provided for deletion");
   }
   const targetIds = resolvedIds;
+  const tasksToDelete = storage.tasks.getTasksByIds(targetIds);
+  const deletedCodes = tasksToDelete.map((t) => t.task_code);
   for (const targetId of targetIds) {
     storage.tasks.deleteTask(targetId);
   }
+  const deletedCodesStr = deletedCodes.length > 0 ? `: ${deletedCodes.join(", ")}` : "";
   return createMcpResponse(
     {
       success: true,
       id: id || void 0,
       ids: ids || void 0,
       repo,
-      deletedCount: targetIds.length
+      deletedCount: targetIds.length,
+      deletedCodes
     },
-    `Deleted ${targetIds.length} task(s) from repo "${repo}".`,
+    `Deleted ${targetIds.length} task(s) from repo "${repo}"${deletedCodesStr}.`,
     { includeSerializedStructuredContent: validated.structured }
   );
 }
@@ -1629,6 +1758,7 @@ async function handleMemoryDetail(args, storage) {
 
 // src/mcp/tools/standard.store.ts
 import { randomUUID as randomUUID3 } from "crypto";
+var UUID_REGEX4 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function generateShortCode2() {
   const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ0123456789";
   let code = "";
@@ -1637,15 +1767,21 @@ function generateShortCode2() {
   }
   return code;
 }
-async function handleStandardStore(params, db2, vectors2) {
-  const validated = StandardStoreSchema.parse(params);
-  const incomingVersion = validated.version || "1.0.0";
-  const incomingLanguage = validated.language ?? null;
-  const incomingStack = validated.stack ?? [];
+function resolveStandardParentId(value, db2) {
+  if (!value) return null;
+  if (UUID_REGEX4.test(value)) return value;
+  const standard = db2.standards.getByCode(value);
+  if (!standard) throw new Error(`parent_id: standard with code '${value}' not found`);
+  return standard.id;
+}
+async function storeSingleStandard(params, db2, vectors2) {
+  const incomingVersion = params.version || "1.0.0";
+  const incomingLanguage = params.language ?? null;
+  const incomingStack = params.stack ?? [];
   const conflict = db2.standards.checkConflicts(
-    validated.content,
+    params.content,
     incomingVersion,
-    validated.repo,
+    params.repo,
     incomingLanguage,
     incomingStack,
     0.82
@@ -1666,31 +1802,30 @@ async function handleStandardStore(params, db2, vectors2) {
         },
         instruction: "Use 'standard-update' on the existing ID to update it. To store a distinct variant, supply a different 'version', 'language', or non-overlapping 'stack'."
       },
-      `Rejected: conflicts with standard "${conflict.title}" (${conflict.id}). Update it via 'standard-update', or differentiate by version / language / stack.`,
-      { structuredContentPathHint: "conflicting_standard" }
+      `Rejected: conflicts with standard "${conflict.title}" (v${conflict.version}, ${conflict.language || "any"}) [${conflict.id.slice(0, 8)}...]. Update via 'standard-update', or differentiate by version / language / stack.`
     );
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const entry = {
     id: randomUUID3(),
     code: generateShortCode2(),
-    title: validated.name,
-    content: validated.content,
-    parent_id: validated.parent_id || null,
-    context: toContextSlug(validated.context || "general"),
-    version: validated.version || "1.0.0",
-    language: validated.language || null,
-    stack: validated.stack || [],
-    is_global: validated.is_global !== false,
-    repo: validated.repo || null,
-    tags: validated.tags || [],
-    metadata: validated.metadata,
+    title: params.name,
+    content: params.content,
+    parent_id: resolveStandardParentId(params.parent_id, db2),
+    context: toContextSlug(params.context || "general"),
+    version: params.version || "1.0.0",
+    language: params.language || null,
+    stack: params.stack || [],
+    is_global: params.is_global !== false,
+    repo: params.repo || null,
+    tags: params.tags || [],
+    metadata: params.metadata,
     created_at: now,
     updated_at: now,
     hit_count: 0,
     last_used_at: null,
-    agent: validated.agent || "unknown",
-    model: validated.model || "unknown"
+    agent: params.agent || "unknown",
+    model: params.model || "unknown"
   };
   db2.standards.insert(entry);
   try {
@@ -1698,13 +1833,6 @@ async function handleStandardStore(params, db2, vectors2) {
   } catch (error) {
     logger.warn("Failed to generate standard vector embedding", { error: String(error) });
   }
-  logger.info("[Tool] standard.store - saved coding standard", {
-    standardId: entry.id,
-    code: entry.code,
-    title: entry.title,
-    stack: entry.stack,
-    language: entry.language
-  });
   return createMcpResponse(
     {
       success: true,
@@ -1714,10 +1842,107 @@ async function handleStandardStore(params, db2, vectors2) {
     `Saved coding standard [${entry.code}]: ${entry.title}`,
     {
       structuredContentPathHint: "standard",
-      includeSerializedStructuredContent: true
+      includeSerializedStructuredContent: params.structured
     }
   );
 }
+async function handleStandardStore(params, db2, vectors2) {
+  const validated = StandardStoreSchema.parse(params);
+  if (validated.standards) {
+    const entries = [];
+    const storedCodes = [];
+    for (const std of validated.standards) {
+      const incomingVersion = std.version || "1.0.0";
+      const incomingLanguage = std.language ?? null;
+      const incomingStack = std.stack ?? [];
+      const conflict = db2.standards.checkConflicts(
+        std.content,
+        incomingVersion,
+        void 0,
+        incomingLanguage,
+        incomingStack,
+        0.82
+      );
+      if (conflict) {
+        return createMcpResponse(
+          {
+            success: false,
+            error: "STANDARD_CONFLICT",
+            message: `This standard's content is highly similar to an existing standard (ID: ${conflict.id}, similarity: ${(conflict.similarity * 100).toFixed(1)}%).`,
+            conflicting_standard: {
+              id: conflict.id,
+              title: conflict.title,
+              version: conflict.version,
+              language: conflict.language,
+              stack: conflict.stack,
+              content: conflict.content
+            },
+            instruction: "Use 'standard-update' on the existing ID to update it. To store a distinct variant, supply a different 'version', 'language', or non-overlapping 'stack'."
+          },
+          `Rejected: conflicts with standard "${conflict.title}" (v${conflict.version}, ${conflict.language || "any"}) [${conflict.id.slice(0, 8)}...]. Update via 'standard-update', or differentiate by version / language / stack.`
+        );
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const code = generateShortCode2();
+      entries.push({
+        id: randomUUID3(),
+        code,
+        title: std.name,
+        content: std.content,
+        parent_id: resolveStandardParentId(std.parent_id, db2),
+        context: toContextSlug(std.context || "general"),
+        version: std.version || "1.0.0",
+        language: std.language || null,
+        stack: std.stack || [],
+        is_global: std.is_global !== false,
+        repo: null,
+        tags: std.tags || [],
+        metadata: std.metadata,
+        created_at: now,
+        updated_at: now,
+        hit_count: 0,
+        last_used_at: null,
+        agent: std.agent || "unknown",
+        model: std.model || "unknown"
+      });
+      storedCodes.push(code);
+    }
+    db2.standards.bulkInsertStandards(entries);
+    for (const entry of entries) {
+      try {
+        await vectors2.upsert(entry.id, buildStandardVectorText(entry), "standard");
+      } catch (error) {
+        logger.warn("Failed to generate standard vector embedding", { error: String(error) });
+      }
+    }
+    const codesStr = storedCodes.length > 0 ? `: ${storedCodes.join(", ")}` : "";
+    return createMcpResponse(
+      { success: true, createdCount: validated.standards.length, codes: storedCodes },
+      `Saved ${validated.standards.length} coding standards${codesStr}.`,
+      { includeSerializedStructuredContent: validated.structured }
+    );
+  }
+  return storeSingleStandard(
+    {
+      name: validated.name,
+      content: validated.content,
+      parent_id: validated.parent_id,
+      context: validated.context,
+      version: validated.version,
+      language: validated.language,
+      stack: validated.stack,
+      repo: validated.repo,
+      is_global: validated.is_global,
+      tags: validated.tags,
+      metadata: validated.metadata,
+      agent: validated.agent,
+      model: validated.model,
+      structured: validated.structured
+    },
+    db2,
+    vectors2
+  );
+}
 
 // src/mcp/tools/standard.search.ts
 var HYBRID_WEIGHTS_STANDARD = {
@@ -1943,6 +2168,14 @@ async function handleStandardSearch(params, db2, vectors2) {
 }
 
 // src/mcp/tools/standard.update.ts
+var UUID_REGEX5 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function resolveStandardParentId2(value, db2) {
+  if (!value) return null;
+  if (UUID_REGEX5.test(value)) return value;
+  const standard = db2.standards.getByCode(value);
+  if (!standard) throw new Error(`parent_id: standard with code '${value}' not found`);
+  return standard.id;
+}
 async function handleStandardUpdate(params, db2, vectors2) {
   const validated = StandardUpdateSchema.parse(params);
   let resolvedId = validated.id;
@@ -1960,7 +2193,7 @@ async function handleStandardUpdate(params, db2, vectors2) {
   const updates = {};
   if (validated.name !== void 0) updates.title = validated.name;
   if (validated.content !== void 0) updates.content = validated.content;
-  if (validated.parent_id !== void 0) updates.parent_id = validated.parent_id;
+  if (validated.parent_id !== void 0) updates.parent_id = resolveStandardParentId2(validated.parent_id, db2);
   if (validated.context !== void 0) updates.context = validated.context;
   if (validated.version !== void 0) updates.version = validated.version;
   if (validated.language !== void 0) updates.language = validated.language;
@@ -1991,7 +2224,7 @@ async function handleStandardUpdate(params, db2, vectors2) {
       code: existing.code,
       updatedFields: Object.keys(updates)
     },
-    `Updated coding standard ${resolvedId}. Fields: ${Object.keys(updates).join(", ") || "none"}.`,
+    `Updated coding standard [${existing.code}] in repo "${existing.repo || "global"}". Fields: ${Object.keys(updates).join(", ") || "none"}.`,
     {
       structuredContentPathHint: "updatedFields",
       includeSerializedStructuredContent: true

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vheins/local-memory-mcp",
-	"version": "0.14.4",
+	"version": "0.14.6",
 	"description": "MCP Local Memory Service for coding copilot agents",
 	"mcpName": "io.github.vheins/local-memory-mcp",
 	"type": "module",