@vheins/local-memory-mcp 0.18.11 → 0.18.13

package/dist/mcp/server.js

@@ -63,7 +63,7 @@ import {
   toContextSlug,
   updateSessionFromInitialize,
   updateSessionRoots
-} from "../chunk-4RFYQ345.js";
+} from "../chunk-BK2QIQXS.js";
 
 // src/mcp/server.ts
 import readline from "readline";
@@ -797,25 +797,7 @@ function capitalize2(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
-// src/mcp/tools/task.manage.ts
-import { randomUUID as randomUUID2 } 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 resolveParentId(value, owner, repo, storage, localCodeMap) {
-  if (!value) return null;
-  if (UUID_REGEX3.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}'`);
-  return parent.id;
-}
-function resolveDependsOn(value, owner, repo, storage, localCodeMap) {
-  if (!value) return null;
-  if (UUID_REGEX3.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}'`);
-  return task.id;
-}
+// src/mcp/tools/task.list.ts
 function describeTaskListFilter(status) {
   if (!status) return "active";
   if (status === "all") return "all";
@@ -864,82 +846,6 @@ function buildTaskListSummary(repo, count, status, phase, search, tasksByStatus)
 function capitalize3(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
-function deriveTaskStatusTimestamps(status, now, existingTask) {
-  const timestamps = {
-    in_progress_at: null,
-    finished_at: null,
-    canceled_at: null
-  };
-  if (status === "in_progress" && existingTask?.status !== "in_progress") {
-    timestamps.in_progress_at = now;
-  }
-  if (status === "completed") {
-    timestamps.finished_at = now;
-  }
-  if (status === "canceled") {
-    timestamps.canceled_at = now;
-  }
-  return timestamps;
-}
-async function archiveTaskToMemory(taskId, repo, storage, vectors2) {
-  const task = storage.tasks.getTaskById(taskId);
-  if (!task) return;
-  const comments = storage.taskComments.getTaskCommentsByTaskId(taskId);
-  let content = `Task: [${task.task_code}] ${task.title}
-`;
-  content += `Phase: ${task.phase}
-`;
-  content += `Description: ${task.description || "No description"}
-`;
-  content += `Commit: ${task.commit_id || "N/A"}
-`;
-  if (task.changed_files && task.changed_files.length > 0) {
-    content += `Files changed:
-`;
-    for (const f of task.changed_files) {
-      content += `  - ${f}
-`;
-    }
-  }
-  if (comments && comments.length > 0) {
-    content += `
-Comments & History:
-`;
-    const chronComments = [...comments].reverse();
-    for (const c of chronComments) {
-      const statusInfo = c.next_status ? ` (Status: ${c.previous_status} -> ${c.next_status})` : "";
-      content += `- [${c.created_at}] ${c.agent}${statusInfo}: ${c.comment}
-`;
-    }
-  }
-  const metadata = {
-    task_id: taskId,
-    task_code: task.task_code,
-    original_metadata: task.metadata
-  };
-  const title = `Completed Task: ${task.title}`;
-  const truncatedTitle = title.length > 100 ? title.substring(0, 97) + "..." : title;
-  try {
-    await handleMemoryStore(
-      {
-        type: "task_archive",
-        title: truncatedTitle,
-        content,
-        importance: Math.min(5, task.priority + 1),
-        agent: task.agent || "system",
-        role: task.role || "unknown",
-        model: "system",
-        scope: { repo, owner: task.owner || "" },
-        tags: ["task-archive", ...task.tags],
-        metadata
-      },
-      storage,
-      vectors2
-    );
-  } catch (error) {
-    logger.error("Failed to archive task to memory", { error: String(error) });
-  }
-}
 async function handleTaskList(args, storage) {
   const validated = TaskListSchema.parse(args);
   const { owner, repo, status, phase, query, limit, offset, structured: isStructuredRequest = false } = validated;
@@ -985,848 +891,398 @@ async function handleTaskList(args, storage) {
     includeSerializedStructuredContent: isStructuredRequest
   });
 }
-async function handleTaskCreate(args, storage) {
-  const parsed = TaskCreateSchema.parse(args);
-  const { owner, repo, tasks: bulkTasks, ...singleTask } = parsed;
-  if (bulkTasks) {
-    const createdTasks = [];
-    const tasksToInsert = [];
-    const now2 = (/* @__PURE__ */ new Date()).toISOString();
-    const codesInRequest = /* @__PURE__ */ new Set();
-    const batchCodes = /* @__PURE__ */ new Set();
-    for (const taskData of bulkTasks) {
-      if (!taskData.task_code) {
-        taskData.task_code = generateNextCode(owner ?? "", repo, "task", storage, batchCodes);
+
+// src/mcp/tools/memory.synthesize.ts
+async function handleMemorySynthesize(params, db2, vectors2, options = {}) {
+  const validated = MemorySynthesizeSchema.parse(params);
+  const session2 = options.session;
+  if (!options.sampleMessage || !session2?.supportsSampling) {
+    throw new Error("Client does not advertise MCP sampling support");
+  }
+  const repo = await resolveRepository(validated.repo, session2, options.elicit);
+  if (!repo) {
+    throw new Error("repo is required when repo cannot be inferred from active MCP roots");
+  }
+  const repoOwner = validated.owner;
+  const recap = await handleMemoryRecap({ owner: repoOwner, repo, limit: 8, offset: 0 }, db2);
+  const recapText = getPrimaryTextContent(recap);
+  const summary = validated.include_summary ? db2.summaries.getSummary(repoOwner, repo)?.summary : "";
+  const taskSnapshot = validated.include_tasks ? await handleTaskList(
+    { owner: repoOwner, repo, status: "backlog,pending,in_progress,blocked", limit: 15, offset: 0 },
+    db2
+  ) : null;
+  const taskText = taskSnapshot ? getPrimaryTextContent(taskSnapshot) : "";
+  const systemPrompt = [
+    "You are a repository memory synthesizer.",
+    "Answer strictly from grounded MCP context and tool results.",
+    "If memory is insufficient, say so explicitly instead of inventing details.",
+    "Prefer concise, technical answers with explicit caveats when evidence is incomplete."
+  ].join(" ");
+  const contextBlock = [
+    `Repository: ${repo}`,
+    validated.current_file_path ? `Current file: ${validated.current_file_path}` : "",
+    summary ? `Summary:
+${summary}` : "",
+    recapText ? `Recent context:
+${recapText}` : "",
+    taskText ? `Active tasks:
+${taskText}` : ""
+  ].filter(Boolean).join("\n\n");
+  const messages = [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: `Objective: ${validated.objective}
+
+Grounding context:
+${contextBlock || "No additional context provided."}`
       }
-      batchCodes.add(taskData.task_code);
-    }
-    const allCodes = bulkTasks.map((t) => t.task_code);
-    const existingCodes = storage.tasks.getExistingTaskCodes(owner, repo, allCodes);
-    const initialStats = storage.taskStats.getTaskStats(owner, repo);
-    let pendingInRequestCount = 0;
-    const localCodeMap = /* @__PURE__ */ new Map();
-    for (const taskData of bulkTasks) {
-      localCodeMap.set(taskData.task_code, randomUUID2());
     }
-    for (const taskData of bulkTasks) {
-      const code = taskData.task_code;
-      if (codesInRequest.has(code)) {
-        throw new Error(`Duplicate task_code in request: '${code}'`);
-      }
-      if (existingCodes.has(code)) {
-        throw new Error(`Duplicate task_code: '${code}' already exists in repository '${repo}'`);
-      }
-      codesInRequest.add(code);
-      const normalizedStatus = taskData.status || "backlog";
-      if (normalizedStatus !== "backlog" && normalizedStatus !== "pending") {
-        throw new Error(`New tasks must be 'backlog' or 'pending'. Task '${code}' has status '${normalizedStatus}'.`);
-      }
-      if (normalizedStatus === "pending") {
-        if (initialStats.todo + pendingInRequestCount >= 10) {
-          throw new Error(
-            `Cannot create task '${code}' as 'pending'. Maximum of 10 pending tasks reached. Please use status 'backlog' for new tasks instead.`
-          );
-        }
-      }
-      const statusTimestamps2 = deriveTaskStatusTimestamps(normalizedStatus, now2);
-      const tags = [...taskData.tags || []];
-      const phaseTag2 = `phase:${taskData.phase}`;
-      if (!tags.includes(phaseTag2)) {
-        tags.push(phaseTag2);
-      }
-      const taskId2 = localCodeMap.get(code);
-      const task2 = {
-        id: taskId2,
-        owner,
-        repo,
-        task_code: code,
-        phase: taskData.phase,
-        title: taskData.title,
-        description: taskData.description,
-        status: normalizedStatus,
-        priority: taskData.priority || 3,
-        agent: taskData.agent || singleTask.agent || "unknown",
-        role: taskData.role || singleTask.role || "unknown",
-        doc_path: taskData.doc_path || null,
-        created_at: now2,
-        updated_at: now2,
-        in_progress_at: statusTimestamps2.in_progress_at,
-        finished_at: statusTimestamps2.finished_at,
-        canceled_at: statusTimestamps2.canceled_at,
-        est_tokens: taskData.est_tokens ?? 0,
-        tags,
-        suggested_skills: taskData.suggested_skills || [],
-        commit_id: null,
-        changed_files: [],
-        metadata: taskData.metadata || {},
-        parent_id: resolveParentId(taskData.parent_id, owner, repo, storage, localCodeMap),
-        depends_on: resolveDependsOn(taskData.depends_on, owner, repo, storage, localCodeMap)
-      };
-      tasksToInsert.push(task2);
-      createdTasks.push(code);
-      if (normalizedStatus === "pending") {
-        pendingInRequestCount++;
+  ];
+  const toolDefinitions = buildSamplingTools(session2, validated.use_tools);
+  let lastResponse = null;
+  let totalToolCalls = 0;
+  let iterations = 0;
+  while (iterations < validated.max_iterations) {
+    iterations += 1;
+    const response = await options.sampleMessage({
+      messages,
+      systemPrompt,
+      maxTokens: validated.max_tokens,
+      tools: toolDefinitions.length > 0 ? toolDefinitions : void 0,
+      toolChoice: toolDefinitions.length > 0 ? { mode: iterations === validated.max_iterations ? "none" : "auto" } : void 0,
+      modelPreferences: {
+        intelligencePriority: 0.9,
+        speedPriority: 0.4
       }
+    });
+    lastResponse = response;
+    messages.push({
+      role: "assistant",
+      content: response.content
+    });
+    const toolUses = extractToolUses(response.content);
+    if (toolUses.length === 0) {
+      break;
     }
-    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}"${taskCodesStr}.`,
-      { includeSerializedStructuredContent: parsed.structured || false }
-    );
-  }
-  const {
-    task_code,
-    phase,
-    title,
-    description,
-    status,
-    priority,
-    agent,
-    role,
-    doc_path,
-    metadata,
-    parent_id,
-    depends_on,
-    est_tokens
-  } = singleTask;
-  if (!phase || !title || !description) {
-    throw new Error("Missing required fields for single task creation (phase, title, description)");
-  }
-  const resolvedCode = task_code || generateNextCode(owner ?? "", repo, "task", storage);
-  if (storage.tasks.isTaskCodeDuplicate(owner, repo, resolvedCode)) {
-    throw new Error(`Duplicate task_code: '${resolvedCode}' already exists in repository '${repo}'`);
-  }
-  if (status !== "backlog" && status !== "pending" && status !== void 0) {
-    throw new Error("New tasks must be created with status 'backlog' or 'pending'.");
-  }
-  if (status === "pending") {
-    const stats = storage.taskStats.getTaskStats(owner, 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.`
-      );
-    }
+    totalToolCalls += toolUses.length;
+    const toolResults = await Promise.all(
+      toolUses.map(async (toolUse) => ({
+        type: "tool_result",
+        toolUseId: toolUse.id,
+        content: [
+          {
+            type: "text",
+            text: await executeSamplingTool(toolUse.name, toolUse.input, db2, vectors2, repoOwner)
+          }
+        ]
+      }))
+    );
+    messages.push({
+      role: "user",
+      content: toolResults
+    });
   }
-  const taskId = randomUUID2();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const statusTimestamps = deriveTaskStatusTimestamps(status || "backlog", now);
-  const finalTags = [...singleTask.tags || []];
-  const phaseTag = `phase:${phase}`;
-  if (!finalTags.includes(phaseTag)) {
-    finalTags.push(phaseTag);
+  const answer = lastResponse ? extractTextFromContent(lastResponse.content).trim() : "";
+  if (!answer) {
+    throw new Error("Sampling did not return a final text answer");
   }
-  const task = {
-    id: taskId,
-    owner,
+  logger.info("[Tool] memory.synthesize", {
     repo,
-    task_code: resolvedCode,
-    phase,
-    title,
-    description,
-    status: status || "backlog",
-    priority: priority || 3,
-    agent: agent || "unknown",
-    role: role || "unknown",
-    doc_path: doc_path || null,
-    created_at: now,
-    updated_at: now,
-    in_progress_at: statusTimestamps.in_progress_at,
-    finished_at: statusTimestamps.finished_at,
-    canceled_at: statusTimestamps.canceled_at,
-    est_tokens: est_tokens ?? 0,
-    tags: finalTags,
-    suggested_skills: singleTask.suggested_skills || [],
-    commit_id: null,
-    changed_files: [],
-    metadata: metadata || {},
-    parent_id: resolveParentId(parent_id, owner, repo, storage),
-    depends_on: resolveDependsOn(depends_on, owner, repo, storage)
-  };
-  storage.tasks.insertTask(task);
+    objective: validated.objective,
+    iterations,
+    toolCalls: totalToolCalls
+  });
   return createMcpResponse(
     {
-      success: true,
-      id: task.id,
-      repo: task.repo,
-      task_code: task.task_code,
-      phase: task.phase,
-      title: task.title,
-      status: task.status,
-      priority: task.priority,
-      depends_on: task.depends_on
+      repo,
+      objective: validated.objective,
+      answer,
+      model: lastResponse?.model,
+      stopReason: lastResponse?.stopReason,
+      iterations,
+      toolCalls: totalToolCalls
     },
-    `Created task [${task.task_code}] ${task.title} in repo "${task.repo}" with status "${task.status}".`,
-    { includeSerializedStructuredContent: parsed.structured || false }
+    `Synthesized answer for "${validated.objective}" using repository "${repo}".`,
+    {
+      structuredContentPathHint: "answer",
+      includeSerializedStructuredContent: true
+    }
   );
 }
-async function handleTaskCreateInteractive(args, storage, options = {}) {
-  const partialTaskData = TaskCreateInteractiveSchema.parse(args ?? {});
-  const inferredRepo = partialTaskData.repo ?? inferRepoFromSession(options.session);
-  const draft = {
-    ...partialTaskData,
-    repo: inferredRepo
-  };
-  const requestedSchema = buildMissingTaskSchema(draft);
-  let completedDraft = draft;
-  if (Object.keys(requestedSchema.properties).length > 0) {
-    if (!options.session?.supportsElicitationForm || !options.elicit) {
-      throw new Error("Client does not advertise MCP elicitation form support");
-    }
-    const elicited = extractAcceptedElicitationContent(
-      await options.elicit({
-        mode: "form",
-        message: "Please complete the missing task details to create a new task.",
-        requestedSchema
-      })
-    );
-    completedDraft = {
-      ...draft,
-      ...elicited
-    };
+async function resolveRepository(repo, session2, elicit) {
+  if (repo) return normalizeRepo(repo);
+  const inferredRepo = inferRepoFromSession(session2);
+  if (inferredRepo) return normalizeRepo(inferredRepo);
+  if (!session2?.supportsElicitationForm || !elicit) {
+    return void 0;
   }
-  return await handleTaskCreate(
-    {
-      ...completedDraft,
-      status: completedDraft.status ?? "backlog",
-      priority: completedDraft.priority ?? 3,
-      structured: true
-    },
-    storage
+  const elicited = extractAcceptedElicitationContent(
+    await elicit({
+      mode: "form",
+      message: "Repository tidak bisa diinfer dari roots aktif. Pilih repository yang ingin disintesis.",
+      requestedSchema: {
+        type: "object",
+        properties: {
+          repo: {
+            type: "string",
+            title: "Repository",
+            description: "Nama repository yang akan dipakai untuk sintesis memori.",
+            minLength: 1
+          }
+        },
+        required: ["repo"]
+      }
+    })
   );
+  return typeof elicited.repo === "string" && elicited.repo.trim() ? normalizeRepo(elicited.repo.trim()) : void 0;
 }
-function buildMissingTaskSchema(task) {
-  const properties = {};
-  const required = [];
-  addRequiredStringField(properties, required, task, "repo", {
-    title: "Repository",
-    description: "Name of the repository for this task.",
-    minLength: 1
-  });
-  addRequiredStringField(properties, required, task, "phase", {
-    title: "Phase",
-    description: "Project phase or milestone for this task.",
-    minLength: 1
-  });
-  addRequiredStringField(properties, required, task, "title", {
-    title: "Title",
-    description: "Short task title.",
-    minLength: 3,
-    maxLength: 100
-  });
-  addRequiredStringField(properties, required, task, "description", {
-    title: "Description",
-    description: "Detailed description. MUST follow format: 1. Context & Analysis, 2. Step & Implementation, 3. Acceptance & Verification",
-    minLength: 1
-  });
-  if (!task.status) {
-    properties.status = {
-      type: "string",
-      title: "Status",
-      description: "Initial task status.",
-      enum: ["backlog", "pending"],
-      default: "backlog"
-    };
-  }
-  if (task.priority === void 0) {
-    properties.priority = {
-      type: "integer",
-      title: "Priority",
-      description: "Task priority from 1 to 5.",
-      minimum: 1,
-      maximum: 5,
-      default: 3
-    };
+function buildSamplingTools(session2, useTools) {
+  if (!useTools || !session2?.supportsSamplingTools) {
+    return [];
   }
-  return {
-    type: "object",
-    properties,
-    required
-  };
+  return [
+    {
+      name: "memory_search",
+      description: "Search local repository memories for relevant context.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo: { type: "string" },
+          query: { type: "string" },
+          limit: { type: "number", minimum: 1, maximum: 10 }
+        },
+        required: ["repo", "query"]
+      }
+    },
+    {
+      name: "memory_recap",
+      description: "Fetch a recap of the most recent memories and active tasks.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo: { type: "string" },
+          limit: { type: "number", minimum: 1, maximum: 20 }
+        },
+        required: ["repo"]
+      }
+    },
+    {
+      name: "task_list",
+      description: "List tasks by status or search term for the repository.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo: { type: "string" },
+          status: { type: "string" },
+          search: { type: "string" },
+          limit: { type: "number", minimum: 1, maximum: 20 }
+        },
+        required: ["repo"]
+      }
+    }
+  ];
 }
-function addRequiredStringField(properties, required, task, field, schema) {
-  if (typeof task[field] === "string" && task[field].trim()) {
-    return;
-  }
-  properties[field] = {
-    type: "string",
-    ...schema
-  };
-  required.push(field);
-}
-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 && !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] : []);
-  if (targetIds.length === 0) {
-    throw new Error("Either 'id' or 'ids' must be provided for update");
-  }
-  let updatedCount = 0;
-  const updatedTasks = [];
-  const completedTaskIds = [];
-  let releasedClaims = 0;
-  let expiredHandoffs = 0;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const isStatusChangingGlobal = updates.status !== void 0;
-  const existingTasks = storage.tasks.getTasksByIds(targetIds);
-  const taskMap = new Map(existingTasks.map((t) => [t.id, t]));
-  for (const targetId of targetIds) {
-    const existingTask = taskMap.get(targetId);
-    if (!existingTask) {
-      if (id) throw new Error(`Task not found: ${targetId}`);
-      continue;
-    }
-    const isStatusChanging = isStatusChangingGlobal && updates.status !== existingTask.status;
-    if (isStatusChanging && !force) {
-      if (!comment || comment.trim() === "") {
-        throw new Error("comment is required when changing task status");
-      }
-      const isStartable = existingTask.status === "backlog" || existingTask.status === "pending" || existingTask.status === "blocked";
-      if (isStartable && updates.status === "completed") {
-        throw new Error(
-          `Cannot transition task ${targetId} from '${existingTask.status}' directly to 'completed'. Must be 'in_progress' first.`
-        );
-      }
-    }
-    if (updates.status === "completed" && isStatusChanging) {
-      if (updates.est_tokens === void 0) {
-        throw new Error("est_tokens is required when changing task status to completed");
-      }
-      const children = storage.tasks.getChildrenByParentId(targetId);
-      const incompleteChildren = children.filter((c) => c.status !== "completed");
-      if (incompleteChildren.length > 0) {
-        const childList = incompleteChildren.map((c) => `[${c.task_code}] ${c.title} (${c.status})`).join("; ");
-        throw new Error(
-          `Cannot complete task [${existingTask.task_code}] "${existingTask.title}" \u2014 it has ${incompleteChildren.length} incomplete child task(s). Complete the following child task(s) first: ${childList}`
-        );
-      }
-    }
-    if (updates.task_code && storage.tasks.isTaskCodeDuplicate(owner, repo, updates.task_code, targetId)) {
-      throw new Error(`Duplicate task_code: '${updates.task_code}' already exists`);
-    }
-    const finalUpdates = { ...updates };
-    if (updates.parent_id !== void 0) {
-      finalUpdates.parent_id = resolveParentId(updates.parent_id, owner, repo, storage);
-    }
-    if (updates.depends_on !== void 0) {
-      finalUpdates.depends_on = resolveDependsOn(updates.depends_on, owner, repo, storage);
-    }
-    if (updates.phase !== void 0 || updates.tags !== void 0) {
-      let currentTags = updates.tags || existingTask.tags || [];
-      currentTags = currentTags.filter((t) => !t.startsWith("phase:"));
-      const finalPhase = updates.phase !== void 0 ? updates.phase : existingTask.phase;
-      if (finalPhase) {
-        const phaseTag = `phase:${finalPhase}`;
-        if (!currentTags.includes(phaseTag)) {
-          currentTags.push(phaseTag);
-        }
-      }
-      finalUpdates.tags = currentTags;
-    }
-    if (updates.status === "completed") {
-      finalUpdates.finished_at = now;
-      finalUpdates.commit_id = updates.commit_id;
-      finalUpdates.changed_files = updates.changed_files;
-    } else if (updates.status === "canceled") finalUpdates.canceled_at = now;
-    else if (updates.status === "in_progress" && existingTask.status !== "in_progress")
-      finalUpdates.in_progress_at = now;
-    storage.tasks.updateTask(targetId, finalUpdates);
-    if (comment !== void 0 || isStatusChanging) {
-      storage.taskComments.insertTaskComment({
-        id: randomUUID2(),
-        task_id: targetId,
-        owner,
-        repo,
-        comment: comment || `Status updated to ${updates.status}`,
-        agent: updates.agent || existingTask.agent || "unknown",
-        role: updates.role || existingTask.role || "unknown",
-        model: updates.model || "unknown",
-        previous_status: isStatusChanging ? existingTask.status : null,
-        next_status: isStatusChanging ? updates.status : null,
-        created_at: now
-      });
+async function executeSamplingTool(toolName, rawInput, db2, vectors2, owner) {
+  switch (toolName) {
+    case "memory_search": {
+      const response = await handleMemorySearch(
+        {
+          owner,
+          repo: rawInput.repo,
+          query: rawInput.query,
+          limit: rawInput.limit ?? 5
+        },
+        db2,
+        vectors2
+      );
+      return getPrimaryTextContent(response);
     }
-    if (updates.status === "completed" && existingTask.status !== "completed") {
-      completedTaskIds.push(targetId);
+    case "memory_recap": {
+      const response = await handleMemoryRecap(
+        {
+          owner,
+          repo: rawInput.repo,
+          limit: rawInput.limit ?? 8,
+          offset: 0
+        },
+        db2
+      );
+      return getPrimaryTextContent(response);
     }
-    if (isStatusChanging && (updates.status === "completed" || updates.status === "canceled")) {
-      releasedClaims += storage.handoffs.releaseClaimsForTask(targetId);
-      expiredHandoffs += storage.handoffs.updatePendingHandoffsForTask(targetId, "expired");
+    case "task_list": {
+      const response = await handleTaskList(
+        {
+          owner,
+          repo: rawInput.repo,
+          status: rawInput.status,
+          search: rawInput.search,
+          limit: rawInput.limit ?? 10,
+          offset: 0
+        },
+        db2
+      );
+      return getPrimaryTextContent(response);
     }
-    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}". 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).`;
-  }
-  const response = createMcpResponse(
-    {
-      success: true,
-      id: id || void 0,
-      ids: ids || void 0,
-      repo,
-      status: updates.status,
-      updatedCount,
-      updatedFields: Object.keys(updates),
-      coordinationCleanup: {
-        releasedClaims,
-        expiredHandoffs
-      }
-    },
-    summaryText,
-    { includeSerializedStructuredContent: updateData.structured }
-  );
-  if (completedTaskIds.length > 0) {
-    setImmediate(async () => {
-      for (const taskId of completedTaskIds) {
-        try {
-          await archiveTaskToMemory(taskId, repo, storage, vectors2);
-        } catch (err) {
-          logger.error("Failed to archive task to memory", { taskId, error: String(err) });
-        }
-      }
-    });
+    default:
+      throw new Error(`Unsupported sampling tool: ${toolName}`);
   }
-  return response;
 }
-async function handleTaskDelete(args, storage) {
-  const validated = TaskDeleteSchema.parse(args);
-  const { owner, repo, id, ids, task_code } = validated;
+
+// src/mcp/tools/memory.delete.ts
+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 (task_code) {
-    const task = storage.tasks.getTaskByCode(owner, repo, task_code);
-    if (!task) throw new Error(`Task not found: ${task_code}`);
-    resolvedIds.push(task.id);
+  if (code) {
+    const entry = db2.memories.getByCode(code, owner, repo);
+    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, owner, repo);
+      if (!entry) throw new Error(`Memory not found: ${c}`);
+      resolvedIds.push(entry.id);
+    }
   }
   if (resolvedIds.length === 0) {
-    throw new Error("Either 'id', 'ids', or 'task_code' must be provided for deletion");
+    throw new Error("Either 'id', 'ids', 'code', or 'codes' must be provided for deletion");
   }
   const targetIds = resolvedIds;
-  const tasksToDelete = storage.tasks.getTasksByIds(targetIds);
-  const deletedCodes = tasksToDelete.map((t) => t.task_code);
+  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) {
-    storage.tasks.deleteTask(targetId);
+    const existing = existingMap.get(targetId);
+    if (existing) {
+      lastRepo = existing.scope.repo;
+      deletedCodes.push(existing.code || existing.id);
+      validIdsToDelete.push(targetId);
+    } else if (id) {
+      throw new Error(`Memory not found: ${targetId}`);
+    }
   }
-  const deletedCodesStr = deletedCodes.length > 0 ? `: ${deletedCodes.join(", ")}` : "";
+  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);
+  }
+  logger.info("[Tool] memory.delete", { repo: lastRepo, count: deletedCount });
   return createMcpResponse(
     {
       success: true,
       id: id || void 0,
       ids: ids || void 0,
-      repo,
-      deletedCount: targetIds.length,
-      deletedCodes
+      repo: lastRepo,
+      deletedCount,
+      deletedCodes: deletedCount > 10 ? [...deletedCodes.slice(0, 10), "..."] : deletedCodes
     },
-    `Deleted ${targetIds.length} task(s) from repo "${repo}"${deletedCodesStr}.`,
-    { includeSerializedStructuredContent: validated.structured }
+    `Deleted ${deletedCount} memory entry(ies) from repo "${lastRepo}".`,
+    {
+      structuredContentPathHint: "deletedCount",
+      includeSerializedStructuredContent: structured
+    }
   );
 }
 
-// src/mcp/tools/memory.synthesize.ts
-async function handleMemorySynthesize(params, db2, vectors2, options = {}) {
-  const validated = MemorySynthesizeSchema.parse(params);
-  const session2 = options.session;
-  if (!options.sampleMessage || !session2?.supportsSampling) {
-    throw new Error("Client does not advertise MCP sampling support");
+// src/mcp/tools/memory.acknowledge.ts
+async function handleMemoryAcknowledge(params, db2) {
+  const validated = MemoryAcknowledgeSchema.parse(params);
+  let memoryId = validated.memory_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}`);
+    memoryId = byCode.id;
+  } else if (!memoryId) {
+    throw new Error("Either memory_id or code must be provided");
   }
-  const repo = await resolveRepository(validated.repo, session2, options.elicit);
-  if (!repo) {
-    throw new Error("repo is required when repo cannot be inferred from active MCP roots");
+  const memory = db2.memories.getById(memoryId);
+  if (!memory) {
+    throw new Error(`Memory with ID ${memoryId} not found.`);
   }
-  const repoOwner = validated.owner;
-  const recap = await handleMemoryRecap({ owner: repoOwner, repo, limit: 8, offset: 0 }, db2);
-  const recapText = getPrimaryTextContent(recap);
-  const summary = validated.include_summary ? db2.summaries.getSummary(repoOwner, repo)?.summary : "";
-  const taskSnapshot = validated.include_tasks ? await handleTaskList(
-    { owner: repoOwner, repo, status: "backlog,pending,in_progress,blocked", limit: 15, offset: 0 },
-    db2
-  ) : null;
-  const taskText = taskSnapshot ? getPrimaryTextContent(taskSnapshot) : "";
-  const systemPrompt = [
-    "You are a repository memory synthesizer.",
-    "Answer strictly from grounded MCP context and tool results.",
-    "If memory is insufficient, say so explicitly instead of inventing details.",
-    "Prefer concise, technical answers with explicit caveats when evidence is incomplete."
-  ].join(" ");
-  const contextBlock = [
-    `Repository: ${repo}`,
-    validated.current_file_path ? `Current file: ${validated.current_file_path}` : "",
-    summary ? `Summary:
-${summary}` : "",
-    recapText ? `Recent context:
-${recapText}` : "",
-    taskText ? `Active tasks:
-${taskText}` : ""
-  ].filter(Boolean).join("\n\n");
-  const messages = [
-    {
-      role: "user",
-      content: {
-        type: "text",
-        text: `Objective: ${validated.objective}
-
-Grounding context:
-${contextBlock || "No additional context provided."}`
-      }
-    }
-  ];
-  const toolDefinitions = buildSamplingTools(session2, validated.use_tools);
-  let lastResponse = null;
-  let totalToolCalls = 0;
-  let iterations = 0;
-  while (iterations < validated.max_iterations) {
-    iterations += 1;
-    const response = await options.sampleMessage({
-      messages,
-      systemPrompt,
-      maxTokens: validated.max_tokens,
-      tools: toolDefinitions.length > 0 ? toolDefinitions : void 0,
-      toolChoice: toolDefinitions.length > 0 ? { mode: iterations === validated.max_iterations ? "none" : "auto" } : void 0,
-      modelPreferences: {
-        intelligencePriority: 0.9,
-        speedPriority: 0.4
-      }
-    });
-    lastResponse = response;
-    messages.push({
-      role: "assistant",
-      content: response.content
-    });
-    const toolUses = extractToolUses(response.content);
-    if (toolUses.length === 0) {
-      break;
-    }
-    totalToolCalls += toolUses.length;
-    const toolResults = await Promise.all(
-      toolUses.map(async (toolUse) => ({
-        type: "tool_result",
-        toolUseId: toolUse.id,
-        content: [
-          {
-            type: "text",
-            text: await executeSamplingTool(toolUse.name, toolUse.input, db2, vectors2, repoOwner)
-          }
-        ]
-      }))
-    );
-    messages.push({
-      role: "user",
-      content: toolResults
+  if (validated.status === "used") {
+    db2.memories.incrementRecallCount(memory.id);
+    logger.info("[Tool] memory.acknowledge - used", { id: memory.id, context: validated.application_context });
+  } else if (validated.status === "contradictory") {
+    logger.warn("[Tool] memory.acknowledge - contradiction reported", {
+      id: memory.id,
+      context: validated.application_context
     });
+  } else {
+    logger.info("[Tool] memory.acknowledge - irrelevant", { id: memory.id, context: validated.application_context });
   }
-  const answer = lastResponse ? extractTextFromContent(lastResponse.content).trim() : "";
-  if (!answer) {
-    throw new Error("Sampling did not return a final text answer");
-  }
-  logger.info("[Tool] memory.synthesize", {
-    repo,
-    objective: validated.objective,
-    iterations,
-    toolCalls: totalToolCalls
-  });
   return createMcpResponse(
     {
-      repo,
-      objective: validated.objective,
-      answer,
-      model: lastResponse?.model,
-      stopReason: lastResponse?.stopReason,
-      iterations,
-      toolCalls: totalToolCalls
+      success: true,
+      id: memory.id,
+      status: validated.status
     },
-    `Synthesized answer for "${validated.objective}" using repository "${repo}".`,
+    `Acknowledged memory [${memory.code}] as "${validated.status}".`,
     {
-      structuredContentPathHint: "answer",
-      includeSerializedStructuredContent: true
+      structuredContentPathHint: "status",
+      includeSerializedStructuredContent: validated.structured
     }
   );
 }
-async function resolveRepository(repo, session2, elicit) {
-  if (repo) return normalizeRepo(repo);
-  const inferredRepo = inferRepoFromSession(session2);
-  if (inferredRepo) return normalizeRepo(inferredRepo);
-  if (!session2?.supportsElicitationForm || !elicit) {
-    return void 0;
+
+// src/mcp/tools/memory.detail.ts
+async function handleMemoryDetail(args, storage) {
+  const validated = MemoryDetailSchema.parse(args);
+  const { id, code, owner, repo } = validated;
+  let memory;
+  if (id) {
+    memory = storage.memories.getById(id);
+  } else if (code) {
+    memory = storage.memories.getByCode(code, owner, repo);
   }
-  const elicited = extractAcceptedElicitationContent(
-    await elicit({
-      mode: "form",
-      message: "Repository tidak bisa diinfer dari roots aktif. Pilih repository yang ingin disintesis.",
-      requestedSchema: {
-        type: "object",
-        properties: {
-          repo: {
-            type: "string",
-            title: "Repository",
-            description: "Nama repository yang akan dipakai untuk sintesis memori.",
-            minLength: 1
-          }
-        },
-        required: ["repo"]
-      }
-    })
-  );
-  return typeof elicited.repo === "string" && elicited.repo.trim() ? normalizeRepo(elicited.repo.trim()) : void 0;
-}
-function buildSamplingTools(session2, useTools) {
-  if (!useTools || !session2?.supportsSamplingTools) {
-    return [];
+  if (!memory) {
+    throw new Error(`Memory not found: ${id || code}`);
   }
-  return [
-    {
-      name: "memory_search",
-      description: "Search local repository memories for relevant context.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          repo: { type: "string" },
-          query: { type: "string" },
-          limit: { type: "number", minimum: 1, maximum: 10 }
-        },
-        required: ["repo", "query"]
-      }
-    },
-    {
-      name: "memory_recap",
-      description: "Fetch a recap of the most recent memories and active tasks.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          repo: { type: "string" },
-          limit: { type: "number", minimum: 1, maximum: 20 }
-        },
-        required: ["repo"]
-      }
-    },
-    {
-      name: "task_list",
-      description: "List tasks by status or search term for the repository.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          repo: { type: "string" },
-          status: { type: "string" },
-          search: { type: "string" },
-          limit: { type: "number", minimum: 1, maximum: 20 }
-        },
-        required: ["repo"]
-      }
-    }
+  storage.memories.incrementHitCount(memory.id);
+  const lines = [
+    `Code: ${memory.code || "-"}`,
+    `ID: ${memory.id}`,
+    `Title: ${memory.title}`,
+    `Type: ${memory.type}`,
+    `Importance: ${memory.importance}`,
+    `Created: ${memory.created_at}`
   ];
-}
-async function executeSamplingTool(toolName, rawInput, db2, vectors2, owner) {
-  switch (toolName) {
-    case "memory_search": {
-      const response = await handleMemorySearch(
-        {
-          owner,
-          repo: rawInput.repo,
-          query: rawInput.query,
-          limit: rawInput.limit ?? 5
-        },
-        db2,
-        vectors2
-      );
-      return getPrimaryTextContent(response);
-    }
-    case "memory_recap": {
-      const response = await handleMemoryRecap(
-        {
-          owner,
-          repo: rawInput.repo,
-          limit: rawInput.limit ?? 8,
-          offset: 0
-        },
-        db2
-      );
-      return getPrimaryTextContent(response);
-    }
-    case "task_list": {
-      const response = await handleTaskList(
-        {
-          owner,
-          repo: rawInput.repo,
-          status: rawInput.status,
-          search: rawInput.search,
-          limit: rawInput.limit ?? 10,
-          offset: 0
-        },
-        db2
-      );
-      return getPrimaryTextContent(response);
-    }
-    default:
-      throw new Error(`Unsupported sampling tool: ${toolName}`);
-  }
-}
-
-// src/mcp/tools/memory.delete.ts
-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 (code) {
-    const entry = db2.memories.getByCode(code, owner, repo);
-    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, owner, repo);
-      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) {
-    const existing = existingMap.get(targetId);
-    if (existing) {
-      lastRepo = existing.scope.repo;
-      deletedCodes.push(existing.code || existing.id);
-      validIdsToDelete.push(targetId);
-    } else if (id) {
-      throw new Error(`Memory not found: ${targetId}`);
-    }
-  }
-  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);
-  }
-  logger.info("[Tool] memory.delete", { repo: lastRepo, count: deletedCount });
-  return createMcpResponse(
-    {
-      success: true,
-      id: id || void 0,
-      ids: ids || void 0,
-      repo: lastRepo,
-      deletedCount,
-      deletedCodes: deletedCount > 10 ? [...deletedCodes.slice(0, 10), "..."] : deletedCodes
-    },
-    `Deleted ${deletedCount} memory entry(ies) from repo "${lastRepo}".`,
-    {
-      structuredContentPathHint: "deletedCount",
-      includeSerializedStructuredContent: structured
-    }
-  );
-}
-
-// src/mcp/tools/memory.acknowledge.ts
-async function handleMemoryAcknowledge(params, db2) {
-  const validated = MemoryAcknowledgeSchema.parse(params);
-  let memoryId = validated.memory_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}`);
-    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 ${memoryId} not found.`);
-  }
-  if (validated.status === "used") {
-    db2.memories.incrementRecallCount(memory.id);
-    logger.info("[Tool] memory.acknowledge - used", { id: memory.id, context: validated.application_context });
-  } else if (validated.status === "contradictory") {
-    logger.warn("[Tool] memory.acknowledge - contradiction reported", {
-      id: memory.id,
-      context: validated.application_context
-    });
-  } else {
-    logger.info("[Tool] memory.acknowledge - irrelevant", { id: memory.id, context: validated.application_context });
-  }
-  return createMcpResponse(
-    {
-      success: true,
-      id: memory.id,
-      status: validated.status
-    },
-    `Acknowledged memory [${memory.code}] as "${validated.status}".`,
-    {
-      structuredContentPathHint: "status",
-      includeSerializedStructuredContent: validated.structured
-    }
-  );
-}
-
-// src/mcp/tools/memory.detail.ts
-async function handleMemoryDetail(args, storage) {
-  const validated = MemoryDetailSchema.parse(args);
-  const { id, code, owner, repo } = validated;
-  let memory;
-  if (id) {
-    memory = storage.memories.getById(id);
-  } else if (code) {
-    memory = storage.memories.getByCode(code, owner, repo);
-  }
-  if (!memory) {
-    throw new Error(`Memory not found: ${id || code}`);
-  }
-  storage.memories.incrementHitCount(memory.id);
-  const lines = [
-    `Code: ${memory.code || "-"}`,
-    `ID: ${memory.id}`,
-    `Title: ${memory.title}`,
-    `Type: ${memory.type}`,
-    `Importance: ${memory.importance}`,
-    `Created: ${memory.created_at}`
-  ];
-  if (memory.scope?.repo) lines.push(`Repo: ${memory.scope.repo}`);
-  if (memory.scope?.folder) lines.push(`Folder: ${memory.scope.folder}`);
-  if (memory.content) {
-    lines.push("", "--- Content ---", memory.content);
-  }
-  const content = lines.join("\n");
-  return createMcpResponse(memory, content, {
-    contentSummary: content,
-    includeSerializedStructuredContent: validated.structured
-  });
+  if (memory.scope?.repo) lines.push(`Repo: ${memory.scope.repo}`);
+  if (memory.scope?.folder) lines.push(`Folder: ${memory.scope.folder}`);
+  if (memory.content) {
+    lines.push("", "--- Content ---", memory.content);
+  }
+  const content = lines.join("\n");
+  return createMcpResponse(memory, content, {
+    contentSummary: content,
+    includeSerializedStructuredContent: validated.structured
+  });
 }
 
 // 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;
+import { randomUUID as randomUUID2 } 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_REGEX4.test(value)) return value;
+  if (UUID_REGEX3.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;
@@ -1865,7 +1321,7 @@ async function storeSingleStandard(params, db2, vectors2) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const entry = {
-    id: randomUUID3(),
+    id: randomUUID2(),
     code: generateNextCode(params.owner, params.repo || "__global__", "standard", db2),
     title: params.name,
     content: params.content,
@@ -1948,7 +1404,7 @@ async function handleStandardStore(params, db2, vectors2) {
       const code = generateNextCode(validated.owner ?? "", standardRepo, "standard", db2, batchCodes);
       batchCodes.add(code);
       entries.push({
-        id: randomUUID3(),
+        id: randomUUID2(),
         code,
         title: std.name,
         content: std.content,
@@ -2222,169 +1678,724 @@ async function handleStandardSearch(params, db2, vectors2) {
         columns: [...COLUMNS],
         rows
       }
-    },
-    `Found ${results.length} coding standards matching your query`,
-    {
-      contentSummary,
-      structuredContentPathHint: "results",
-      includeSerializedStructuredContent: true
+    },
+    `Found ${results.length} coding standards matching your query`,
+    {
+      contentSummary,
+      structuredContentPathHint: "results",
+      includeSerializedStructuredContent: true
+    }
+  );
+}
+
+// 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;
+  const standard = db2.standards.getByCode(value, owner, repo);
+  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;
+  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}`);
+    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: ${resolvedId}`);
+  }
+  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 = resolveStandardParentId2(validated.parent_id, db2, existing.owner, existing.repo ?? void 0);
+  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;
+  if (validated.stack !== void 0) updates.stack = validated.stack;
+  if (validated.repo !== void 0) updates.repo = validated.repo;
+  if (validated.is_global !== void 0) updates.is_global = validated.is_global;
+  if (validated.tags !== void 0) updates.tags = validated.tags;
+  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(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(resolvedId, buildStandardVectorText(merged), "standard");
+  }
+  logger.info("[Tool] standard.update - updated coding standard", {
+    standardId: resolvedId,
+    fields: Object.keys(updates)
+  });
+  return createMcpResponse(
+    {
+      success: true,
+      id: resolvedId,
+      code: existing.code,
+      updatedFields: Object.keys(updates)
+    },
+    `Updated coding standard [${existing.code}] in repo "${existing.repo || "global"}". Fields: ${Object.keys(updates).join(", ") || "none"}.`,
+    {
+      structuredContentPathHint: "updatedFields",
+      includeSerializedStructuredContent: true
+    }
+  );
+}
+
+// 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);
+  if (!standard) {
+    const identifier = validated.id ?? validated.code;
+    throw new Error(`Coding standard not found: ${identifier}`);
+  }
+  storage.standards.incrementHitCounts([standard.id]);
+  const lines = [
+    `ID: ${standard.id}`,
+    ...standard.code ? [`Code: ${standard.code}`] : [],
+    `Title: ${standard.title}`,
+    `Parent ID: ${standard.parent_id || "-"}`,
+    `Context: ${standard.context}`,
+    `Version: ${standard.version}`,
+    `Language: ${standard.language || "-"}`,
+    `Scope: ${standard.is_global ? "global" : standard.repo || "-"}`,
+    `Created: ${standard.created_at}`,
+    `Updated: ${standard.updated_at}`
+  ];
+  if (standard.stack.length > 0) lines.push(`Stack: ${standard.stack.join(", ")}`);
+  if (standard.tags.length > 0) lines.push(`Tags: ${standard.tags.join(", ")}`);
+  if (Object.keys(standard.metadata).length > 0) lines.push(`Metadata: ${JSON.stringify(standard.metadata)}`);
+  if (standard.content) {
+    lines.push("", "--- Content ---", standard.content);
+  }
+  const content = lines.join("\n");
+  return createMcpResponse(standard, content, {
+    contentSummary: content,
+    includeSerializedStructuredContent: validated.structured
+  });
+}
+
+// src/mcp/tools/standard.delete.ts
+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 (code) {
+    const entry = db2.standards.getByCode(code, owner, repo);
+    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, owner, repo);
+      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";
+  for (const targetId of targetIds) {
+    const existing = db2.standards.getById(targetId);
+    if (existing) {
+      lastRepo = existing.repo || (existing.is_global ? "global" : lastRepo);
+      deletedTitles.push(existing.title);
+      db2.standards.delete(targetId);
+      await vectors2.remove(targetId, "standard");
+      deletedCount++;
+    } else if (id) {
+      throw new Error(`Coding standard not found: ${targetId}`);
+    }
+  }
+  logger.info("[Tool] standard.delete", { repo: lastRepo, count: deletedCount });
+  return createMcpResponse(
+    {
+      success: true,
+      id: id || void 0,
+      ids: ids || void 0,
+      repo: lastRepo,
+      deletedCount,
+      deletedTitles: deletedTitles.length > 10 ? [...deletedTitles.slice(0, 10), "..."] : deletedTitles
+    },
+    `Deleted ${deletedCount} coding standard(s) from "${lastRepo}".`,
+    {
+      structuredContentPathHint: "deletedCount",
+      includeSerializedStructuredContent: structured
+    }
+  );
+}
+
+// src/mcp/tools/task.create.ts
+import { randomUUID as randomUUID3 } 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 (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}'`);
+  return parent.id;
+}
+function resolveDependsOn(value, owner, repo, storage, localCodeMap) {
+  if (!value) return null;
+  if (UUID_REGEX5.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}'`);
+  return task.id;
+}
+function deriveTaskStatusTimestamps(status, now, existingTask) {
+  const timestamps = {
+    in_progress_at: null,
+    finished_at: null,
+    canceled_at: null
+  };
+  if (status === "in_progress" && existingTask?.status !== "in_progress") {
+    timestamps.in_progress_at = now;
+  }
+  if (status === "completed") {
+    timestamps.finished_at = now;
+  }
+  if (status === "canceled") {
+    timestamps.canceled_at = now;
+  }
+  return timestamps;
+}
+async function archiveTaskToMemory(taskId, repo, storage, vectors2) {
+  const task = storage.tasks.getTaskById(taskId);
+  if (!task) return;
+  const comments = storage.taskComments.getTaskCommentsByTaskId(taskId);
+  let content = `Task: [${task.task_code}] ${task.title}
+`;
+  content += `Phase: ${task.phase}
+`;
+  content += `Description: ${task.description || "No description"}
+`;
+  content += `Commit: ${task.commit_id || "N/A"}
+`;
+  if (task.changed_files && task.changed_files.length > 0) {
+    content += `Files changed:
+`;
+    for (const f of task.changed_files) {
+      content += `  - ${f}
+`;
+    }
+  }
+  if (comments && comments.length > 0) {
+    content += `
+Comments & History:
+`;
+    const chronComments = [...comments].reverse();
+    for (const c of chronComments) {
+      const statusInfo = c.next_status ? ` (Status: ${c.previous_status} -> ${c.next_status})` : "";
+      content += `- [${c.created_at}] ${c.agent}${statusInfo}: ${c.comment}
+`;
+    }
+  }
+  const metadata = {
+    task_id: taskId,
+    task_code: task.task_code,
+    original_metadata: task.metadata
+  };
+  const title = `Completed Task: ${task.title}`;
+  const truncatedTitle = title.length > 100 ? title.substring(0, 97) + "..." : title;
+  try {
+    await handleMemoryStore(
+      {
+        type: "task_archive",
+        title: truncatedTitle,
+        content,
+        importance: Math.min(5, task.priority + 1),
+        agent: task.agent || "system",
+        role: task.role || "unknown",
+        model: "system",
+        scope: { repo, owner: task.owner || "" },
+        tags: ["task-archive", ...task.tags],
+        metadata
+      },
+      storage,
+      vectors2
+    );
+  } catch (error) {
+    logger.error("Failed to archive task to memory", { error: String(error) });
+  }
+}
+
+// src/mcp/tools/task.create.ts
+async function handleTaskCreate(args, storage) {
+  const parsed = TaskCreateSchema.parse(args);
+  const { owner, repo, tasks: bulkTasks, ...singleTask } = parsed;
+  if (bulkTasks) {
+    const createdTasks = [];
+    const tasksToInsert = [];
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    const codesInRequest = /* @__PURE__ */ new Set();
+    const batchCodes = /* @__PURE__ */ new Set();
+    for (const taskData of bulkTasks) {
+      if (!taskData.task_code) {
+        taskData.task_code = generateNextCode(owner ?? "", repo, "task", storage, batchCodes);
+      }
+      batchCodes.add(taskData.task_code);
+    }
+    const allCodes = bulkTasks.map((t) => t.task_code);
+    const existingCodes = storage.tasks.getExistingTaskCodes(owner, repo, allCodes);
+    const initialStats = storage.taskStats.getTaskStats(owner, repo);
+    let pendingInRequestCount = 0;
+    const localCodeMap = /* @__PURE__ */ new Map();
+    for (const taskData of bulkTasks) {
+      localCodeMap.set(taskData.task_code, randomUUID3());
+    }
+    for (const taskData of bulkTasks) {
+      const code = taskData.task_code;
+      if (codesInRequest.has(code)) {
+        throw new Error(`Duplicate task_code in request: '${code}'`);
+      }
+      if (existingCodes.has(code)) {
+        throw new Error(`Duplicate task_code: '${code}' already exists in repository '${repo}'`);
+      }
+      codesInRequest.add(code);
+      const normalizedStatus = taskData.status || "backlog";
+      if (normalizedStatus !== "backlog" && normalizedStatus !== "pending") {
+        throw new Error(`New tasks must be 'backlog' or 'pending'. Task '${code}' has status '${normalizedStatus}'.`);
+      }
+      if (normalizedStatus === "pending") {
+        if (initialStats.todo + pendingInRequestCount >= 10) {
+          throw new Error(
+            `Cannot create task '${code}' as 'pending'. Maximum of 10 pending tasks reached. Please use status 'backlog' for new tasks instead.`
+          );
+        }
+      }
+      const statusTimestamps2 = deriveTaskStatusTimestamps(normalizedStatus, now2);
+      const tags = [...taskData.tags || []];
+      const phaseTag2 = `phase:${taskData.phase}`;
+      if (!tags.includes(phaseTag2)) {
+        tags.push(phaseTag2);
+      }
+      const taskId2 = localCodeMap.get(code);
+      const task2 = {
+        id: taskId2,
+        owner,
+        repo,
+        task_code: code,
+        phase: taskData.phase,
+        title: taskData.title,
+        description: taskData.description,
+        status: normalizedStatus,
+        priority: taskData.priority || 3,
+        agent: taskData.agent || singleTask.agent || "unknown",
+        role: taskData.role || singleTask.role || "unknown",
+        doc_path: taskData.doc_path || null,
+        created_at: now2,
+        updated_at: now2,
+        in_progress_at: statusTimestamps2.in_progress_at,
+        finished_at: statusTimestamps2.finished_at,
+        canceled_at: statusTimestamps2.canceled_at,
+        est_tokens: taskData.est_tokens ?? 0,
+        tags,
+        suggested_skills: taskData.suggested_skills || [],
+        commit_id: null,
+        changed_files: [],
+        metadata: taskData.metadata || {},
+        parent_id: resolveParentId(taskData.parent_id, owner, repo, storage, localCodeMap),
+        depends_on: resolveDependsOn(taskData.depends_on, owner, repo, storage, localCodeMap)
+      };
+      tasksToInsert.push(task2);
+      createdTasks.push(code);
+      if (normalizedStatus === "pending") {
+        pendingInRequestCount++;
+      }
+    }
+    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}"${taskCodesStr}.`,
+      { includeSerializedStructuredContent: parsed.structured || false }
+    );
+  }
+  const {
+    task_code,
+    phase,
+    title,
+    description,
+    status,
+    priority,
+    agent,
+    role,
+    doc_path,
+    metadata,
+    parent_id,
+    depends_on,
+    est_tokens
+  } = singleTask;
+  if (!phase || !title || !description) {
+    throw new Error("Missing required fields for single task creation (phase, title, description)");
+  }
+  const resolvedCode = task_code || generateNextCode(owner ?? "", repo, "task", storage);
+  if (storage.tasks.isTaskCodeDuplicate(owner, repo, resolvedCode)) {
+    throw new Error(`Duplicate task_code: '${resolvedCode}' already exists in repository '${repo}'`);
+  }
+  if (status !== "backlog" && status !== "pending" && status !== void 0) {
+    throw new Error("New tasks must be created with status 'backlog' or 'pending'.");
+  }
+  if (status === "pending") {
+    const stats = storage.taskStats.getTaskStats(owner, 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.`
+      );
+    }
+  }
+  const taskId = randomUUID3();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const statusTimestamps = deriveTaskStatusTimestamps(status || "backlog", now);
+  const finalTags = [...singleTask.tags || []];
+  const phaseTag = `phase:${phase}`;
+  if (!finalTags.includes(phaseTag)) {
+    finalTags.push(phaseTag);
+  }
+  const task = {
+    id: taskId,
+    owner,
+    repo,
+    task_code: resolvedCode,
+    phase,
+    title,
+    description,
+    status: status || "backlog",
+    priority: priority || 3,
+    agent: agent || "unknown",
+    role: role || "unknown",
+    doc_path: doc_path || null,
+    created_at: now,
+    updated_at: now,
+    in_progress_at: statusTimestamps.in_progress_at,
+    finished_at: statusTimestamps.finished_at,
+    canceled_at: statusTimestamps.canceled_at,
+    est_tokens: est_tokens ?? 0,
+    tags: finalTags,
+    suggested_skills: singleTask.suggested_skills || [],
+    commit_id: null,
+    changed_files: [],
+    metadata: metadata || {},
+    parent_id: resolveParentId(parent_id, owner, repo, storage),
+    depends_on: resolveDependsOn(depends_on, owner, repo, storage)
+  };
+  storage.tasks.insertTask(task);
+  return createMcpResponse(
+    {
+      success: true,
+      id: task.id,
+      repo: task.repo,
+      task_code: task.task_code,
+      phase: task.phase,
+      title: task.title,
+      status: task.status,
+      priority: task.priority,
+      depends_on: task.depends_on
+    },
+    `Created task [${task.task_code}] ${task.title} in repo "${task.repo}" with status "${task.status}".`,
+    { includeSerializedStructuredContent: parsed.structured || false }
+  );
+}
+async function handleTaskCreateInteractive(args, storage, options = {}) {
+  const partialTaskData = TaskCreateInteractiveSchema.parse(args ?? {});
+  const inferredRepo = partialTaskData.repo ?? inferRepoFromSession(options.session);
+  const draft = {
+    ...partialTaskData,
+    repo: inferredRepo
+  };
+  const requestedSchema = buildMissingTaskSchema(draft);
+  let completedDraft = draft;
+  if (Object.keys(requestedSchema.properties).length > 0) {
+    if (!options.session?.supportsElicitationForm || !options.elicit) {
+      throw new Error("Client does not advertise MCP elicitation form support");
+    }
+    const elicited = extractAcceptedElicitationContent(
+      await options.elicit({
+        mode: "form",
+        message: "Please complete the missing task details to create a new task.",
+        requestedSchema
+      })
+    );
+    completedDraft = {
+      ...draft,
+      ...elicited
+    };
+  }
+  return await handleTaskCreate(
+    {
+      ...completedDraft,
+      status: completedDraft.status ?? "backlog",
+      priority: completedDraft.priority ?? 3,
+      structured: true
+    },
+    storage
+  );
+}
+function buildMissingTaskSchema(task) {
+  const properties = {};
+  const required = [];
+  addRequiredStringField(properties, required, task, "repo", {
+    title: "Repository",
+    description: "Name of the repository for this task.",
+    minLength: 1
+  });
+  addRequiredStringField(properties, required, task, "phase", {
+    title: "Phase",
+    description: "Project phase or milestone for this task.",
+    minLength: 1
+  });
+  addRequiredStringField(properties, required, task, "title", {
+    title: "Title",
+    description: "Short task title.",
+    minLength: 3,
+    maxLength: 100
+  });
+  addRequiredStringField(properties, required, task, "description", {
+    title: "Description",
+    description: "Detailed description. MUST follow format: 1. Context & Analysis, 2. Step & Implementation, 3. Acceptance & Verification",
+    minLength: 1
+  });
+  if (!task.status) {
+    properties.status = {
+      type: "string",
+      title: "Status",
+      description: "Initial task status.",
+      enum: ["backlog", "pending"],
+      default: "backlog"
+    };
+  }
+  if (task.priority === void 0) {
+    properties.priority = {
+      type: "integer",
+      title: "Priority",
+      description: "Task priority from 1 to 5.",
+      minimum: 1,
+      maximum: 5,
+      default: 3
+    };
+  }
+  return {
+    type: "object",
+    properties,
+    required
+  };
+}
+function addRequiredStringField(properties, required, task, field, schema) {
+  if (typeof task[field] === "string" && task[field].trim()) {
+    return;
+  }
+  properties[field] = {
+    type: "string",
+    ...schema
+  };
+  required.push(field);
+}
+
+// src/mcp/tools/task.update.ts
+import { randomUUID as randomUUID4 } from "crypto";
+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 && !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] : []);
+  if (targetIds.length === 0) {
+    throw new Error("Either 'id' or 'ids' must be provided for update");
+  }
+  let updatedCount = 0;
+  const updatedTasks = [];
+  const completedTaskIds = [];
+  let releasedClaims = 0;
+  let expiredHandoffs = 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const isStatusChangingGlobal = updates.status !== void 0;
+  const existingTasks = storage.tasks.getTasksByIds(targetIds);
+  const taskMap = new Map(existingTasks.map((t) => [t.id, t]));
+  for (const targetId of targetIds) {
+    const existingTask = taskMap.get(targetId);
+    if (!existingTask) {
+      if (id) throw new Error(`Task not found: ${targetId}`);
+      continue;
+    }
+    const isStatusChanging = isStatusChangingGlobal && updates.status !== existingTask.status;
+    if (isStatusChanging && !force) {
+      if (!comment || comment.trim() === "") {
+        throw new Error("comment is required when changing task status");
+      }
+      const isStartable = existingTask.status === "backlog" || existingTask.status === "pending" || existingTask.status === "blocked";
+      if (isStartable && updates.status === "completed") {
+        throw new Error(
+          `Cannot transition task ${targetId} from '${existingTask.status}' directly to 'completed'. Must be 'in_progress' first.`
+        );
+      }
     }
-  );
-}
-
-// 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, owner, repo) {
-  if (!value) return null;
-  if (UUID_REGEX5.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;
-}
-async function handleStandardUpdate(params, db2, vectors2) {
-  const validated = StandardUpdateSchema.parse(params);
-  let resolvedId = validated.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}`);
-    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: ${resolvedId}`);
+    if (updates.status === "completed" && isStatusChanging) {
+      if (updates.est_tokens === void 0) {
+        throw new Error("est_tokens is required when changing task status to completed");
+      }
+      const children = storage.tasks.getChildrenByParentId(targetId);
+      const incompleteChildren = children.filter((c) => c.status !== "completed");
+      if (incompleteChildren.length > 0) {
+        const childList = incompleteChildren.map((c) => `[${c.task_code}] ${c.title} (${c.status})`).join("; ");
+        throw new Error(
+          `Cannot complete task [${existingTask.task_code}] "${existingTask.title}" \u2014 it has ${incompleteChildren.length} incomplete child task(s). Complete the following child task(s) first: ${childList}`
+        );
+      }
+    }
+    if (updates.task_code && storage.tasks.isTaskCodeDuplicate(owner, repo, updates.task_code, targetId)) {
+      throw new Error(`Duplicate task_code: '${updates.task_code}' already exists`);
+    }
+    const finalUpdates = { ...updates };
+    if (updates.parent_id !== void 0) {
+      finalUpdates.parent_id = resolveParentId(updates.parent_id, owner, repo, storage);
+    }
+    if (updates.depends_on !== void 0) {
+      finalUpdates.depends_on = resolveDependsOn(updates.depends_on, owner, repo, storage);
+    }
+    if (updates.phase !== void 0 || updates.tags !== void 0) {
+      let currentTags = updates.tags || existingTask.tags || [];
+      currentTags = currentTags.filter((t) => !t.startsWith("phase:"));
+      const finalPhase = updates.phase !== void 0 ? updates.phase : existingTask.phase;
+      if (finalPhase) {
+        const phaseTag = `phase:${finalPhase}`;
+        if (!currentTags.includes(phaseTag)) {
+          currentTags.push(phaseTag);
+        }
+      }
+      finalUpdates.tags = currentTags;
+    }
+    if (updates.status === "completed") {
+      finalUpdates.finished_at = now;
+      finalUpdates.commit_id = updates.commit_id;
+      finalUpdates.changed_files = updates.changed_files;
+    } else if (updates.status === "canceled") finalUpdates.canceled_at = now;
+    else if (updates.status === "in_progress" && existingTask.status !== "in_progress")
+      finalUpdates.in_progress_at = now;
+    storage.tasks.updateTask(targetId, finalUpdates);
+    if (comment !== void 0 || isStatusChanging) {
+      storage.taskComments.insertTaskComment({
+        id: randomUUID4(),
+        task_id: targetId,
+        owner,
+        repo,
+        comment: comment || `Status updated to ${updates.status}`,
+        agent: updates.agent || existingTask.agent || "unknown",
+        role: updates.role || existingTask.role || "unknown",
+        model: updates.model || "unknown",
+        previous_status: isStatusChanging ? existingTask.status : null,
+        next_status: isStatusChanging ? updates.status : null,
+        created_at: now
+      });
+    }
+    if (updates.status === "completed" && existingTask.status !== "completed") {
+      completedTaskIds.push(targetId);
+    }
+    if (isStatusChanging && (updates.status === "completed" || updates.status === "canceled")) {
+      releasedClaims += storage.handoffs.releaseClaimsForTask(targetId);
+      expiredHandoffs += storage.handoffs.updatePendingHandoffsForTask(targetId, "expired");
+    }
+    updatedTasks.push({ id: targetId, code: updates.task_code || existingTask.task_code });
+    updatedCount++;
   }
-  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 = resolveStandardParentId2(validated.parent_id, db2, existing.owner, existing.repo ?? void 0);
-  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;
-  if (validated.stack !== void 0) updates.stack = validated.stack;
-  if (validated.repo !== void 0) updates.repo = validated.repo;
-  if (validated.is_global !== void 0) updates.is_global = validated.is_global;
-  if (validated.tags !== void 0) updates.tags = validated.tags;
-  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(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(resolvedId, buildStandardVectorText(merged), "standard");
+  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}". 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).`;
   }
