npm - @vheins/local-memory-mcp - Versions diffs - 0.9.6 → 0.9.9 - Mend

@vheins/local-memory-mcp 0.9.6 → 0.9.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/{chunk-PWNNK75T.js → chunk-UB4KAJYE.js} +293 -42
package/dist/dashboard/public/assets/index-C2cM-UXM.css +1 -0
package/dist/dashboard/public/assets/index-D-xKLFFr.js +86 -0
package/dist/dashboard/public/index.html +2 -2
package/dist/dashboard/server.js +109 -53
package/dist/mcp/server.js +208 -23
package/dist/prompts/memory-agent-core.md +1 -1
package/dist/prompts/task-management-guidelines.md +4 -2
package/dist/prompts/tool-usage-guidelines.md +4 -2
package/package.json +1 -1
package/dist/dashboard/public/assets/index-C9M1BD7U.js +0 -86
package/dist/dashboard/public/assets/index-CNE1bKgp.css +0 -1

package/dist/dashboard/public/index.html CHANGED Viewed

@@ -8,8 +8,8 @@
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
-  <script type="module" crossorigin src="/assets/index-C9M1BD7U.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-CNE1bKgp.css">
+  <script type="module" crossorigin src="/assets/index-D-xKLFFr.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-C2cM-UXM.css">
 </head>
 <body>
   <div id="app"></div>

package/dist/dashboard/server.js CHANGED Viewed

@@ -10,7 +10,7 @@ import {
   createFileSink,
   listResources,
   logger
-} from "../chunk-PWNNK75T.js";
+} from "../chunk-UB4KAJYE.js";
 // src/dashboard/server.ts
 import express from "express";
@@ -215,7 +215,7 @@ vectors.initialize().catch((err) => {
 });
 // src/dashboard/routes/index.ts
-import { Router as Router5 } from "express";
+import { Router as Router6 } from "express";
 // src/dashboard/routes/system.routes.ts
 import { Router } from "express";
@@ -297,6 +297,7 @@ var SystemController = class {
       uptime: Math.floor((Date.now() - startTime) / 1e3),
       version: pkg.version,
       memoryCount: stats.totalMemories,
+      repoCount: stats.totalRepos,
       pendingRequests: mcpClient.getPendingCount(),
       dbPath: db.getDbPath()
     };
