@vheins/local-memory-mcp 0.13.1 → 0.14.0

package/dist/mcp/server.js

@@ -1,11 +1,6 @@
 #!/usr/bin/env node
 import {
   CAPABILITIES,
-  ClaimListSchema,
-  ClaimReleaseSchema,
-  HandoffCreateSchema,
-  HandoffListSchema,
-  HandoffUpdateSchema,
   LOG_LEVEL_VALUES,
   MCP_PROTOCOL_VERSION,
   MemoryAcknowledgeSchema,
@@ -25,18 +20,19 @@ import {
   StandardStoreSchema,
   StandardUpdateSchema,
   TOOL_DEFINITIONS,
-  TaskClaimSchema,
   TaskCreateInteractiveSchema,
   TaskCreateSchema,
   TaskDeleteSchema,
   TaskGetSchema,
   TaskListSchema,
+  TaskSearchSchema,
   TaskUpdateSchema,
   addLogSink,
   buildStandardVectorText,
   completePromptArgument,
   completeResourceArgument,
   createFileSink,
+  createMcpResponse,
   createSessionContext,
   decodeCursor,
   encodeCursor,
@@ -44,7 +40,14 @@ import {
   findContainingRoot,
   getFilesystemRoots,
   getLogLevel,
+  getPrimaryTextContent,
   getPrompt,
+  handleClaimList,
+  handleClaimRelease,
+  handleHandoffCreate,
+  handleHandoffList,
+  handleHandoffUpdate,
+  handleTaskClaim,
   inferRepoFromSession,
   isPathWithinRoots,
   listPrompts,
@@ -57,7 +60,7 @@ import {
   toContextSlug,
   updateSessionFromInitialize,
   updateSessionRoots
-} from "../chunk-UZWV2DYU.js";
+} from "../chunk-GXQCHTXK.js";
 
 // src/mcp/server.ts
 import readline from "readline";
@@ -186,111 +189,6 @@ function invalidCompletionParams(message) {
 
 // src/mcp/tools/memory.store.ts
 import { randomUUID } from "crypto";
-
-// src/mcp/utils/mcp-response.ts
-import { z } from "zod";
-var McpAnnotationsSchema = z.object({
-  audience: z.array(z.enum(["user", "assistant"])).optional(),
-  priority: z.number().min(0).max(1).optional(),
-  lastModified: z.string().optional()
-}).strict().optional();
-var McpContentSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("text"),
-    text: z.string(),
-    annotations: McpAnnotationsSchema
-  }),
-  z.object({
-    type: z.literal("image"),
-    data: z.string(),
-    mimeType: z.string(),
-    annotations: McpAnnotationsSchema
-  }),
-  z.object({
-    type: z.literal("resource"),
-    resource: z.object({
-      uri: z.string(),
-      mimeType: z.string().optional(),
-      text: z.string().optional(),
-      annotations: McpAnnotationsSchema
-    })
-  })
-]);
-function createMcpResponse(data, summary, options) {
-  const { structuredContentPathHint, contentSummary, includeSerializedStructuredContent = false } = options || {};
-  void includeSerializedStructuredContent;
-  let finalData = data;
-  if (data && typeof data === "object") {
-    const cloned = JSON.parse(JSON.stringify(data));
-    finalData = cloned;
-    const arrayKeys = ["results", "tasks", "memories", "items"];
-    let foundArray = false;
-    for (const key of arrayKeys) {
-      const value = cloned[key];
-      if (Array.isArray(value)) {
-        cloned[key] = value.map(
-          (item) => pruneMetadata(item)
-        );
-        foundArray = true;
-      }
-    }
-    if (Array.isArray(cloned)) {
-      finalData = cloned.map((item) => pruneMetadata(item));
-    } else if (!foundArray) {
-      finalData = pruneMetadata(cloned);
-    }
-  }
-  const content = [];
-  if (contentSummary && contentSummary.trim().length > 0) {
-    content.push({
-      type: "text",
-      text: contentSummary.trim()
-    });
-  } else if (summary && summary.trim().length > 0) {
-    const pointerText = structuredContentPathHint ? `Read structuredContent.${structuredContentPathHint} for details.` : `Read structuredContent for machine-readable results.`;
-    content.push({
-      type: "text",
-      text: `${summary.trim()} ${pointerText}`
-    });
-  }
-  const response = {
-    structuredContent: finalData,
-    isError: false
-  };
-  if (includeSerializedStructuredContent === false) {
-    delete response.structuredContent;
-  }
-  response.content = content;
-  return response;
-}
-function pruneMetadata(item) {
-  if (!item || typeof item !== "object") return item;
-  const pruned = { ...item };
-  const toRemove = [
-    "hit_count",
-    "recall_count",
-    "last_used_at",
-    "expires_at",
-    "agent",
-    "role",
-    "model",
-    "recall_rate",
-    "vector_version",
-    "similarity"
-    // Similarity is useful but adds noise if many results
-  ];
-  for (const field of toRemove) {
-    delete pruned[field];
-  }
-  return pruned;
-}
-function getPrimaryTextContent(response) {
-  if (!Array.isArray(response.content)) return "";
-  const textItem = response.content.find((item) => item.type === "text");
-  return textItem?.type === "text" ? textItem.text : "";
-}
-
-// src/mcp/tools/memory.store.ts
 function hasMetadataLikeTitle(title) {
   const normalized = title.trim();
   return /^\[[^\]]{0,200}(agent:|role:|model:|\d{4}-\d{2}-\d{2}|source_)[^\]]*\]/i.test(normalized);
