@vheins/local-memory-mcp 0.19.12 → 0.19.14

package/dist/{chunk-H7BLOZB6.js → chunk-3ZCTWRSA.js}

@@ -6690,7 +6690,7 @@ var MemoryStoreSchema = z3.object({
   memories: z3.array(SingleMemorySchema).min(1).optional()
 });
 var MemoryUpdateSchema = z3.object({
-  id: z3.string().uuid().optional(),
+  id: z3.string().optional(),
   code: z3.string().max(20).optional(),
   owner: z3.string().min(1),
   repo: z3.string().min(1).transform(normalizeRepo),
@@ -6730,7 +6730,7 @@ var MemorySearchSchema = z3.object({
   structured: z3.boolean().default(false)
 });
 var MemoryAcknowledgeSchema = z3.object({
-  memory_id: z3.string().uuid().optional(),
+  memory_id: z3.string().optional(),
   code: z3.string().max(20).optional(),
   owner: z3.string().min(1),
   repo: z3.string().min(1).transform(normalizeRepo),
@@ -6750,8 +6750,8 @@ var MemoryRecapSchema = z3.object({
 var MemoryDeleteSchema = z3.object({
   owner: z3.string().min(1),
   repo: z3.string().min(1).transform(normalizeRepo),
-  id: z3.string().uuid().optional(),
-  ids: z3.array(z3.string().uuid()).min(1).optional(),
+  id: z3.string().optional(),
+  ids: z3.array(z3.string()).min(1).optional(),
   code: z3.string().max(20).optional(),
   codes: z3.array(z3.string().max(20)).min(1).optional(),
   structured: z3.boolean().default(false)
@@ -6762,7 +6762,7 @@ var MemoryDeleteSchema = z3.object({
   }
 );
 var MemoryDetailSchema = z3.object({
-  id: z3.string().uuid().optional(),
+  id: z3.string().optional(),
   code: z3.string().max(20).optional(),
   owner: z3.string().min(1),
   repo: z3.string().min(1).transform(normalizeRepo),
@@ -6899,8 +6899,8 @@ var TaskCreateInteractiveSchema = SingleTaskCreateSchema.partial().extend({
 var TaskUpdateSchema = z4.object({
   owner: z4.string().min(1),
   repo: z4.string().min(1).transform(normalizeRepo),
-  id: z4.string().uuid().optional(),
-  ids: z4.array(z4.string().uuid()).min(1).optional(),
+  id: z4.string().optional(),
+  ids: z4.array(z4.string()).min(1).optional(),
   task_code: z4.string().optional(),
   task_codes: z4.array(z4.string().min(1)).min(1).optional(),
   phase: z4.string().optional(),
@@ -6926,7 +6926,7 @@ var TaskUpdateSchema = z4.object({
 }).refine(
   (data) => data.id !== void 0 || data.ids !== void 0 || data.task_code !== void 0 || data.task_codes !== void 0,
   {
-    message: "Either 'id' (UUID), 'ids' (array of UUIDs), 'task_code' (string code like PERF-1), or 'task_codes' (array of string codes) must be provided. Note: 'ids' expects UUID format, not task codes \u2014 use 'task_code'/'task_codes' for string identifiers."
+    message: "Either 'id' (UUID), 'ids' (array of UUIDs or codes), 'task_code' (string code like PERF-1), or 'task_codes' (array of string codes) must be provided."
   }
 ).refine((data) => Object.keys(data).length > 2, {
   message: "At least one field besides repo and id/ids must be provided for update"
@@ -6955,21 +6955,21 @@ var TaskSearchSchema = z4.object({
 var TaskDeleteSchema = z4.object({
   owner: z4.string().min(1),
   repo: z4.string().min(1).transform(normalizeRepo),
-  id: z4.string().uuid().optional(),
-  ids: z4.array(z4.string().uuid()).min(1).optional(),
+  id: z4.string().optional(),
+  ids: z4.array(z4.string()).min(1).optional(),
   task_code: z4.string().optional(),
   task_codes: z4.array(z4.string().min(1)).min(1).optional(),
   structured: z4.boolean().default(false)
 }).refine(
   (data) => data.id !== void 0 || data.ids !== void 0 || data.task_code !== void 0 || data.task_codes !== void 0,
   {
-    message: "Either 'id' (UUID), 'ids' (array of UUIDs), 'task_code' (string code like PERF-1), or 'task_codes' (array of string codes) must be provided. Note: 'ids' expects UUID format, not task codes \u2014 use 'task_code'/'task_codes' for string identifiers."
+    message: "Either 'id' (UUID), 'ids' (array of UUIDs or codes), 'task_code' (string code like PERF-1), or 'task_codes' (array of string codes) must be provided."
   }
 );
 var TaskGetSchema = z4.object({
   owner: z4.string().min(1),
   repo: z4.string().min(1).transform(normalizeRepo),
-  id: z4.string().uuid().optional(),
+  id: z4.string().optional(),
   task_code: z4.string().optional(),
   task_codes: z4.array(z4.string().min(1)).min(1).optional(),
   structured: z4.boolean().default(false)
@@ -6984,7 +6984,7 @@ var HandoffCreateSchema = z5.object({
   repo: z5.string().min(1, "repo is required \u2014 provide it explicitly or configure MCP workspace roots").transform(normalizeRepo),
   from_agent: z5.string().min(1),
   to_agent: z5.string().min(1).optional(),
-  task_id: z5.string().uuid().optional(),
+  task_id: z5.string().optional(),
   task_code: z5.string().optional(),
   summary: z5.string().min(1),
   context: z5.record(z5.string(), z5.unknown()).optional(),
@@ -7016,7 +7016,7 @@ var HandoffListSchema = z5.object({
 var TaskClaimSchema = z5.object({
   owner: z5.string().min(1, "owner is required \u2014 provide it explicitly or configure MCP workspace roots"),
   repo: z5.string().min(1, "repo is required \u2014 provide it explicitly or configure MCP workspace roots").transform(normalizeRepo),
-  task_id: z5.string().uuid().optional(),
+  task_id: z5.string().optional(),
   task_code: z5.string().optional(),
   agent: z5.string().min(1),
   role: z5.string().optional(),
@@ -7039,7 +7039,7 @@ var ClaimListSchema = z5.object({
 var ClaimReleaseSchema = z5.object({
   owner: z5.string().min(1, "owner is required \u2014 provide it explicitly or configure MCP workspace roots"),
   repo: z5.string().min(1, "repo is required \u2014 provide it explicitly or configure MCP workspace roots").transform(normalizeRepo),
-  task_id: z5.string().uuid().optional(),
+  task_id: z5.string().optional(),
   task_code: z5.string().optional(),
   agent: z5.string().min(1).optional(),
   structured: z5.boolean().default(false)
@@ -7078,7 +7078,7 @@ var StandardStoreSchema = z6.object({
   message: "repo is required for repo-specific standards"
 });
 var StandardUpdateSchema = z6.object({
-  id: z6.string().uuid().optional(),
+  id: z6.string().optional(),
   code: z6.string().max(20).optional(),
   name: z6.string().min(3).max(255).optional(),
   content: z6.string().min(10).optional(),
@@ -7120,8 +7120,8 @@ var StandardSearchSchema = z6.object({
 var StandardDeleteSchema = z6.object({
   owner: z6.string().min(1),
   repo: z6.string().min(1).transform(normalizeRepo),
-  id: z6.string().uuid().optional(),
-  ids: z6.array(z6.string().uuid()).min(1).optional(),
+  id: z6.string().optional(),
+  ids: z6.array(z6.string()).min(1).optional(),
   code: z6.string().max(20).optional(),
   codes: z6.array(z6.string().max(20)).min(1).optional(),
   structured: z6.boolean().default(false)
@@ -7132,7 +7132,7 @@ var StandardDeleteSchema = z6.object({
   }
 );
 var StandardDetailSchema = z6.object({
-  id: z6.string().uuid().optional(),
+  id: z6.string().optional(),
   code: z6.string().max(20).optional(),
   owner: z6.string().min(1),
   repo: z6.string().min(1).transform(normalizeRepo),
@@ -7215,6 +7215,9 @@ var KGBackfillSchema = z8.object({
   source: z8.enum(["memories", "standards", "both"]).optional().default("both")
 });
 
+// src/mcp/utils/uuid.ts
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
 // src/mcp/tools/handoff.manage.ts
 function buildHandoffListSummary(repo, count, status, fromAgent, toAgent) {
   const parts = [`Found ${count} handoff${count === 1 ? "" : "s"} in repo "${repo}".`];
@@ -7243,6 +7246,13 @@ async function handleHandoffCreate(args, storage) {
   const validated = HandoffCreateSchema.parse(args);
   const { owner, repo, from_agent, to_agent, task_id, task_code, summary, context, expires_at, structured } = validated;
   let resolvedTaskId = task_id ?? null;
+  if (resolvedTaskId && !UUID_REGEX.test(resolvedTaskId)) {
+    const task = storage.tasks.getTaskByCode(owner, repo, resolvedTaskId);
+    if (!task) {
+      throw new Error(`Task not found: ${resolvedTaskId} in repo ${repo}`);
+    }
+    resolvedTaskId = task.id;
+  }
   if (!resolvedTaskId && task_code) {
     const task = storage.tasks.getTaskByCode(owner, repo, task_code);
     if (!task) {
@@ -7361,6 +7371,13 @@ async function handleTaskClaim(args, storage) {
   const validated = TaskClaimSchema.parse(args);
   const { owner, repo, task_id, task_code, agent, role, metadata, structured } = validated;
   let taskId = task_id;
+  if (taskId && !UUID_REGEX.test(taskId)) {
+    const task2 = storage.tasks.getTaskByCode(owner, repo, taskId);
+    if (!task2) {
+      throw new Error(`Task not found: ${taskId} in repo ${repo}`);
+    }
+    taskId = task2.id;
+  }
   let resolvedTaskCode;
   let task;
   if (taskId) {
@@ -7466,6 +7483,13 @@ async function handleClaimRelease(args, storage) {
   const validated = ClaimReleaseSchema.parse(args);
   const { owner, repo, task_id, task_code, agent, structured } = validated;
   let resolvedTaskId = task_id;
+  if (resolvedTaskId && !UUID_REGEX.test(resolvedTaskId)) {
+    const task = storage.tasks.getTaskByCode(owner, repo, resolvedTaskId);
+    if (!task) {
+      throw new Error(`Task not found: ${resolvedTaskId} in repo ${repo}`);
+    }
+    resolvedTaskId = task.id;
+  }
   let resolvedTaskCode = task_code ?? null;
   if (resolvedTaskId) {
     const task = storage.tasks.getTaskById(resolvedTaskId);
@@ -7576,6 +7600,7 @@ export {
   DeleteRelationSchema,
   DeleteObservationSchema,
   KGBackfillSchema,
+  UUID_REGEX,
   handleHandoffCreate,
   handleHandoffList,
   handleHandoffUpdate,

package/dist/dashboard/server.js

@@ -15,7 +15,7 @@ import {
   handleTaskClaim,
   listResources,
   logger
-} from "../chunk-H7BLOZB6.js";
+} from "../chunk-3ZCTWRSA.js";
 
 // src/dashboard/server.ts
 import express from "express";

package/dist/mcp/server.js

@@ -34,6 +34,7 @@ import {
   TaskSearchSchema,
   TaskStatusSchema,
   TaskUpdateSchema,
+  UUID_REGEX,
   addLogSink,
   buildStandardVectorText,
   completePromptArgument,
@@ -61,7 +62,7 @@ import {
   parseRepoInput,
   rankCompletionValues,
   toContextSlug
-} from "../chunk-H7BLOZB6.js";
+} from "../chunk-3ZCTWRSA.js";
 
 // src/mcp/server.ts
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
@@ -74,8 +75,8 @@ import path from "path";
 import { fileURLToPath } from "url";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var pkgVersion = "0.1.0";
-if ("0.19.12") {
-  pkgVersion = "0.19.12";
+if ("0.19.14") {
+  pkgVersion = "0.19.14";
 } else {
   let searchDir = __dirname;
   for (let i = 0; i < 5; i++) {
@@ -422,7 +423,6 @@ async function saveExtractions(content, title, owner, repo, db2) {
 }
 
 // src/mcp/tools/memory.store.ts
-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);
@@ -657,14 +657,13 @@ async function handleMemoryStore(params, 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, owner, repo) {
   if (!value) return null;
-  if (UUID_REGEX2.test(value)) return value;
+  if (UUID_REGEX.test(value)) return value;
   const memory = db2.memories.getByCode(value, owner, repo);
   if (!memory) throw new Error(`supersedes: memory with code '${value}' not found`);
   return memory.id;
@@ -672,6 +671,11 @@ function resolveMemorySupersedes2(value, db2, owner, repo) {
 async function handleMemoryUpdate(params, db2, vectors2) {
   const validated = MemoryUpdateSchema.parse(params);
   let resolvedId = validated.id;
+  if (resolvedId && !UUID_REGEX.test(resolvedId)) {
+    const byCode = db2.memories.getByCode(resolvedId, validated.owner, validated.repo);
+    if (!byCode) throw new Error(`Memory not found: ${resolvedId}`);
+    resolvedId = byCode.id;
+  }
   if (!resolvedId && validated.code) {
     const byCode = db2.memories.getByCode(validated.code, validated.owner, validated.repo);
     if (!byCode) throw new Error(`Memory not found: ${validated.code}`);
@@ -1037,6 +1041,11 @@ function applyTimeFilter(memories, tunnel) {
 async function handleMemoryAcknowledge(params, db2) {
   const validated = MemoryAcknowledgeSchema.parse(params);
   let memoryId = validated.memory_id;
+  if (memoryId && !UUID_REGEX.test(memoryId)) {
+    const byCode = db2.memories.getByCode(memoryId, validated.owner, validated.repo);
+    if (!byCode) throw new Error(`Memory not found: ${memoryId}`);
+    memoryId = byCode.id;
+  }
   if (!memoryId && validated.code) {
     const byCode = db2.memories.getByCode(validated.code, validated.owner, validated.repo);
     if (!byCode) throw new Error(`Memory not found: ${validated.code}`);
@@ -1541,8 +1550,26 @@ async function handleMemoryDelete(params, db2, vectors2, onProgress) {
   const validated = MemoryDeleteSchema.parse(params);
   const { id, ids, code, codes, owner, repo, structured } = validated;
   const resolvedIds = [];
-  if (ids) resolvedIds.push(...ids);
-  if (id) resolvedIds.push(id);
+  if (ids) {
+    for (const item of ids) {
+      if (UUID_REGEX.test(item)) {
+        resolvedIds.push(item);
+      } else {
+        const entry = db2.memories.getByCode(item, owner, repo);
+        if (!entry) throw new Error(`Memory not found: ${item}`);
+        resolvedIds.push(entry.id);
+      }
+    }
+  }
+  if (id) {
+    if (!UUID_REGEX.test(id)) {
+      const entry = db2.memories.getByCode(id, owner, repo);
+      if (!entry) throw new Error(`Memory not found: ${id}`);
+      resolvedIds.push(entry.id);
+    } else {
+      resolvedIds.push(id);
+    }
+  }
   if (code) {
     const entry = db2.memories.getByCode(code, owner, repo);
     if (!entry) throw new Error(`Memory not found: ${code}`);
@@ -1573,7 +1600,7 @@ async function handleMemoryDelete(params, db2, vectors2, onProgress) {
       lastRepo = existing.scope.repo;
       deletedCodes.push(existing.code || existing.id);
       validIdsToDelete.push(targetId);
-    } else if (id) {
+    } else {
       throw new Error(`Memory not found: ${targetId}`);
     }
   }
@@ -1615,7 +1642,7 @@ async function handleMemoryDetail(args, storage) {
   const { id, code, owner, repo } = validated;
   let memory;
   if (id) {
-    memory = storage.memories.getById(id);
+    memory = UUID_REGEX.test(id) ? storage.memories.getById(id) : storage.memories.getByCode(id, owner, repo);
   } else if (code) {
     memory = storage.memories.getByCode(code, owner, repo);
   }
@@ -1645,10 +1672,9 @@ async function handleMemoryDetail(args, storage) {
 
 // src/mcp/tools/standard.store.ts
 import { randomUUID as randomUUID3 } from "crypto";
-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 resolveStandardParentId(value, db2, owner, repo) {
   if (!value) return null;
-  if (UUID_REGEX3.test(value)) return value;
+  if (UUID_REGEX.test(value)) return value;
   const standard = db2.standards.getByCode(value, owner, repo);
   if (!standard) throw new Error(`parent_id: standard with code '${value}' not found`);
   return standard.id;
@@ -2055,10 +2081,9 @@ async function handleStandardSearch(params, db2, vectors2) {
 }
 
 // src/mcp/tools/standard.update.ts
-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 resolveStandardParentId2(value, db2, owner, repo) {
   if (!value) return null;
-  if (UUID_REGEX4.test(value)) return value;
+  if (UUID_REGEX.test(value)) return value;
   const standard = db2.standards.getByCode(value, owner, repo);
   if (!standard) throw new Error(`parent_id: standard with code '${value}' not found`);
   return standard.id;
@@ -2066,6 +2091,11 @@ function resolveStandardParentId2(value, db2, owner, repo) {
 async function handleStandardUpdate(params, db2, vectors2) {
   const validated = StandardUpdateSchema.parse(params);
   let resolvedId = validated.id;
+  if (resolvedId && !UUID_REGEX.test(resolvedId)) {
+    const byCode = db2.standards.getByCode(resolvedId, validated.owner, validated.repo);
+    if (!byCode) throw new Error(`Coding standard not found: ${resolvedId}`);
+    resolvedId = byCode.id;
+  }
   if (!resolvedId && validated.code) {
     const byCode = db2.standards.getByCode(validated.code, validated.owner, validated.repo);
     if (!byCode) throw new Error(`Coding standard not found: ${validated.code}`);
@@ -2123,9 +2153,15 @@ async function handleStandardUpdate(params, db2, vectors2) {
 // src/mcp/tools/standard.detail.ts
 async function handleStandardDetail(args, storage) {
   const validated = StandardDetailSchema.parse(args);
-  const standard = validated.id ? storage.standards.getById(validated.id) : storage.standards.getByCode(validated.code, validated.owner, validated.repo);
+  const { id, code, owner, repo } = validated;
+  let standard;
+  if (id) {
+    standard = UUID_REGEX.test(id) ? storage.standards.getById(id) : storage.standards.getByCode(id, owner, repo);
+  } else if (code) {
+    standard = storage.standards.getByCode(code, owner, repo);
+  }
   if (!standard) {
-    const identifier = validated.id ?? validated.code;
+    const identifier = id ?? code;
     throw new Error(`Coding standard not found: ${identifier}`);
   }
   storage.standards.incrementHitCounts([standard.id]);
@@ -2159,8 +2195,26 @@ async function handleStandardDelete(params, db2, vectors2) {
   const validated = StandardDeleteSchema.parse(params);
   const { id, ids, code, codes, owner, repo, structured } = validated;
   const resolvedIds = [];
-  if (ids) resolvedIds.push(...ids);
-  if (id) resolvedIds.push(id);
+  if (ids) {
+    for (const item of ids) {
+      if (UUID_REGEX.test(item)) {
+        resolvedIds.push(item);
+      } else {
+        const entry = db2.standards.getByCode(item, owner, repo);
+        if (!entry) throw new Error(`Coding standard not found: ${item}`);
+        resolvedIds.push(entry.id);
+      }
+    }
+  }
+  if (id) {
+    if (!UUID_REGEX.test(id)) {
+      const entry = db2.standards.getByCode(id, owner, repo);
+      if (!entry) throw new Error(`Coding standard not found: ${id}`);
+      resolvedIds.push(entry.id);
+    } else {
+      resolvedIds.push(id);
+    }
+  }
   if (code) {
     const entry = db2.standards.getByCode(code, owner, repo);
     if (!entry) throw new Error(`Coding standard not found: ${code}`);
@@ -2188,7 +2242,7 @@ async function handleStandardDelete(params, db2, vectors2) {
       db2.standards.delete(targetId);
       await vectors2.remove(targetId, "standard");
       deletedCount++;
-    } else if (id) {
+    } else {
       throw new Error(`Coding standard not found: ${targetId}`);
     }
   }
@@ -2214,10 +2268,9 @@ async function handleStandardDelete(params, db2, vectors2) {
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/mcp/tools/task.helpers.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 resolveParentId(value, owner, repo, storage, localCodeMap) {
   if (!value) return null;
-  if (UUID_REGEX5.test(value)) return value;
+  if (UUID_REGEX.test(value)) return value;
   if (localCodeMap?.has(value)) return localCodeMap.get(value);
   const parent = storage.tasks.getTaskByCode(owner, repo, value);
   if (!parent) throw new Error(`parent_id: task with code '${value}' not found in repo '${repo}'`);
@@ -2225,7 +2278,7 @@ function resolveParentId(value, owner, repo, storage, localCodeMap) {
 }
 function resolveDependsOn(value, owner, repo, storage, localCodeMap) {
   if (!value) return null;
-  if (UUID_REGEX5.test(value)) return value;
+  if (UUID_REGEX.test(value)) return value;
   if (localCodeMap?.has(value)) return localCodeMap.get(value);
   const task = storage.tasks.getTaskByCode(owner, repo, value);
   if (!task) throw new Error(`depends_on: task with code '${value}' not found in repo '${repo}'`);
@@ -2583,12 +2636,29 @@ async function handleTaskUpdate(args, storage, vectors2) {
   const updateData = TaskUpdateSchema.parse(args);
   const { owner, repo, id, ids, comment, force, ...updates } = updateData;
   let resolvedId = id;
+  if (resolvedId && !UUID_REGEX.test(resolvedId)) {
+    const found = storage.tasks.getTaskByCode(owner, repo, resolvedId);
+    if (!found) throw new Error(`Task not found: ${resolvedId}`);
+    resolvedId = found.id;
+  }
   if (!resolvedId && !ids && updates.task_code) {
     const found = storage.tasks.getTaskByCode(owner, repo, updates.task_code);
     if (!found) throw new Error(`Task not found: ${updates.task_code}`);
     resolvedId = found.id;
   }
-  const targetIds = ids || (resolvedId ? [resolvedId] : []);
+  const resolvedIdsArray = [];
+  if (ids) {
+    for (const item of ids) {
+      if (UUID_REGEX.test(item)) {
+        resolvedIdsArray.push(item);
+      } else {
+        const task = storage.tasks.getTaskByCode(owner, repo, item);
+        if (!task) throw new Error(`Task not found: ${item}`);
+        resolvedIdsArray.push(task.id);
+      }
+    }
+  }
+  const targetIds = resolvedIdsArray.length > 0 ? resolvedIdsArray : resolvedId ? [resolvedId] : [];
   if (targetIds.length === 0) {
     throw new Error("Either 'id' or 'ids' must be provided for update");
   }
@@ -2731,8 +2801,26 @@ async function handleTaskDelete(args, storage) {
   const validated = TaskDeleteSchema.parse(args);
   const { owner, repo, id, ids, task_code } = validated;
   const resolvedIds = [];
-  if (ids) resolvedIds.push(...ids);
-  if (id) resolvedIds.push(id);
+  if (ids) {
+    for (const item of ids) {
+      if (UUID_REGEX.test(item)) {
+        resolvedIds.push(item);
+      } else {
+        const task = storage.tasks.getTaskByCode(owner, repo, item);
+        if (!task) throw new Error(`Task not found: ${item}`);
+        resolvedIds.push(task.id);
+      }
+    }
+  }
+  if (id) {
+    if (!UUID_REGEX.test(id)) {
+      const task = storage.tasks.getTaskByCode(owner, repo, id);
+      if (!task) throw new Error(`Task not found: ${id}`);
+      resolvedIds.push(task.id);
+    } else {
+      resolvedIds.push(id);
+    }
+  }
   if (task_code) {
     const task = storage.tasks.getTaskByCode(owner, repo, task_code);
     if (!task) throw new Error(`Task not found: ${task_code}`);
@@ -2768,7 +2856,7 @@ async function handleTaskGet(args, storage) {
   const { owner, repo, id, task_code, structured: isStructuredRequest } = validated;
   let task;
   if (id) {
-    task = storage.tasks.getTaskById(id);
+    task = UUID_REGEX.test(id) ? storage.tasks.getTaskById(id) : storage.tasks.getTaskByCode(owner, repo, id);
   } else if (task_code) {
     task = storage.tasks.getTaskByCode(owner, repo, task_code);
   } else {
@@ -3063,6 +3151,10 @@ async function handleDecisionLog(args, db2, vectors2) {
     tags,
     structured: validated.structured
   };
+  const conflict = await db2.memoryVectors.checkConflicts(formattedContent, owner, repo, "decision", vectors2, 0.55);
+  if (conflict) {
+    memoryStoreParams.supersedes = conflict.id;
+  }
   return handleMemoryStore(memoryStoreParams, db2, vectors2);
 }
 

package/dist/prompts/server/instructions.md

@@ -54,9 +54,41 @@ S2 | continue to task or respond | S1✅ | ready | —
 - Durable only (arch, patterns, decisions, fixes)
 - memory-acknowledge after code gen from memory
 - Global scope = cross-repo only; prefer repo-specific
-- decision-log = shortcut for storing decision-type memories (auto-sets type=decision, importance=4)
+- decision-log = shortcut for storing decision-type memories (auto-sets type=decision, importance=4, agent=current, model=current, scope=current)
 - session-summarize = archive session as task_archive memory (type=task_archive, importance=3)
 
+### memory-store required fields
+
+Every `memory-store` call MUST include these fields:
+
+| Field        | Type                                                                | Description                                                         |
+| :----------- | :------------------------------------------------------------------ | :------------------------------------------------------------------ |
+| `type`       | enum: `code_fact`, `decision`, `mistake`, `pattern`, `task_archive` | Memory category                                                     |
+| `title`      | string (3-255 chars)                                                | Concise title, no metadata                                          |
+| `content`    | string (min 10 chars)                                               | Body of the memory                                                  |
+| `importance` | number (1-5)                                                        | 1=low, 5=critical                                                   |
+| `agent`      | string                                                              | Identity of the calling agent (e.g., `explore`, `sentinel`, `main`) |
+| `model`      | string                                                              | Model identifier (e.g., `opencode-go/deepseek-v4-flash`)            |
+| `scope`      | object `{ owner, repo }`                                            | `owner`=GitHub org/username, `repo`=repo name                       |
+
+Example:
+
+```json
+{
+	"type": "code_fact",
+	"title": "Auth uses JWT",
+	"content": "Authentication system uses JWT tokens with 1h expiry.",
+	"importance": 3,
+	"agent": "explore",
+	"model": "opencode-go/deepseek-v4-flash",
+	"scope": { "owner": "vheins", "repo": "sentinel-agent" }
+}
+```
+
+### memory-update optional fields
+
+`memory-update` accepts the same fields as `memory-store` but all are optional (only provide the fields to change). Either `id` (UUID) or `code` (string) is required to identify the target memory.
+
 **Tasks**: task-list → task-claim(auto → in_progress) → task-update(completed)
 
 - Register via task-create before execution

package/package.json

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