-  logger.info("[Tool] standard.update - updated coding standard", {
-    standardId: resolvedId,
-    fields: Object.keys(updates)
-  });
-  return createMcpResponse(
+  const response = createMcpResponse(
     {
       success: true,
-      id: resolvedId,
-      code: existing.code,
-      updatedFields: Object.keys(updates)
+      id: id || void 0,
+      ids: ids || void 0,
+      repo,
+      status: updates.status,
+      updatedCount,
+      updatedFields: Object.keys(updates),
+      coordinationCleanup: {
+        releasedClaims,
+        expiredHandoffs
+      }
     },
-    `Updated coding standard [${existing.code}] in repo "${existing.repo || "global"}". Fields: ${Object.keys(updates).join(", ") || "none"}.`,
-    {
-      structuredContentPathHint: "updatedFields",
-      includeSerializedStructuredContent: true
-    }
+    summaryText,
+    { includeSerializedStructuredContent: updateData.structured }
   );
-}
-
-// 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);
-  if (!standard) {
-    const identifier = validated.id ?? validated.code;
-    throw new Error(`Coding standard not found: ${identifier}`);
-  }
-  storage.standards.incrementHitCounts([standard.id]);
-  const lines = [
-    `ID: ${standard.id}`,
-    ...standard.code ? [`Code: ${standard.code}`] : [],
-    `Title: ${standard.title}`,
-    `Parent ID: ${standard.parent_id || "-"}`,
-    `Context: ${standard.context}`,
-    `Version: ${standard.version}`,
-    `Language: ${standard.language || "-"}`,
-    `Scope: ${standard.is_global ? "global" : standard.repo || "-"}`,
-    `Created: ${standard.created_at}`,
-    `Updated: ${standard.updated_at}`
-  ];
-  if (standard.stack.length > 0) lines.push(`Stack: ${standard.stack.join(", ")}`);
-  if (standard.tags.length > 0) lines.push(`Tags: ${standard.tags.join(", ")}`);
-  if (Object.keys(standard.metadata).length > 0) lines.push(`Metadata: ${JSON.stringify(standard.metadata)}`);
-  if (standard.content) {
-    lines.push("", "--- Content ---", standard.content);
+  if (completedTaskIds.length > 0) {
+    setImmediate(async () => {
+      for (const taskId of completedTaskIds) {
+        try {
+          await archiveTaskToMemory(taskId, repo, storage, vectors2);
+        } catch (err) {
+          logger.error("Failed to archive task to memory", { taskId, error: String(err) });
+        }
+      }
+    });
   }
-  const content = lines.join("\n");
-  return createMcpResponse(standard, content, {
-    contentSummary: content,
-    includeSerializedStructuredContent: validated.structured
-  });
+  return response;
 }
 
