@vheins/local-memory-mcp 0.16.3 → 0.18.0

package/dist/mcp/server.js

@@ -48,6 +48,7 @@ import {
   handleHandoffList,
   handleHandoffUpdate,
   handleTaskClaim,
+  inferOwnerFromSession,
   inferRepoFromSession,
   isPathWithinRoots,
   listPrompts,
@@ -55,12 +56,13 @@ import {
   listResources,
   logger,
   normalizeRepo,
+  parseRepoInput,
   readResource,
   setLogLevel,
   toContextSlug,
   updateSessionFromInitialize,
   updateSessionRoots
-} from "../chunk-MSP4MIT7.js";
+} from "../chunk-YVPDPZXG.js";
 
 // src/mcp/server.ts
 import readline from "readline";
@@ -133,7 +135,7 @@ function getSuggestedRepos(db2, session2) {
 }
 function getSuggestedTags(db2) {
   const values = /* @__PURE__ */ new Set();
-  const memories = db2.memories.getRecentMemories("", 1e3);
+  const memories = db2.memories.getRecentMemories("", "", 1e3);
   for (const memory of memories) {
     for (const tag of memory.tags || []) {
       if (typeof tag === "string" && tag.trim()) {
@@ -146,7 +148,7 @@ function getSuggestedTags(db2) {
 function getSuggestedTasks(db2, session2, contextArguments) {
   const repo = typeof contextArguments.repo === "string" && contextArguments.repo.trim() ? contextArguments.repo.trim() : inferRepoFromSession(session2);
   if (!repo) return [];
-  return db2.tasks.getTasksByRepo(repo, void 0, 100).map((task) => ({
+  return db2.tasks.getTasksByRepo("", repo, void 0, 100).map((task) => ({
     id: task.id,
     task_code: task.task_code,
     title: task.title
@@ -196,7 +198,7 @@ var ENTITY_CONFIG = {
   memory: { prefix: "MEM", table: "memories", column: "code" },
   standard: { prefix: "STD", table: "coding_standards", column: "code" }
 };
-function generateNextCode(repo, entityType, storage, batchCodes) {
+function generateNextCode(owner, repo, entityType, storage, batchCodes) {
   const config = ENTITY_CONFIG[entityType];
   const pattern = `${config.prefix}-%`;
   const offset = config.prefix.length + 2;
@@ -204,9 +206,9 @@ function generateNextCode(repo, entityType, storage, batchCodes) {
     `
     SELECT MAX(CAST(SUBSTR(${config.column}, ?) AS INTEGER)) as max_seq
     FROM ${config.table}
-    WHERE repo = ? AND ${config.column} LIKE ?
+    WHERE owner = ? AND repo = ? AND ${config.column} LIKE ?
   `
-  ).get(offset, repo, pattern);
+  ).get(offset, owner, repo, pattern);
   let nextSeq = (row?.max_seq ?? 0) + 1;
   if (batchCodes) {
     for (const code of batchCodes) {
@@ -247,6 +249,7 @@ async function storeSingleMemory(params, db2, vectors2) {
   if (!resolvedSupersedes && params.type !== "task_archive") {
     const conflict = await db2.memoryVectors.checkConflicts(
       params.content,
+      params.scope.owner,
       params.scope.repo,
       params.type,
       vectors2,
@@ -277,7 +280,7 @@ async function storeSingleMemory(params, db2, vectors2) {
   }
   const entry = {
     id: randomUUID(),
-    code: params.code || generateNextCode(params.scope.repo, "memory", db2),
+    code: params.code || generateNextCode(params.scope.owner ?? "", params.scope.repo, "memory", db2),
     type: params.type,
     title: params.title,
     content: params.content,
@@ -285,7 +288,7 @@ async function storeSingleMemory(params, db2, vectors2) {
     agent: params.agent,
     role: params.role,
     model: params.model,
-    scope: params.scope,
+    scope: { ...params.scope, owner: params.scope.owner },
     created_at: now,
     updated_at: now,
     completed_at: null,
@@ -339,7 +342,14 @@ async function handleMemoryStore(params, db2, vectors2) {
       const expires_at = mem.ttlDays != null ? new Date(createdAtTime + mem.ttlDays * 864e5).toISOString() : null;
       const resolvedSupersedes = resolveMemorySupersedes(mem.supersedes, db2);
       if (!resolvedSupersedes && mem.type !== "task_archive") {
-        const conflict = await db2.memoryVectors.checkConflicts(mem.content, mem.scope.repo, mem.type, vectors2, 0.55);
+        const conflict = await db2.memoryVectors.checkConflicts(
+          mem.content,
+          mem.scope.owner,
+          mem.scope.repo,
+          mem.type,
+          vectors2,
+          0.55
+        );
         if (conflict) {
           return createMcpResponse(
             {
@@ -363,7 +373,7 @@ async function handleMemoryStore(params, db2, vectors2) {
       if (mem.scope.language && !tags.includes(mem.scope.language.toLowerCase())) {
         tags.push(mem.scope.language.toLowerCase());
       }
-      const code = mem.code || generateNextCode(mem.scope.repo, "memory", db2, batchCodes);
+      const code = mem.code || generateNextCode(mem.scope.owner ?? "", mem.scope.repo, "memory", db2, batchCodes);
       batchCodes.add(code);
       entries.push({
         id: randomUUID(),
@@ -375,7 +385,7 @@ async function handleMemoryStore(params, db2, vectors2) {
         agent: mem.agent,
         role: mem.role,
         model: mem.model,
-        scope: mem.scope,
+        scope: { ...mem.scope, owner: mem.scope.owner },
         created_at: now,
         updated_at: now,
         completed_at: null,
@@ -489,7 +499,7 @@ async function handleMemoryUpdate(params, db2, vectors2) {
   if (validated.content !== void 0) {
     await vectors2.upsert(resolvedId, validated.content);
   }
-  db2.actions.logAction("update", existing.scope.repo, { memoryId: resolvedId, resultCount: 1 });
+  db2.actions.logAction("update", existing.scope.owner, existing.scope.repo, { memoryId: resolvedId, resultCount: 1 });
   logger.info("[Tool] memory.update", { repo: existing.scope.repo, id: resolvedId, fields: Object.keys(updates) });
   return createMcpResponse(
     {
@@ -543,6 +553,7 @@ async function handleMemorySearch(params, db2, vectors2) {
   const fetchLimit = (validated.offset + validated.limit) * 3;
   const similarityResults = db2.memoryVectors.searchBySimilarity(
     searchQuery,
+    validated.owner,
     validated.repo,
     fetchLimit,
     validated.include_archived,
@@ -672,7 +683,7 @@ async function handleMemorySummarize(params, db2) {
   const summary = validated.signals.join("\n- ");
   const fullSummary = `Project summary:
 - ${summary}`;
-  db2.summaries.upsertSummary(validated.repo, fullSummary);
+  db2.summaries.upsertSummary(validated.owner, validated.repo, fullSummary);
   const content = `Updated summary for repo "${validated.repo}" with ${validated.signals.length} signals:
 
 ${fullSummary}`;
@@ -713,11 +724,16 @@ function extractAcceptedElicitationContent(result) {
 async function handleMemoryRecap(params, db2) {
   const validated = MemoryRecapSchema.parse(params);
   logger.info("[Tool] memory.recap", { repo: validated.repo, limit: validated.limit, offset: validated.offset });
-  const stats = db2.memories.getStats(validated.repo);
-  const total = db2.memories.getTotalCount(validated.repo, false, ["task_archive"]);
-  const rows = db2.memories.getRecentMemories(validated.repo, validated.limit, validated.offset, false, [
-    "task_archive"
-  ]);
+  const stats = db2.memories.getStats(validated.owner, validated.repo);
+  const total = db2.memories.getTotalCount(validated.owner, validated.repo, false, ["task_archive"]);
+  const rows = db2.memories.getRecentMemories(
+    validated.owner,
+    validated.repo,
+    validated.limit,
+    validated.offset,
+    false,
+    ["task_archive"]
+  );
   const COLUMNS = ["id", "code", "title", "type", "importance"];
   const topRows = rows.map((row) => [row.id, row.code || "-", row.title ?? "Untitled", row.type, row.importance]);
   const byType = {};
@@ -782,19 +798,19 @@ function capitalize2(str) {
 // 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, repo, storage, localCodeMap) {
+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(repo, 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, repo, storage, localCodeMap) {
+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(repo, 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;
 }
@@ -911,7 +927,7 @@ Comments & History:
         agent: task.agent || "system",
         role: task.role || "unknown",
         model: "system",
-        scope: { repo },
+        scope: { repo, owner: task.owner || "" },
         tags: ["task-archive", ...task.tags],
         metadata
       },
@@ -925,6 +941,7 @@ Comments & History:
 async function handleTaskList(args, storage) {
   const validated = TaskListSchema.parse(args);
   const {
+    owner,
     repo,
     status = "backlog,pending,in_progress,blocked",
     phase,
@@ -937,7 +954,7 @@ async function handleTaskList(args, storage) {
   if (status !== "all") {
     statuses = status.split(",").map((s) => s.trim()).filter(Boolean);
   }
-  const tasks = storage.tasks.getTasksByMultipleStatuses(repo, statuses, limit, offset, query);
+  const tasks = storage.tasks.getTasksByMultipleStatuses(owner, repo, statuses, limit, offset, query);
   const filteredTasks = phase ? tasks.filter((t) => t.phase.toLowerCase() === phase.toLowerCase()) : tasks;
   const COLUMNS = ["id", "task_code", "title", "status", "priority", "updated_at", "comments_count"];
   const rows = filteredTasks.map((t) => [
@@ -977,7 +994,7 @@ async function handleTaskList(args, storage) {
 }
 async function handleTaskCreate(args, storage) {
   const parsed = TaskCreateSchema.parse(args);
-  const { repo, tasks: bulkTasks, ...singleTask } = parsed;
+  const { owner, repo, tasks: bulkTasks, ...singleTask } = parsed;
   if (bulkTasks) {
     const createdTasks = [];
     const tasksToInsert = [];
@@ -986,13 +1003,13 @@ async function handleTaskCreate(args, storage) {
     const batchCodes = /* @__PURE__ */ new Set();
     for (const taskData of bulkTasks) {
       if (!taskData.task_code) {
-        taskData.task_code = generateNextCode(repo, "task", storage, batchCodes);
+        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(repo, allCodes);
-    const initialStats = storage.taskStats.getTaskStats(repo);
+    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) {
@@ -1027,6 +1044,7 @@ async function handleTaskCreate(args, storage) {
       const taskId2 = localCodeMap.get(code);
       const task2 = {
         id: taskId2,
+        owner,
         repo,
         task_code: code,
         phase: taskData.phase,
@@ -1048,8 +1066,8 @@ async function handleTaskCreate(args, storage) {
         commit_id: null,
         changed_files: [],
         metadata: taskData.metadata || {},
-        parent_id: resolveParentId(taskData.parent_id, repo, storage, localCodeMap),
-        depends_on: resolveDependsOn(taskData.depends_on, repo, storage, localCodeMap)
+        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);
@@ -1083,15 +1101,15 @@ async function handleTaskCreate(args, storage) {
   if (!phase || !title || !description) {
     throw new Error("Missing required fields for single task creation (phase, title, description)");
   }
-  const resolvedCode = task_code || generateNextCode(repo, "task", storage);
-  if (storage.tasks.isTaskCodeDuplicate(repo, resolvedCode)) {
+  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(repo);
+    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.`
@@ -1108,6 +1126,7 @@ async function handleTaskCreate(args, storage) {
   }
   const task = {
     id: taskId,
+    owner,
     repo,
     task_code: resolvedCode,
     phase,
@@ -1129,8 +1148,8 @@ async function handleTaskCreate(args, storage) {
     commit_id: null,
     changed_files: [],
     metadata: metadata || {},
-    parent_id: resolveParentId(parent_id, repo, storage),
-    depends_on: resolveDependsOn(depends_on, repo, storage)
+    parent_id: resolveParentId(parent_id, owner, repo, storage),
+    depends_on: resolveDependsOn(depends_on, owner, repo, storage)
   };
   storage.tasks.insertTask(task);
   return createMcpResponse(
@@ -1245,10 +1264,10 @@ function addRequiredStringField(properties, required, task, field, schema) {
 }
 async function handleTaskUpdate(args, storage, vectors2) {
   const updateData = TaskUpdateSchema.parse(args);
-  const { repo, id, ids, comment, force, ...updates } = updateData;
+  const { owner, repo, id, ids, comment, force, ...updates } = updateData;
   let resolvedId = id;
   if (!resolvedId && !ids && updates.task_code) {
-    const found = storage.tasks.getTaskByCode(repo, 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;
   }
@@ -1293,10 +1312,10 @@ async function handleTaskUpdate(args, storage, vectors2) {
     }
     const finalUpdates = { ...updates };
     if (updates.parent_id !== void 0) {
-      finalUpdates.parent_id = resolveParentId(updates.parent_id, repo, storage);
+      finalUpdates.parent_id = resolveParentId(updates.parent_id, owner, repo, storage);
     }
     if (updates.depends_on !== void 0) {
-      finalUpdates.depends_on = resolveDependsOn(updates.depends_on, repo, storage);
+      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 || [];
@@ -1322,6 +1341,7 @@ async function handleTaskUpdate(args, storage, vectors2) {
       storage.taskComments.insertTaskComment({
         id: randomUUID2(),
         task_id: targetId,
+        owner,
         repo,
         comment: comment || `Status updated to ${updates.status}`,
         agent: updates.agent || existingTask.agent || "unknown",
@@ -1382,12 +1402,12 @@ async function handleTaskUpdate(args, storage, vectors2) {
 }
 async function handleTaskDelete(args, storage) {
   const validated = TaskDeleteSchema.parse(args);
-  const { repo, id, ids, task_code } = validated;
+  const { owner, repo, id, ids, task_code } = validated;
   const resolvedIds = [];
   if (ids) resolvedIds.push(...ids);
   if (id) resolvedIds.push(id);
   if (task_code) {
-    const task = storage.tasks.getTaskByCode(repo, task_code);
+    const task = storage.tasks.getTaskByCode(owner, repo, task_code);
     if (!task) throw new Error(`Task not found: ${task_code}`);
     resolvedIds.push(task.id);
   }
@@ -1426,10 +1446,14 @@ async function handleMemorySynthesize(params, db2, vectors2, options = {}) {
   if (!repo) {
     throw new Error("repo is required when repo cannot be inferred from active MCP roots");
   }
-  const recap = await handleMemoryRecap({ repo, limit: 8, offset: 0 }, db2);
+  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(repo)?.summary : "";
-  const taskSnapshot = validated.include_tasks ? await handleTaskList({ repo, status: "backlog,pending,in_progress,blocked", limit: 15, offset: 0 }, db2) : null;
+  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.",
@@ -1493,7 +1517,7 @@ ${contextBlock || "No additional context provided."}`
         content: [
           {
             type: "text",
-            text: await executeSamplingTool(toolUse.name, toolUse.input, db2, vectors2)
+            text: await executeSamplingTool(toolUse.name, toolUse.input, db2, vectors2, repoOwner)
           }
         ]
       }))
@@ -1603,11 +1627,12 @@ function buildSamplingTools(session2, useTools) {
     }
   ];
 }
-async function executeSamplingTool(toolName, rawInput, db2, vectors2) {
+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
@@ -1620,6 +1645,7 @@ async function executeSamplingTool(toolName, rawInput, db2, vectors2) {
     case "memory_recap": {
       const response = await handleMemoryRecap(
         {
+          owner,
           repo: rawInput.repo,
           limit: rawInput.limit ?? 8,
           offset: 0
@@ -1631,6 +1657,7 @@ async function executeSamplingTool(toolName, rawInput, db2, vectors2) {
     case "task_list": {
       const response = await handleTaskList(
         {
+          owner,
           repo: rawInput.repo,
           status: rawInput.status,
           search: rawInput.search,
@@ -1810,7 +1837,8 @@ async function storeSingleStandard(params, db2, vectors2) {
   const conflict = db2.standards.checkConflicts(
     params.content,
     incomingVersion,
-    params.repo,
+    params.owner,
+    params.repo ?? void 0,
     incomingLanguage,
     incomingStack,
     0.82
@@ -1837,7 +1865,7 @@ async function storeSingleStandard(params, db2, vectors2) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const entry = {
     id: randomUUID3(),
-    code: generateNextCode(params.repo || "__global__", "standard", db2),
+    code: generateNextCode(params.owner, params.repo || "__global__", "standard", db2),
     title: params.name,
     content: params.content,
     parent_id: resolveStandardParentId(params.parent_id, db2),
@@ -1846,6 +1874,7 @@ async function storeSingleStandard(params, db2, vectors2) {
     language: params.language || null,
     stack: params.stack || [],
     is_global: params.is_global !== false,
+    owner: params.owner,
     repo: params.repo || null,
     tags: params.tags || [],
     metadata: params.metadata,
@@ -1889,7 +1918,8 @@ async function handleStandardStore(params, db2, vectors2) {
       const conflict = db2.standards.checkConflicts(
         std.content,
         incomingVersion,
-        void 0,
+        validated.owner,
+        validated.repo,
         incomingLanguage,
         incomingStack,
         0.82
@@ -1914,7 +1944,7 @@ async function handleStandardStore(params, db2, vectors2) {
         );
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const code = generateNextCode(standardRepo, "standard", db2, batchCodes);
+      const code = generateNextCode(validated.owner ?? "", standardRepo, "standard", db2, batchCodes);
       batchCodes.add(code);
       entries.push({
         id: randomUUID3(),
@@ -1927,6 +1957,7 @@ async function handleStandardStore(params, db2, vectors2) {
         language: std.language || null,
         stack: std.stack || [],
         is_global: std.is_global !== false,
+        owner: validated.owner,
         repo: null,
         tags: std.tags || [],
         metadata: std.metadata,
@@ -1963,6 +1994,7 @@ async function handleStandardStore(params, db2, vectors2) {
       version: validated.version,
       language: validated.language,
       stack: validated.stack,
+      owner: validated.owner,
       repo: validated.repo,
       is_global: validated.is_global,
       tags: validated.tags,
@@ -2357,12 +2389,12 @@ async function handleStandardDelete(params, db2, vectors2) {
 // src/mcp/tools/task.get.ts
 async function handleTaskGet(args, storage) {
   const validated = TaskGetSchema.parse(args);
-  const { repo, id, task_code, structured: isStructuredRequest } = validated;
+  const { owner, repo, id, task_code, structured: isStructuredRequest } = validated;
   let task;
   if (id) {
     task = storage.tasks.getTaskById(id);
   } else if (task_code) {
-    task = storage.tasks.getTaskByCode(repo, task_code);
+    task = storage.tasks.getTaskByCode(owner, repo, task_code);
   } else {
     throw new Error("Either id or task_code must be provided");
   }
@@ -2398,10 +2430,14 @@ async function handleTaskGet(args, storage) {
     if (task.comments_count !== void 0) lines.push(`Comments: ${task.comments_count}`);
     if (task.coordination) {
       if (task.coordination.active_claim_count > 0) {
-        lines.push(`Claim: ${task.coordination.active_claim_agent || "?"} (${task.coordination.active_claim_role || ""}) since ${task.coordination.active_claim_claimed_at || ""}`);
+        lines.push(
+          `Claim: ${task.coordination.active_claim_agent || "?"} (${task.coordination.active_claim_role || ""}) since ${task.coordination.active_claim_claimed_at || ""}`
+        );
       }
       if (task.coordination.pending_handoff_count > 0) {
-        lines.push(`Handoff: ${task.coordination.pending_handoff_summary || ""} \u2192 ${task.coordination.pending_handoff_to_agent || "?"}`);
+        lines.push(
+          `Handoff: ${task.coordination.pending_handoff_summary || ""} \u2192 ${task.coordination.pending_handoff_to_agent || "?"}`
+        );
       }
     }
     lines.push(`Created: ${task.created_at}`);
@@ -2446,17 +2482,27 @@ async function handleTaskGet(args, storage) {
 // src/mcp/tools/task.search.ts
 async function handleTaskSearch(args, storage) {
   const validated = TaskSearchSchema.parse(args);
-  const { repo, query, status, limit, offset, structured: isStructuredRequest = false, phase, priority } = validated;
+  const {
+    owner,
+    repo,
+    query,
+    status,
+    limit,
+    offset,
+    structured: isStructuredRequest = false,
+    phase,
+    priority
+  } = validated;
   let tasks;
   if (status) {
     const statuses = status.split(",").map((s) => s.trim()).filter(Boolean);
     if (statuses.length > 1) {
-      tasks = storage.tasks.getTasksByMultipleStatuses(repo, statuses, void 0, void 0, query);
+      tasks = storage.tasks.getTasksByMultipleStatuses(owner, repo, statuses, void 0, void 0, query);
     } else {
-      tasks = storage.tasks.getTasksByRepo(repo, status, void 0, void 0, query);
+      tasks = storage.tasks.getTasksByRepo(owner, repo, status, void 0, void 0, query);
     }
   } else {
-    tasks = storage.tasks.getTasksByRepo(repo, void 0, void 0, void 0, query);
+    tasks = storage.tasks.getTasksByRepo(owner, repo, void 0, void 0, void 0, query);
   }
   if (phase) {
     const phaseLower = phase.toLowerCase();
@@ -2676,9 +2722,9 @@ function createRouter(db2, vectors2, options) {
         resultCount: Array.isArray(sc?.results) ? sc.results.length : sc?.count || 0
       };
       if (isWrite) {
-        db2.actions.logAction(actionType, repo, logOptions);
+        db2.actions.logAction(actionType, "", repo, logOptions);
       } else {
-        await db2.withWrite(() => db2.actions.logAction(actionType, repo, logOptions));
+        await db2.withWrite(() => db2.actions.logAction(actionType, "", repo, logOptions));
       }
     } catch (e) {
       logger.error("Failed to log action", { toolName, error: String(e) });
@@ -2760,6 +2806,29 @@ function normalizeToolArguments(args, session2) {
   if (scope && !scope.repo) {
     scope.repo = nextArgs.repo ?? inferRepoFromSession(session2);
   }
+  if (!nextArgs.owner) {
+    const repoVal2 = nextArgs.repo || "";
+    const parsed = parseRepoInput(repoVal2, void 0);
+    nextArgs.owner = parsed.owner || inferOwnerFromSession(session2) || "";
+  }
+  if (scope && !scope.owner) {
+    const repoVal2 = scope.repo || nextArgs.repo || "";
+    const parsed = parseRepoInput(repoVal2, void 0);
+    scope.owner = parsed.owner || nextArgs.owner || inferOwnerFromSession(session2) || "";
+  }
+  const ownerVal = nextArgs.owner || inferOwnerFromSession(session2) || "";
+  const repoVal = nextArgs.repo || inferRepoFromSession(session2) || "";
+  const memories = nextArgs.memories;
+  if (memories) {
+    for (const mem of memories) {
+      const memScope = mem.scope;
+      if (memScope) {
+        if (!memScope.owner)
+          memScope.owner = ownerVal || parseRepoInput(memScope.repo || repoVal, void 0).owner || "";
+        if (!memScope.repo) memScope.repo = repoVal;
+      }
+    }
+  }
   if (typeof nextArgs.current_file_path === "string" && scope) {
     const containingRoot = path2.isAbsolute(nextArgs.current_file_path) ? findContainingRoot(nextArgs.current_file_path, session2) : null;
     if (containingRoot) {

package/dist/prompts/csl-from-docs.md

@@ -65,4 +65,4 @@ If you refuse, return exactly:
 }
 ```
 
-Path: {{path}} Repo: {{current_repo}}
+Path: {{path}} Owner: {{current_owner}} Repo: {{current_repo}}

package/dist/prompts/csl-scrapper.md

@@ -70,4 +70,4 @@ If you refuse, return exactly:
 }
 ```
 
-Source: {{source_url}} Repo: {{current_repo}}
+Source: {{source_url}} Owner: {{current_owner}} Repo: {{current_repo}}

package/dist/prompts/server/instructions.md

@@ -5,6 +5,15 @@ description: Main instructions for the MCP server
 
 Local Memory MCP — persistent memory, task coordination, and coding standards for AI agents.
 
+## Data Scoping
+
+All data (memories, tasks, handoffs, claims) is scoped by **owner/repo**:
+
+- **owner** = organization/namespace (e.g., GitHub org, username)
+- **repo** = project/repository name
+
+Pass both `owner` and `repo` whenever a tool requires them. The `owner/repo` pair forms the unique data boundary.
+
 ## Session Start Mode
 
 Entry=orient → hydrate → ready Guard: S(N) req S(N-1)✅

package/package.json

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