@@ -311,9 +209,10 @@ async function handleMemoryStore(params, db2, vectors2) {
     );
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const expires_at = validated.ttlDays != null ? new Date(Date.now() + validated.ttlDays * 864e5).toISOString() : null;
+  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 conflict = await db2.memories.checkConflicts(
+    const conflict = await db2.memoryVectors.checkConflicts(
       validated.content,
       validated.scope.repo,
       validated.type,
@@ -416,9 +315,17 @@ function hasMetadataLikeTitle2(title) {
 }
 async function handleMemoryUpdate(params, db2, vectors2) {
   const validated = MemoryUpdateSchema.parse(params);
-  const existing = db2.memories.getById(validated.id);
+  let resolvedId = validated.id;
+  if (!resolvedId && validated.code) {
+    const byCode = db2.memories.getByCode(validated.code);
+    if (!byCode) throw new Error(`Memory not found: ${validated.code}`);
+    resolvedId = byCode.id;
+  } else if (!resolvedId) {
+    throw new Error("Either id or code must be provided");
+  }
+  const existing = db2.memories.getById(resolvedId);
   if (!existing) {
-    throw new Error(`Memory not found: ${validated.id}`);
+    throw new Error(`Memory not found: ${resolvedId}`);
   }
   const repoFilter = params?.repo || params?.scope?.repo;
   if (repoFilter && repoFilter !== existing.scope.repo) {
@@ -444,20 +351,21 @@ async function handleMemoryUpdate(params, db2, vectors2) {
   if (validated.metadata !== void 0) updates.metadata = validated.metadata;
   if (validated.is_global !== void 0) updates.is_global = validated.is_global;
   if (validated.completed_at !== void 0) updates.completed_at = validated.completed_at;
-  db2.memories.update(validated.id, updates);
+  db2.memories.update(resolvedId, updates);
   if (validated.content !== void 0) {
-    await vectors2.upsert(validated.id, validated.content);
+    await vectors2.upsert(resolvedId, validated.content);
   }
-  db2.actions.logAction("update", existing.scope.repo, { memoryId: validated.id, resultCount: 1 });
-  logger.info("[Tool] memory.update", { repo: existing.scope.repo, id: validated.id, fields: Object.keys(updates) });
+  db2.actions.logAction("update", existing.scope.repo, { memoryId: resolvedId, resultCount: 1 });
+  logger.info("[Tool] memory.update", { repo: existing.scope.repo, id: resolvedId, fields: Object.keys(updates) });
   return createMcpResponse(
     {
       success: true,
-      id: validated.id,
+      id: resolvedId,
+      code: existing.code,
       repo: existing.scope.repo,
       updatedFields: Object.keys(updates)
     },
-    `Updated memory ${validated.id} in repo "${existing.scope.repo}". Fields: ${Object.keys(updates).join(", ") || "none"}.`,
+    `Updated memory ${resolvedId} in repo "${existing.scope.repo}". Fields: ${Object.keys(updates).join(", ") || "none"}.`,
     {
       structuredContentPathHint: "updatedFields",
       includeSerializedStructuredContent: validated.structured
@@ -499,7 +407,7 @@ async function handleMemorySearch(params, db2, vectors2) {
   const validated = MemorySearchSchema.parse(params);
   const searchQuery = expandQuery(validated.query, validated.prompt);
   const fetchLimit = (validated.offset + validated.limit) * 3;
-  const similarityResults = db2.memories.searchBySimilarity(
+  const similarityResults = db2.memoryVectors.searchBySimilarity(
     searchQuery,
     validated.repo,
     fetchLimit,
@@ -815,7 +723,7 @@ function deriveTaskStatusTimestamps(status, now, existingTask) {
 async function archiveTaskToMemory(taskId, repo, storage, vectors2) {
   const task = storage.tasks.getTaskById(taskId);
   if (!task) return;
-  const comments = storage.tasks.getTaskCommentsByTaskId(taskId);
+  const comments = storage.taskComments.getTaskCommentsByTaskId(taskId);
   let content = `Task: [${task.task_code}] ${task.title}
 `;
   content += `Phase: ${task.phase}
@@ -931,7 +839,7 @@ async function handleTaskCreate(args, storage) {
     const createdTasks = [];
     const now2 = (/* @__PURE__ */ new Date()).toISOString();
     const codesInRequest = /* @__PURE__ */ new Set();
-    const initialStats = storage.tasks.getTaskStats(repo);
+    const initialStats = storage.taskStats.getTaskStats(repo);
     let pendingInRequestCount = 0;
     for (const taskData of bulkTasks) {
       if (codesInRequest.has(taskData.task_code)) {
@@ -979,6 +887,8 @@ async function handleTaskCreate(args, storage) {
         canceled_at: statusTimestamps2.canceled_at,
         est_tokens: taskData.est_tokens ?? 0,
         tags,
+        commit_id: null,
+        changed_files: [],
         metadata: taskData.metadata || {},
         parent_id: resolveParentId(taskData.parent_id, repo, storage),
         depends_on: taskData.depends_on || null
@@ -1021,9 +931,11 @@ async function handleTaskCreate(args, storage) {
     throw new Error("New tasks must be created with status 'backlog' or 'pending'.");
   }
   if (status === "pending") {
-    const stats = storage.tasks.getTaskStats(repo);
+    const stats = storage.taskStats.getTaskStats(repo);
     if (stats.todo >= 10) {
-      throw new Error(`Cannot create task as 'pending'. Maximum of 10 pending tasks reached. Please use status 'backlog' for new tasks instead.`);
+      throw new Error(
+        `Cannot create task as 'pending'. Maximum of 10 pending tasks reached. Please use status 'backlog' for new tasks instead.`
+      );
     }
   }
   const taskId = randomUUID2();
@@ -1053,6 +965,8 @@ async function handleTaskCreate(args, storage) {
     canceled_at: statusTimestamps.canceled_at,
     est_tokens: est_tokens ?? 0,
     tags: finalTags,
+    commit_id: null,
+    changed_files: [],
     metadata: metadata || {},
     parent_id: resolveParentId(parent_id, repo, storage),
     depends_on: depends_on || null
@@ -1246,7 +1160,7 @@ async function handleTaskUpdate(args, storage, vectors2) {
       finalUpdates.in_progress_at = now;
     storage.tasks.updateTask(targetId, finalUpdates);
     if (comment !== void 0 || isStatusChanging) {
-      storage.tasks.insertTaskComment({
+      storage.taskComments.insertTaskComment({
         id: randomUUID2(),
         task_id: targetId,
         repo,
@@ -1306,11 +1220,19 @@ async function handleTaskUpdate(args, storage, vectors2) {
 }
 async function handleTaskDelete(args, storage) {
   const validated = TaskDeleteSchema.parse(args);
-  const { repo, id, ids } = validated;
-  const targetIds = ids || (id ? [id] : []);
-  if (targetIds.length === 0) {
-    throw new Error("Either 'id' or 'ids' must be provided for deletion");
+  const { repo, id, ids, task_code } = validated;
+  const resolvedIds = [];
+  if (ids) resolvedIds.push(...ids);
+  if (id) resolvedIds.push(id);
+  if (task_code) {
+    const task = storage.tasks.getTaskByCode(repo, task_code);
+    if (!task) throw new Error(`Task not found: ${task_code}`);
+    resolvedIds.push(task.id);
+  }
+  if (resolvedIds.length === 0) {
+    throw new Error("Either 'id', 'ids', or 'task_code' must be provided for deletion");
   }
+  const targetIds = resolvedIds;
   for (const targetId of targetIds) {
     storage.tasks.deleteTask(targetId);
   }
@@ -1561,31 +1483,54 @@ async function executeSamplingTool(toolName, rawInput, db2, vectors2) {
 // src/mcp/tools/memory.delete.ts
 async function handleMemoryDelete(params, db2, vectors2, onProgress) {
   const validated = MemoryDeleteSchema.parse(params);
-  const { id, ids, repo, structured } = validated;
-  const targetIds = ids || (id ? [id] : []);
-  if (targetIds.length === 0) {
-    throw new Error("Either 'id' or 'ids' must be provided for deletion");
-  }
+  const { id, ids, code, codes, repo, structured } = validated;
+  const resolvedIds = [];
+  if (ids) resolvedIds.push(...ids);
+  if (id) resolvedIds.push(id);
+  if (code) {
+    const entry = db2.memories.getByCode(code);
+    if (!entry) throw new Error(`Memory not found: ${code}`);
+    resolvedIds.push(entry.id);
+  }
+  if (codes) {
+    for (const c of codes) {
+      const entry = db2.memories.getByCode(c);
+      if (!entry) throw new Error(`Memory not found: ${c}`);
+      resolvedIds.push(entry.id);
+    }
+  }
+  if (resolvedIds.length === 0) {
+    throw new Error("Either 'id', 'ids', 'code', or 'codes' must be provided for deletion");
+  }
+  const targetIds = resolvedIds;
   let deletedCount = 0;
   const deletedCodes = [];
   let lastRepo = repo || "unknown";
   const total = targetIds.length;
   let progress = 0;
+  const existingMemories = db2.memories.getByIds(targetIds);
+  const existingMap = new Map(existingMemories.map((m) => [m.id, m]));
+  const validIdsToDelete = [];
   for (const targetId of targetIds) {
-    if (onProgress) {
-      onProgress(progress, total);
-    }
-    const existing = db2.memories.getById(targetId);
+    const existing = existingMap.get(targetId);
     if (existing) {
       lastRepo = existing.scope.repo;
       deletedCodes.push(existing.code || existing.id);
-      db2.memories.delete(targetId);
-      await vectors2.remove(targetId);
-      deletedCount++;
+      validIdsToDelete.push(targetId);
     } else if (id) {
       throw new Error(`Memory not found: ${targetId}`);
     }
-    progress++;
+  }
+  if (validIdsToDelete.length > 0) {
+    db2.memoryArchives.bulkDeleteMemories(validIdsToDelete);
+    for (const validId of validIdsToDelete) {
+      if (onProgress) {
+        onProgress(progress, total);
+      }
+      await vectors2.remove(validId);
+      progress++;
+    }
+    deletedCount = validIdsToDelete.length;
   }
   if (onProgress) {
     onProgress(progress, total);
@@ -1611,9 +1556,17 @@ async function handleMemoryDelete(params, db2, vectors2, onProgress) {
 // src/mcp/tools/memory.acknowledge.ts
 async function handleMemoryAcknowledge(params, db2) {
   const validated = MemoryAcknowledgeSchema.parse(params);
-  const memory = db2.memories.getById(validated.memory_id);
+  let memoryId = validated.memory_id;
+  if (!memoryId && validated.code) {
+    const byCode = db2.memories.getByCode(validated.code);
+    if (!byCode) throw new Error(`Memory not found: ${validated.code}`);
+    memoryId = byCode.id;
+  } else if (!memoryId) {
+    throw new Error("Either memory_id or code must be provided");
+  }
+  const memory = db2.memories.getById(memoryId);
   if (!memory) {
-    throw new Error(`Memory with ID ${validated.memory_id} not found.`);
+    throw new Error(`Memory with ID ${memoryId} not found.`);
   }
   if (validated.status === "used") {
     db2.memories.incrementRecallCount(memory.id);
@@ -1674,266 +1627,6 @@ async function handleMemoryDetail(args, storage) {
   });
 }
 
-// src/mcp/tools/handoff.manage.ts
-function buildHandoffListSummary(repo, count, status, fromAgent, toAgent) {
-  const parts = [`Found ${count} handoff${count === 1 ? "" : "s"} in repo "${repo}".`];
-  if (status) {
-    parts.push(`Status filter: ${status}.`);
-  }
-  if (fromAgent) {
-    parts.push(`From agent: ${fromAgent}.`);
-  }
-  if (toAgent) {
-    parts.push(`To agent: ${toAgent}.`);
-  }
-  return parts.join("\n");
-}
-function buildClaimListSummary(repo, count, agent, activeOnly) {
-  const parts = [`Found ${count} claim${count === 1 ? "" : "s"} in repo "${repo}".`];
-  if (agent) {
-    parts.push(`Agent filter: ${agent}.`);
-  }
-  if (activeOnly) {
-    parts.push("Showing active claims only.");
-  }
-  return parts.join("\n");
-}
-async function handleHandoffCreate(args, storage) {
-  const validated = HandoffCreateSchema.parse(args);
-  const { repo, from_agent, to_agent, task_id, task_code, summary, context, expires_at, structured } = validated;
-  let resolvedTaskId = task_id ?? null;
-  if (!resolvedTaskId && task_code) {
-    const task = storage.tasks.getTaskByCode(repo, task_code);
-    if (!task) {
-      throw new Error(`Task not found: ${task_code} in repo ${repo}`);
-    }
-    resolvedTaskId = task.id;
-  }
-  const handoff = storage.handoffs.createHandoff({
-    repo,
-    from_agent,
-    to_agent,
-    task_id: resolvedTaskId,
-    summary,
-    context,
-    expires_at
-  });
-  const contentSummary = [
-    `Created handoff ${handoff.id}.`,
-    `Repo: ${handoff.repo}`,
-    `From: ${handoff.from_agent}`,
-    `To: ${handoff.to_agent || "unassigned"}`,
-    `Status: ${handoff.status}`,
-    `Task ID: ${handoff.task_id || "-"}`,
-    `Summary: ${handoff.summary}`
-  ].join("\n");
-  return createMcpResponse(handoff, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-async function handleHandoffList(args, storage) {
-  const validated = HandoffListSchema.parse(args);
-  const { repo, status, from_agent, to_agent, limit, offset, structured } = validated;
-  const handoffs = storage.handoffs.listHandoffs({
-    repo,
-    status,
-    from_agent,
-    to_agent,
-    limit,
-    offset
-  });
-  const COLUMNS = [
-    "id",
-    "from_agent",
-    "to_agent",
-    "task_id",
-    "task_code",
-    "status",
-    "created_at",
-    "updated_at",
-    "expires_at",
-    "summary",
-    "context"
-  ];
-  const rows = handoffs.map((handoff) => [
-    handoff.id,
-    handoff.from_agent,
-    handoff.to_agent,
-    handoff.task_id,
-    handoff.task_code ?? null,
-    handoff.status,
-    handoff.created_at,
-    handoff.updated_at,
-    handoff.expires_at,
-    handoff.summary,
-    handoff.context
-  ]);
-  const structuredData = {
-    schema: "handoff-list",
-    handoffs: {
-      columns: [...COLUMNS],
-      rows
-    },
-    count: rows.length,
-    offset
-  };
-  const contentSummary = buildHandoffListSummary(repo, rows.length, status, from_agent, to_agent);
-  return createMcpResponse(structuredData, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-async function handleHandoffUpdate(args, storage) {
-  const validated = HandoffUpdateSchema.parse(args);
-  const { id, status, structured } = validated;
-  const existing = storage.handoffs.getHandoffById(id);
-  if (!existing) {
-    throw new Error(`Handoff not found: ${id}`);
-  }
-  const success = storage.handoffs.updateHandoffStatus(id, status);
-  if (!success) {
-    throw new Error(`Failed to update handoff: ${id}`);
-  }
-  const updated = storage.handoffs.getHandoffById(id);
-  const result = {
-    success,
-    id,
-    status,
-    handoff: updated
-  };
-  const contentSummary = [`Updated handoff ${id}.`, `Status: ${status}`].join("\n");
-  return createMcpResponse(result, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-async function handleTaskClaim(args, storage) {
-  const validated = TaskClaimSchema.parse(args);
-  const { repo, task_id, task_code, agent, role, metadata, structured } = validated;
-  let taskId = task_id;
-  let resolvedTaskCode;
-  if (taskId) {
-    const task = storage.tasks.getTaskById(taskId);
-    if (!task || task.repo !== repo) {
-      throw new Error(`Task not found: ${taskId} in repo ${repo}`);
-    }
-    resolvedTaskCode = task.task_code;
-  } else if (task_code) {
-    const task = storage.tasks.getTaskByCode(repo, task_code);
-    if (!task) {
-      throw new Error(`Task not found: ${task_code} in repo ${repo}`);
-    }
-    taskId = task.id;
-    resolvedTaskCode = task.task_code;
-  } else {
-    throw new Error("Either task_id or task_code must be provided");
-  }
-  const claim = storage.handoffs.claimTask({
-    repo,
-    task_id: taskId,
-    agent,
-    role,
-    metadata
-  });
-  const responseData = {
-    ...claim,
-    task_code: resolvedTaskCode
-  };
-  const contentSummary = [
-    `Claimed task ${resolvedTaskCode || claim.task_id}.`,
-    `Repo: ${claim.repo}`,
-    `Task ID: ${claim.task_id}`,
-    `Agent: ${claim.agent}`,
-    `Role: ${claim.role}`,
-    `Claimed At: ${claim.claimed_at}`
-  ].join("\n");
-  const response = createMcpResponse(responseData, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-  if (structured) {
-    response.structuredContent = responseData;
-  }
-  return response;
-}
-async function handleClaimList(args, storage) {
-  const validated = ClaimListSchema.parse(args);
-  const { repo, agent, active_only, limit, offset, structured } = validated;
-  const claims = storage.handoffs.listClaims({
-    repo,
-    agent,
-    active_only,
-    limit,
-    offset
-  });
-  const COLUMNS = ["id", "task_id", "task_code", "agent", "role", "claimed_at", "released_at", "metadata"];
-  const rows = claims.map((claim) => [
-    claim.id,
-    claim.task_id,
-    claim.task_code ?? null,
-    claim.agent,
-    claim.role,
-    claim.claimed_at,
-    claim.released_at,
-    claim.metadata
-  ]);
-  const structuredData = {
-    schema: "claim-list",
-    claims: {
-      columns: [...COLUMNS],
-      rows
-    },
-    count: rows.length,
-    offset
-  };
-  const contentSummary = buildClaimListSummary(repo, rows.length, agent, active_only);
-  return createMcpResponse(structuredData, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-async function handleClaimRelease(args, storage) {
-  const validated = ClaimReleaseSchema.parse(args);
-  const { repo, task_id, task_code, agent, structured } = validated;
-  let resolvedTaskId = task_id;
-  let resolvedTaskCode = task_code ?? null;
-  if (resolvedTaskId) {
-    const task = storage.tasks.getTaskById(resolvedTaskId);
-    if (!task || task.repo !== repo) {
-      throw new Error(`Task not found: ${resolvedTaskId} in repo ${repo}`);
-    }
-    resolvedTaskCode = task.task_code;
-  } else if (task_code) {
-    const task = storage.tasks.getTaskByCode(repo, task_code);
-    if (!task) {
-      throw new Error(`Task not found: ${task_code} in repo ${repo}`);
-    }
-    resolvedTaskId = task.id;
-    resolvedTaskCode = task.task_code;
-  }
-  const success = storage.handoffs.releaseClaim(resolvedTaskId, agent);
-  if (!success) {
-    throw new Error(`No active claim found for task ${resolvedTaskCode || resolvedTaskId}`);
-  }
-  const result = {
-    success,
-    repo,
-    task_id: resolvedTaskId,
-    task_code: resolvedTaskCode,
-    agent: agent ?? null
-  };
-  const contentSummary = [
-    `Released claim for task ${resolvedTaskCode || resolvedTaskId}.`,
-    `Repo: ${repo}`,
-    agent ? `Agent: ${agent}` : "Agent: any active claimant"
-  ].join("\n");
-  return createMcpResponse(result, contentSummary, {
-    contentSummary,
-    includeSerializedStructuredContent: structured
-  });
-}
-
 // src/mcp/tools/standard.store.ts
 import { randomUUID as randomUUID3 } from "crypto";
 function generateShortCode2() {
@@ -2252,9 +1945,17 @@ async function handleStandardSearch(params, db2, vectors2) {
 // src/mcp/tools/standard.update.ts
 async function handleStandardUpdate(params, db2, vectors2) {
   const validated = StandardUpdateSchema.parse(params);
-  const existing = db2.standards.getById(validated.id);
+  let resolvedId = validated.id;
+  if (!resolvedId && validated.code) {
+    const byCode = db2.standards.getByCode(validated.code);
+    if (!byCode) throw new Error(`Coding standard not found: ${validated.code}`);
+    resolvedId = byCode.id;
+  } else if (!resolvedId) {
+    throw new Error("Either id or code must be provided");
+  }
+  const existing = db2.standards.getById(resolvedId);
   if (!existing) {
-    throw new Error(`Coding standard not found: ${validated.id}`);
+    throw new Error(`Coding standard not found: ${resolvedId}`);
   }
   const updates = {};
   if (validated.name !== void 0) updates.title = validated.name;
@@ -2270,26 +1971,27 @@ async function handleStandardUpdate(params, db2, vectors2) {
   if (validated.metadata !== void 0) updates.metadata = validated.metadata;
   if (validated.agent !== void 0) updates.agent = validated.agent;
   if (validated.model !== void 0) updates.model = validated.model;
-  db2.standards.update(validated.id, updates);
+  db2.standards.update(resolvedId, updates);
   const merged = {
     ...existing,
     ...updates,
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   if (validated.name !== void 0 || validated.content !== void 0 || validated.context !== void 0 || validated.version !== void 0 || validated.language !== void 0 || validated.stack !== void 0 || validated.tags !== void 0 || validated.metadata !== void 0) {
-    await vectors2.upsert(validated.id, buildStandardVectorText(merged), "standard");
+    await vectors2.upsert(resolvedId, buildStandardVectorText(merged), "standard");
   }
   logger.info("[Tool] standard.update - updated coding standard", {
-    standardId: validated.id,
+    standardId: resolvedId,
     fields: Object.keys(updates)
   });
   return createMcpResponse(
     {
       success: true,
-      id: validated.id,
+      id: resolvedId,
+      code: existing.code,
       updatedFields: Object.keys(updates)
     },
-    `Updated coding standard ${validated.id}. Fields: ${Object.keys(updates).join(", ") || "none"}.`,
+    `Updated coding standard ${resolvedId}. Fields: ${Object.keys(updates).join(", ") || "none"}.`,
     {
       structuredContentPathHint: "updatedFields",
       includeSerializedStructuredContent: true
@@ -2334,11 +2036,26 @@ async function handleStandardDetail(args, storage) {
 // src/mcp/tools/standard.delete.ts
 async function handleStandardDelete(params, db2, vectors2) {
   const validated = StandardDeleteSchema.parse(params);
-  const { id, ids, repo, structured } = validated;
-  const targetIds = ids || (id ? [id] : []);
-  if (targetIds.length === 0) {
-    throw new Error("Either 'id' or 'ids' must be provided for deletion");
-  }
+  const { id, ids, code, codes, repo, structured } = validated;
+  const resolvedIds = [];
+  if (ids) resolvedIds.push(...ids);
+  if (id) resolvedIds.push(id);
+  if (code) {
+    const entry = db2.standards.getByCode(code);
+    if (!entry) throw new Error(`Coding standard not found: ${code}`);
+    resolvedIds.push(entry.id);
+  }
+  if (codes) {
+    for (const c of codes) {
+      const entry = db2.standards.getByCode(c);
+      if (!entry) throw new Error(`Coding standard not found: ${c}`);
+      resolvedIds.push(entry.id);
+    }
+  }
+  if (resolvedIds.length === 0) {
+    throw new Error("Either 'id', 'ids', 'code', or 'codes' must be provided for deletion");
+  }
+  const targetIds = resolvedIds;
   let deletedCount = 0;
   const deletedTitles = [];
   let lastRepo = repo || "unknown";
@@ -2387,7 +2104,7 @@ async function handleTaskGet(args, storage) {
   if (!task) {
     throw new Error(`Task not found: ${id || task_code} in repo ${repo}`);
   }
-  const comments = storage.tasks.getTaskCommentsByTaskId(task.id);
+  const comments = storage.taskComments.getTaskCommentsByTaskId(task.id);
   let contentSummary;
   if (!isStructuredRequest) {
     const lines = [
@@ -2424,6 +2141,62 @@ async function handleTaskGet(args, storage) {
   });
 }
 
+// src/mcp/tools/task.search.ts
+async function handleTaskSearch(args, storage) {
+  const validated = TaskSearchSchema.parse(args);
+  const { repo, query, status, limit, offset, structured: isStructuredRequest = false, phase, priority } = validated;
+  let tasks;
+  if (status) {
+    const statuses = status.split(",").map((s) => s.trim()).filter(Boolean);
+    if (statuses.length > 1) {
+      tasks = storage.tasks.getTasksByMultipleStatuses(repo, statuses, void 0, void 0, query);
+    } else {
+      tasks = storage.tasks.getTasksByRepo(repo, status, void 0, void 0, query);
+    }
+  } else {
+    tasks = storage.tasks.getTasksByRepo(repo, void 0, void 0, void 0, query);
+  }
+  if (phase) {
+    const phaseLower = phase.toLowerCase();
+    tasks = tasks.filter((t) => t.phase && t.phase.toLowerCase() === phaseLower);
+  }
+  if (priority !== void 0) {
+    tasks = tasks.filter((t) => t.priority === priority);
+  }
+  const total = tasks.length;
+  const paginated = tasks.slice(offset, offset + limit);
+  const COLUMNS = ["id", "task_code", "title", "status", "priority", "updated_at", "phase"];
+  const rows = paginated.map((t) => [t.id, t.task_code, t.title, t.status, t.priority, t.updated_at, t.phase]);
+  const structuredData = {
+    schema: "task-search",
+    query,
+    count: paginated.length,
+    total,
+    offset,
+    limit,
+    results: {
+      columns: [...COLUMNS],
+      rows
+    }
+  };
+  let contentSummary;
+  if (!isStructuredRequest) {
+    contentSummary = paginated.length > 0 ? `Found ${total} tasks matching "${query}" in repo "${repo}". Use task-detail to fetch full task content.` : `No tasks found for "${query}" in repo "${repo}".`;
+  }
+  logger.info("[Tool] task.search", {
+    repo,
+    query,
+    total,
+    offset,
+    returned: paginated.length
+  });
+  return createMcpResponse(structuredData, contentSummary || `Found ${total} tasks for "${query}".`, {
+    contentSummary,
+    structuredContentPathHint: "results",
+    includeSerializedStructuredContent: isStructuredRequest
+  });
+}
+
 // src/mcp/router.ts
 function createRouter(db2, vectors2, options) {
   const getSessionContext = options?.getSessionContext;
@@ -2575,6 +2348,8 @@ function createRouter(db2, vectors2, options) {
           return await handleTaskDelete(args, db2);
         case "task-list":
           return await handleTaskList(args, db2);
+        case "task-search":
+          return await handleTaskSearch(args, db2);
         case "task-detail":
           return await handleTaskGet(args, db2);
         default:
@@ -2749,8 +2524,8 @@ logger.info("[Server] startup", { pid: process.pid, version: CAPABILITIES.server
 vectors.initialize().catch((err) => {
   logger.warn("[Server] Initial vector model loading failed. Will retry on first use.", { error: String(err) });
 });
-var expiredArchived = db.memories.archiveExpiredMemories();
-var lowScoreArchived = db.memories.archiveLowScoreMemories();
+var expiredArchived = db.memoryArchives.archiveExpiredMemories();
+var lowScoreArchived = db.memoryArchives.archiveLowScoreMemories();
 var totalArchived = (expiredArchived || 0) + (lowScoreArchived || 0);
 if (totalArchived > 0) {
   logger.info(
@@ -2771,9 +2546,7 @@ var logNotificationsEnabled = false;
 var handleMethod = createRouter(db, vectors, {
   getSessionContext: () => session,
   sampleMessage: (params) => requestClient("sampling/createMessage", params),
-  // eslint-disable-line @typescript-eslint/no-explicit-any
   elicit: (params) => requestClient("elicitation/create", params),
-  // eslint-disable-line @typescript-eslint/no-explicit-any
   onResourcesMutated: (uris) => notifyUpdatedResources(uris)
 });
 addLogSink((payload) => {