-// src/mcp/tools/standard.delete.ts
-async function handleStandardDelete(params, db2, vectors2) {
-  const validated = StandardDeleteSchema.parse(params);
-  const { id, ids, code, codes, owner, repo, structured } = validated;
+// src/mcp/tools/task.delete.ts
+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 (code) {
-    const entry = db2.standards.getByCode(code, owner, repo);
-    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, owner, repo);
-      if (!entry) throw new Error(`Coding standard not found: ${c}`);
-      resolvedIds.push(entry.id);
-    }
+  if (task_code) {
+    const task = storage.tasks.getTaskByCode(owner, 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', 'code', or 'codes' must be provided for deletion");
+    throw new Error("Either 'id', 'ids', or 'task_code' must be provided for deletion");
   }
   const targetIds = resolvedIds;
-  let deletedCount = 0;
-  const deletedTitles = [];
-  let lastRepo = repo || "unknown";
+  const tasksToDelete = storage.tasks.getTasksByIds(targetIds);
+  const deletedCodes = tasksToDelete.map((t) => t.task_code);
   for (const targetId of targetIds) {
-    const existing = db2.standards.getById(targetId);
-    if (existing) {
-      lastRepo = existing.repo || (existing.is_global ? "global" : lastRepo);
-      deletedTitles.push(existing.title);
-      db2.standards.delete(targetId);
-      await vectors2.remove(targetId, "standard");
-      deletedCount++;
-    } else if (id) {
-      throw new Error(`Coding standard not found: ${targetId}`);
-    }
+    storage.tasks.deleteTask(targetId);
   }
-  logger.info("[Tool] standard.delete", { repo: lastRepo, count: deletedCount });
+  const deletedCodesStr = deletedCodes.length > 0 ? `: ${deletedCodes.join(", ")}` : "";
   return createMcpResponse(
     {
       success: true,
       id: id || void 0,
       ids: ids || void 0,
-      repo: lastRepo,
-      deletedCount,
-      deletedTitles: deletedTitles.length > 10 ? [...deletedTitles.slice(0, 10), "..."] : deletedTitles
+      repo,
+      deletedCount: targetIds.length,
+      deletedCodes
     },
-    `Deleted ${deletedCount} coding standard(s) from "${lastRepo}".`,
-    {
-      structuredContentPathHint: "deletedCount",
-      includeSerializedStructuredContent: structured
-    }
+    `Deleted ${targetIds.length} task(s) from repo "${repo}"${deletedCodesStr}.`,
+    { includeSerializedStructuredContent: validated.structured }
   );
 }
 
@@ -2820,7 +2831,7 @@ function normalizeToolArguments(args, session2) {
     const parsed = parseRepoInput(repoVal2, void 0);
     nextArgs.owner = parsed.owner || inferOwnerFromSession(session2) || "";
     if (nextArgs.owner && !repoVal2.includes("/")) {
-      console.warn(
+      logger.warn(
         `[router] owner inferred from session (${nextArgs.owner}) \u2014 may be incorrect. Agents should pass explicit owner/repo.`
       );
     }