@@ -321,8 +322,7 @@ var SystemController = class {
     try {
       await db.refresh();
       const repo = req.query.repo;
-      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
-      const stats = db.system.getDashboardStats(repo);
+      const stats = repo ? db.system.getDashboardStats(repo) : db.system.getGlobalDashboardStats();
       res.json(jsonApiRes(stats, "system-stats"));
     } catch (err) {
       const message = err instanceof Error ? err.message : "Internal server error";
@@ -723,41 +723,33 @@ var TasksController = class {
       const attributes = getAttributes(req);
       const existingTask = db.tasks.getTaskById(id);
       if (!existingTask) return res.status(404).json(jsonApiError("Task not found", 404));
-      await db.withWrite(() => {
-        db.tasks.updateTask(id, attributes);
-        if (attributes.status && attributes.status !== existingTask.status) {
-          db.actions.logAction("update", existingTask.repo, {
-            taskId: id,
-            query: `Status changed to ${attributes.status}`
-          });
-          db.tasks.insertTaskComment({
-            id: randomUUID2(),
-            task_id: id,
-            repo: existingTask.repo,
-            comment: attributes.comment || `Status updated via dashboard`,
-            agent: "dashboard",
-            role: "user",
-            model: "web-ui",
-            previous_status: existingTask.status,
-            next_status: attributes.status,
-            created_at: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        } else if (attributes.comment) {
-          db.tasks.insertTaskComment({
-            id: randomUUID2(),
-            task_id: id,
-            repo: existingTask.repo,
-            comment: attributes.comment,
-            agent: "dashboard",
-            role: "user",
-            model: "web-ui",
-            previous_status: null,
-            next_status: null,
-            created_at: (/* @__PURE__ */ new Date()).toISOString()
-          });
+      if (!mcpClient.isConnected()) await mcpClient.start();
+      const toolArgs = {
+        repo: existingTask.repo,
+        id,
+        agent: "dashboard",
+        role: "user",
+        model: "web-ui",
+        structured: true
+      };
+      for (const [key, value] of Object.entries(attributes)) {
+        if (value !== void 0) {
+          toolArgs[key] = value;
         }
-      });
-      res.json(jsonApiRes({ message: "Updated" }, "status"));
+      }
+      if (attributes.status && attributes.status !== existingTask.status && !toolArgs.comment) {
+        toolArgs.comment = `Status updated via dashboard to ${attributes.status}`;
+      }
+      if (attributes.status === "completed" && toolArgs.est_tokens === void 0) {
+        toolArgs.est_tokens = existingTask.est_tokens || 0;
+      }
+      await mcpClient.callTool("task-update", toolArgs);
+      await db.refresh();
+      const updatedTask = db.tasks.getTaskById(id);
+      if (!updatedTask) {
+        return res.status(500).json(jsonApiError("Task updated but could not be reloaded", 500));
+      }
+      res.json(jsonApiRes(updatedTask, "task"));
     } catch (err) {
       const message = err instanceof Error ? err.message : "Internal server error";
       res.status(500).json(jsonApiError(message));
@@ -808,23 +800,23 @@ var TasksController = class {
     try {
       await db.refresh();
       const { repo } = req.query;
-      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      const targetRepo = typeof repo === "string" && repo.length > 0 ? repo : null;
       const stats = {
         daily: {
-          ...db.tasks.getTaskTimeStats(repo, "daily"),
-          history: db.tasks.getTaskComparisonSeries(repo, "daily")
+          ...db.tasks.getTaskTimeStats(targetRepo, "daily"),
+          history: db.tasks.getTaskComparisonSeries(targetRepo, "daily")
         },
         weekly: {
-          ...db.tasks.getTaskTimeStats(repo, "weekly"),
-          history: db.tasks.getTaskComparisonSeries(repo, "weekly")
+          ...db.tasks.getTaskTimeStats(targetRepo, "weekly"),
+          history: db.tasks.getTaskComparisonSeries(targetRepo, "weekly")
         },
         monthly: {
-          ...db.tasks.getTaskTimeStats(repo, "monthly"),
-          history: db.tasks.getTaskComparisonSeries(repo, "monthly")
+          ...db.tasks.getTaskTimeStats(targetRepo, "monthly"),
+          history: db.tasks.getTaskComparisonSeries(targetRepo, "monthly")
         },
         overall: {
-          ...db.tasks.getTaskTimeStats(repo, "overall"),
-          history: db.tasks.getTaskComparisonSeries(repo, "overall")
+          ...db.tasks.getTaskTimeStats(targetRepo, "overall"),
+          history: db.tasks.getTaskComparisonSeries(targetRepo, "overall")
         }
       };
       res.json(jsonApiRes(stats, "performance-stats"));
@@ -1039,13 +1031,77 @@ router4.put("/:id", StandardsController.update);
 router4.delete("/:id", StandardsController.delete);
 var standard_routes_default = router4;
-// src/dashboard/routes/index.ts
+// src/dashboard/routes/coordination.routes.ts
+import { Router as Router5 } from "express";
+// src/dashboard/controllers/CoordinationController.ts
+var CoordinationController = class {
+  static async listClaims(req, res) {
+    try {
+      await db.refresh();
+      const { repo, agent, active_only } = req.query;
+      const page = Math.max(1, parseInt(req.query.page || "1", 10));
+      const pageSize = Math.min(100, Math.max(1, parseInt(req.query.pageSize || "20", 10)));
+      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      const claims = db.handoffs.listClaims({
+        repo,
+        agent: typeof agent === "string" ? agent : void 0,
+        active_only: active_only === void 0 ? true : String(active_only) === "true",
+        limit: pageSize,
+        offset: (page - 1) * pageSize
+      });
+      const total = db.handoffs.listClaims({
+        repo,
+        agent: typeof agent === "string" ? agent : void 0,
+        active_only: active_only === void 0 ? true : String(active_only) === "true",
+        limit: 1e5,
+        offset: 0
+      }).length;
+      res.json(
+        jsonApiRes(claims, "claim", {
+          meta: {
+            page,
+            pageSize,
+            totalItems: total,
+            totalPages: Math.ceil(total / pageSize)
+          }
+        })
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async releaseClaim(req, res) {
+    try {
+      const attributes = getAttributes(req);
+      if (!mcpClient.isConnected()) await mcpClient.start();
+      const result = await mcpClient.callTool("claim-release", {
+        ...attributes,
+        structured: true
+      });
+      res.json(jsonApiRes(result.structuredContent || result, "claim-release"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+};
+// src/dashboard/routes/coordination.routes.ts
 var router5 = Router5();
-router5.use("/", system_routes_default);
-router5.use("/memories", memory_routes_default);
-router5.use("/tasks", task_routes_default);
-router5.use("/standards", standard_routes_default);
-var routes_default = router5;
+router5.get("/claims", CoordinationController.listClaims);
+router5.post("/claims/release", CoordinationController.releaseClaim);
+var coordination_routes_default = router5;
+// src/dashboard/routes/index.ts
+var router6 = Router6();
+router6.use("/", system_routes_default);
+router6.use("/memories", memory_routes_default);
+router6.use("/tasks", task_routes_default);
+router6.use("/standards", standard_routes_default);
+router6.use("/coordination", coordination_routes_default);
+var routes_default = router6;
 // src/dashboard/server.ts
 var __dirname3 = path3.dirname(fileURLToPath3(import.meta.url));

package/dist/mcp/server.js CHANGED Viewed

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import {
   CAPABILITIES,
+  ClaimListSchema,
+  ClaimReleaseSchema,
   HandoffCreateSchema,
   HandoffListSchema,
   HandoffUpdateSchema,
@@ -55,7 +57,7 @@ import {
   toContextSlug,
   updateSessionFromInitialize,
   updateSessionRoots
-} from "../chunk-PWNNK75T.js";
+} from "../chunk-UB4KAJYE.js";
 // src/mcp/server.ts
 import readline from "readline";
@@ -1663,6 +1665,16 @@ function buildHandoffListSummary(repo, count, status, fromAgent, 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;
@@ -1708,15 +1720,31 @@ async function handleHandoffList(args, storage) {
     limit,
     offset
   });
-  const COLUMNS = ["id", "from_agent", "to_agent", "task_id", "status", "created_at", "summary"];
+  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.summary
+    handoff.updated_at,
+    handoff.expires_at,
+    handoff.summary,
+    handoff.context
   ]);
   const structuredData = {
     schema: "handoff-list",
@@ -1806,6 +1834,82 @@ async function handleTaskClaim(args, storage) {
   }
   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";
@@ -1901,10 +2005,63 @@ async function handleStandardStore(params, db2, vectors2) {
 // src/mcp/tools/standard.search.ts
 var HYBRID_WEIGHTS_STANDARD = {
-  similarity: 0.55,
-  vector: 0.35,
-  usage: 0.1
+  similarity: 0.4,
+  vector: 0.25,
+  keyword: 0.3,
+  usage: 0.05
 };
+function tokenizeSearchText(value) {
+  return value.toLowerCase().split(/[^a-z0-9]+/g).map((token) => token.trim()).filter((token) => token.length >= 2);
+}
+function scoreKeywordRelevance(query, standard) {
+  const queryTokens = Array.from(new Set(tokenizeSearchText(query)));
+  if (queryTokens.length === 0) return 0;
+  const titleText = standard.title.toLowerCase();
+  const contextText = standard.context.toLowerCase();
+  const tagText = standard.tags.join(" ").toLowerCase();
+  const stackText = standard.stack.join(" ").toLowerCase();
+  const contentText = standard.content.toLowerCase();
+  const queryPhrase = query.trim().toLowerCase();
+  let titleMatches = 0;
+  let contextMatches = 0;
+  let tagMatches = 0;
+  let stackMatches = 0;
+  let contentMatches = 0;
+  for (const token of queryTokens) {
+    if (titleText.includes(token)) titleMatches += 1;
+    if (contextText.includes(token)) contextMatches += 1;
+    if (tagText.includes(token)) tagMatches += 1;
+    if (stackText.includes(token)) stackMatches += 1;
+    if (contentText.includes(token)) contentMatches += 1;
+  }
+  const titleCoverage = titleMatches / queryTokens.length;
+  const contextCoverage = contextMatches / queryTokens.length;
+  const tagCoverage = tagMatches / queryTokens.length;
+  const stackCoverage = stackMatches / queryTokens.length;
+  const contentCoverage = contentMatches / queryTokens.length;
+  const exactPhraseBonus = queryPhrase.length >= 6 && (titleText.includes(queryPhrase) || contentText.includes(queryPhrase) || tagText.includes(queryPhrase)) ? 0.2 : 0;
+  return Math.min(
+    1,
+    titleCoverage * 0.45 + contextCoverage * 0.15 + tagCoverage * 0.15 + stackCoverage * 0.05 + contentCoverage * 0.2 + exactPhraseBonus
+  );
+}
+function collectMatchedTerms(query, standard) {
+  const queryTokens = Array.from(new Set(tokenizeSearchText(query)));
+  if (queryTokens.length === 0) return [];
+  const searchableFields = [
+    standard.title.toLowerCase(),
+    standard.context.toLowerCase(),
+    standard.tags.join(" ").toLowerCase(),
+    standard.stack.join(" ").toLowerCase(),
+    standard.content.toLowerCase()
+  ];
+  return queryTokens.filter((token) => searchableFields.some((field) => field.includes(token)));
+}
+function toConfidence(finalScore, keywordScore) {
+  if (finalScore >= 0.72 || keywordScore >= 0.85) return "high";
+  if (finalScore >= 0.42 || keywordScore >= 0.45) return "medium";
+  return "low";
+}
 async function handleStandardSearch(params, db2, vectors2) {
   const validated = StandardSearchSchema.parse(params);
   const searchQuery = expandQuery(validated.query || "", void 0);
@@ -1936,13 +2093,18 @@ async function handleStandardSearch(params, db2, vectors2) {
     if (similarityResults.length > 0) {
       scoredStandards = similarityResults.map((candidate) => {
         const vectorScore = vectorScoreMap.get(candidate.id) ?? 0;
+        const keywordScore = scoreKeywordRelevance(validated.query || "", candidate);
+        const matchedTerms = collectMatchedTerms(validated.query || "", candidate);
         const usageScore = Math.min(1, candidate.hit_count / 10);
-        const finalScore = candidate.similarity * HYBRID_WEIGHTS_STANDARD.similarity + vectorScore * HYBRID_WEIGHTS_STANDARD.vector + usageScore * HYBRID_WEIGHTS_STANDARD.usage;
+        const finalScore = candidate.similarity * HYBRID_WEIGHTS_STANDARD.similarity + vectorScore * HYBRID_WEIGHTS_STANDARD.vector + keywordScore * HYBRID_WEIGHTS_STANDARD.keyword + usageScore * HYBRID_WEIGHTS_STANDARD.usage;
         return {
           standard: candidate,
           similarityScore: candidate.similarity,
           vectorScore,
-          finalScore
+          keywordScore,
+          matchedTerms,
+          finalScore,
+          confidence: toConfidence(finalScore, keywordScore)
         };
       });
     } else if (vectorResults.length > 0) {
@@ -1951,43 +2113,58 @@ async function handleStandardSearch(params, db2, vectors2) {
       scoredStandards = vectorResults.flatMap((row) => {
         const standard = standardMap.get(row.id);
         if (!standard) return [];
+        const keywordScore = scoreKeywordRelevance(validated.query || "", standard);
+        const matchedTerms = collectMatchedTerms(validated.query || "", standard);
         const usageScore = Math.min(1, standard.hit_count / 10);
+        const finalScore = row.score * HYBRID_WEIGHTS_STANDARD.vector + keywordScore * HYBRID_WEIGHTS_STANDARD.keyword + usageScore * (1 - HYBRID_WEIGHTS_STANDARD.vector - HYBRID_WEIGHTS_STANDARD.keyword);
         return [
           {
             standard,
             similarityScore: 0,
             vectorScore: row.score,
-            finalScore: row.score * 0.9 + usageScore * 0.1
+            keywordScore,
+            matchedTerms,
+            finalScore,
+            confidence: toConfidence(finalScore, keywordScore)
           }
         ];
       });
     }
   } catch (error) {
     logger.warn("Standard vector search failed, using similarity only", { error: String(error) });
-    scoredStandards = similarityResults.map((candidate) => ({
-      standard: candidate,
-      similarityScore: candidate.similarity,
-      vectorScore: 0,
-      finalScore: candidate.similarity * 0.9 + Math.min(1, candidate.hit_count / 10) * 0.1
-    }));
+    scoredStandards = similarityResults.map((candidate) => {
+      const keywordScore = scoreKeywordRelevance(validated.query || "", candidate);
+      const matchedTerms = collectMatchedTerms(validated.query || "", candidate);
+      const finalScore = candidate.similarity * (HYBRID_WEIGHTS_STANDARD.similarity + HYBRID_WEIGHTS_STANDARD.vector * 0.5) + keywordScore * HYBRID_WEIGHTS_STANDARD.keyword + Math.min(1, candidate.hit_count / 10) * HYBRID_WEIGHTS_STANDARD.usage;
+      return {
+        standard: candidate,
+        similarityScore: candidate.similarity,
+        vectorScore: 0,
+        keywordScore,
+        matchedTerms,
+        finalScore,
+        confidence: toConfidence(finalScore, keywordScore)
+      };
+    });
   }
   scoredStandards.sort((a, b) => b.finalScore - a.finalScore);
   const threshold = scoredStandards.length <= 5 ? 0.08 : 0.2;
-  let results = scoredStandards.filter((candidate) => candidate.finalScore >= threshold).map((candidate) => candidate.standard);
+  let results = scoredStandards.filter((candidate) => candidate.finalScore >= threshold);
   if (results.length === 0 && scoredStandards.length > 0) {
-    results = [scoredStandards[0].standard];
+    results = [scoredStandards[0]];
   }
   const paginatedResults = results.slice(validated.offset, validated.offset + validated.limit);
-  db2.standards.incrementHitCounts(paginatedResults.map((standard) => standard.id));
+  db2.standards.incrementHitCounts(paginatedResults.map(({ standard }) => standard.id));
   logger.info("[Tool] standard.search - searched coding standards", {
     resultCount: paginatedResults.length,
     stack: validated.stack,
     language: validated.language,
     context: validated.context,
-    version: validated.version
+    version: validated.version,
+    topConfidence: paginatedResults[0]?.confidence
   });
-  const COLUMNS = ["code", "id", "title", "context", "language", "scope", "tags", "updated_at"];
-  const rows = paginatedResults.map((standard) => [
+  const COLUMNS = ["code", "id", "title", "context", "language", "scope", "tags", "confidence", "score", "matched_terms", "updated_at"];
+  const rows = paginatedResults.map(({ standard, confidence, finalScore, matchedTerms }) => [
     standard.code ?? "-",
     standard.id,
     standard.title,
@@ -1995,15 +2172,18 @@ async function handleStandardSearch(params, db2, vectors2) {
     standard.language || "-",
     standard.is_global ? "global" : standard.repo || "-",
     standard.tags.join(", "),
+    confidence,
+    Number(finalScore.toFixed(3)),
+    matchedTerms.join(", "),
     standard.updated_at
   ]);
   let contentSummary;
   if (paginatedResults.length > 0) {
     const parts = [
       "Standards:",
-      "- code|title|context|language|scope",
+      "- code|confidence|matched_terms|title|context|language|scope",
       ...paginatedResults.map(
-        (standard) => `- ${standard.code ?? "-"}|${standard.title}|${standard.context}|${standard.language || "-"}|${standard.is_global ? "global" : standard.repo || "-"}`
+        ({ standard, confidence, matchedTerms }) => `- ${standard.code ?? "-"}|${confidence}|${matchedTerms.join(", ")}|${standard.title}|${standard.context}|${standard.language || "-"}|${standard.is_global ? "global" : standard.repo || "-"}`
       ),
       "",
       "Use standard-detail with code for full content."
@@ -2283,6 +2463,7 @@ function createRouter(db2, vectors2, options) {
     "task-create",
     "task-create-interactive",
     "task-claim",
+    "claim-release",
     "task-update",
     "task-delete"
   ]);
@@ -2327,6 +2508,10 @@ function createRouter(db2, vectors2, options) {
           return await handleHandoffUpdate(args, db2);
         case "task-claim":
           return await handleTaskClaim(args, db2);
+        case "claim-list":
+          return await handleClaimList(args, db2);
+        case "claim-release":
+          return await handleClaimRelease(args, db2);
         case "standard-store":
           return await handleStandardStore(args, db2, vectors2);
         case "standard-update":

package/dist/prompts/memory-agent-core.md CHANGED Viewed

@@ -18,7 +18,7 @@ You are a memory-aware agent. Memory is project truth, not a suggestion.
 ## Execution Policy
 1. **Orient**: Call `task-list` for active work and `handoff-list` for pending transfers when starting a repository session. Close stale pending handoffs with `handoff-update` when they no longer describe unfinished work.
-2. **Claim**: Use `task-claim` before taking ownership of a concrete task.
+2. **Claim**: Use `task-claim` before taking ownership of a concrete task. Use `claim-list` when ownership is unclear and `claim-release` to clear stale claims during reassignment.
 3. **Search**: Call `memory-search` with `current_file_path` and `current_tags` before coding.
 4. **Standards**: Call `standard-search` when implementation may be governed by coding standards.
 5. **Retrieve**: Use `memory-detail` for full content if search pointer rows are insufficient.

package/dist/prompts/task-management-guidelines.md CHANGED Viewed

@@ -9,8 +9,8 @@ agent: Project Manager
 ## 1. NAVIGATION (`task-list`)
 -   **Sync**: Call `task-list` at every session start (default: `in_progress,pending`).
 -   **Format**: Compact pointer table: `id`, `task_code`, `title`, `status`, `priority`, `updated_at`, `comments_count`. Use `query` for keyword search.
--   **Retrieve**: Fetch full context via `task-detail` AFTER selecting a task.
--   **Coordination**: Check active ownership with task metadata and `task-claim`. NEVER work on tasks claimed by others. Focus on ONE task at a time.
+-   **Retrieve**: Fetch full context via `task-detail` AFTER selecting a task. The hydrated task includes current coordination state such as active claims and pending handoffs.
+-   **Coordination**: Check active ownership with task coordination metadata, `task-claim`, and `claim-list`. NEVER work on tasks claimed by others. Focus on ONE task at a time.
 ## 2. DETAIL TOOLS
 -   **Tasks**: Call `task-detail` for history/comments (ID or `task_code`).
@@ -23,6 +23,8 @@ agent: Project Manager
 -   **Transition Safety**: MUST move from `backlog/pending` → `in_progress` → `completed`. Skipping `in_progress` is forbidden.
 -   **Automatic Cleanup**: `task-update` to `completed` or `canceled` automatically releases active claims and expires pending handoffs linked to that task.
 -   **Claiming**: Use `task-claim` when taking ownership of a task, with `task_code` when working from human-visible queues.
+-   **Claim Inspection**: Use `claim-list` when ownership is unclear or when triaging stale work.
+-   **Claim Release**: Use `claim-release` to clear stale ownership explicitly when a task is being handed back or reassigned.
 -   **Handoff**: Use `handoff-create` only when pausing or transferring unfinished work. Do not use pending handoffs for completion summaries; close consumed/stale handoffs with `handoff-update`.
 -   **Validation**: Only mark `completed` after passing tests or explicitly documenting why verification could not run.
 -   **Archiving**: Completion triggers auto-archive to `task_archive` memory with token reporting.

package/dist/prompts/tool-usage-guidelines.md CHANGED Viewed

@@ -18,7 +18,7 @@ Use the tools in the same flow exposed by the dashboard: navigate with compact l
 ## 2. Task Flow
 - **Navigate**: Start with `task-list` using active statuses (`in_progress,pending`) or explicit filters.
-- **Hydrate**: Use `task-detail` after selecting a task from the list. Do not treat list rows as full task context.
+- **Hydrate**: Use `task-detail` after selecting a task from the list. Full task detail includes comments plus current coordination state such as active claims and pending handoffs.
 - **Mutate**: Use `task-create`, `task-update`, and `task-delete` for lifecycle changes.
 - **Transitions**: Move `backlog/pending/blocked` to `in_progress` before `completed`; include validation evidence and token estimate on completion.
 - **Automatic cleanup**: Moving a task to `completed` or `canceled` automatically releases active claims and expires pending handoffs linked to that task.
@@ -30,11 +30,13 @@ Use the tools in the same flow exposed by the dashboard: navigate with compact l
 - **Scope**: Prefer repo-specific standards for local conventions; use global standards only for cross-repo rules.
 ## 4. Handoff & Claim Flow
-- **Queue**: Use `handoff-list` as the handoff navigation layer. Filter by `status`, `from_agent`, or `to_agent`.
+- **Queue**: Use `handoff-list` as the handoff navigation layer. Filter by `status`, `from_agent`, or `to_agent`. Hydrated handoff rows include `task_code`, `updated_at`, `expires_at`, and structured `context`.
 - **Create handoff**: Use `handoff-create` only when unfinished work needs context transfer. Include `from_agent`, optional `to_agent`, optional `task_code` or `task_id`, concise `summary`, and structured `context` with `next_steps`, `blockers`, or `remaining_work`.
 - **Close handoff**: Use `handoff-update` to move stale or consumed handoffs out of `pending`. Use `accepted` when consumed, `rejected` when declined, and `expired` when obsolete or only a completed-work summary.
 - **No completion handoff**: Do not create pending handoffs for completed-work summaries, release notes, validation notes, or archive records. Put those on `task-update` comments or durable memory.
 - **Claim task**: Use `task-claim` for task ownership. Do not encode claims in memory metadata.
+- **Inspect claims**: Use `claim-list` to inspect active ownership by repo or agent before reassigning work.
+- **Release claims**: Use `claim-release` to explicitly clear stale ownership when work is transferred or abandoned.
 - **Linkage**: Prefer `task_code` for human workflows and `task_id` when already hydrated.
 ## 5. Reference Flow

package/package.json CHANGED Viewed

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