fix: query legacy directory-hash tag to preserve existing memories on upgrade

jim80net · claude · jim80net · commit a88b0bd4e3ac · 2026-04-04T21:42:11.000-07:00
Existing users have project memories stored under sha256(directory).
After switching to sha256(normalizeGitUrl(remoteUrl)), those memories
become silently inaccessible. Fix by querying both the new canonical
tag and the legacy directory-based tag for all read operations (search,
list, compaction context), deduplicating by memory ID. Writes go only
to the new canonical tag so memories gradually migrate.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/index.ts b/src/index.ts
@@ -127,15 +127,22 @@ export const SupermemoryPlugin: Plugin = async (ctx: PluginInput) => {
         if (isFirstMessage) {
           injectedSessions.add(input.sessionID);
 
-          const [profileResult, userMemoriesResult, projectMemoriesListResult] = await Promise.all([
+          const [profileResult, userMemoriesResult, projectMemoriesListResult, legacyProjectResult] = await Promise.all([
             supermemoryClient.getProfile(tags.user, userMessage),
             supermemoryClient.searchMemories(userMessage, tags.user),
             supermemoryClient.listMemories(tags.project, CONFIG.maxProjectMemories),
+            tags.legacyProject
+              ? supermemoryClient.listMemories(tags.legacyProject, CONFIG.maxProjectMemories)
+              : Promise.resolve({ success: true, memories: [] } as const),
           ]);
 
           const profile = profileResult.success ? profileResult : null;
           const userMemories = userMemoriesResult.success ? userMemoriesResult : { results: [] };
-          const projectMemoriesList = projectMemoriesListResult.success ? projectMemoriesListResult : { memories: [] };
+          const currentMemories = projectMemoriesListResult.success ? (projectMemoriesListResult.memories || []) : [];
+          const legacyMemories = legacyProjectResult.success ? (legacyProjectResult.memories || []) : [];
+          const seenIds = new Set(currentMemories.map((m: any) => m.id));
+          const mergedMemories = [...currentMemories, ...legacyMemories.filter((m: any) => !seenIds.has(m.id))];
+          const projectMemoriesList = { success: true, memories: mergedMemories };
 
           const projectMemories = {
             results: (projectMemoriesList.memories || []).map((m: any) => ({
@@ -338,22 +345,28 @@ export const SupermemoryPlugin: Plugin = async (ctx: PluginInput) => {
                 }
 
                 if (scope === "project") {
-                  const result = await supermemoryClient.searchMemories(
-                    args.query,
-                    tags.project
-                  );
+                  const [result, legacyResult] = await Promise.all([
+                    supermemoryClient.searchMemories(args.query, tags.project),
+                    tags.legacyProject
+                      ? supermemoryClient.searchMemories(args.query, tags.legacyProject)
+                      : Promise.resolve({ success: true, results: [] } as const),
+                  ]);
                   if (!result.success) {
                     return JSON.stringify({
                       success: false,
                       error: result.error || "Failed to search memories",
                     });
                   }
-                  return formatSearchResults(args.query, scope, result, args.limit);
+                  const merged = mergeSearchResults(result, legacyResult);
+                  return formatSearchResults(args.query, scope, merged, args.limit);
                 }
 
-                const [userResult, projectResult] = await Promise.all([
+                const [userResult, projectResult, legacyProjectResult] = await Promise.all([
                   supermemoryClient.searchMemories(args.query, tags.user),
                   supermemoryClient.searchMemories(args.query, tags.project),
+                  tags.legacyProject
+                    ? supermemoryClient.searchMemories(args.query, tags.legacyProject)
+                    : Promise.resolve({ success: true, results: [] } as const),
                 ]);
 
                 if (!userResult.success || !projectResult.success) {
@@ -363,12 +376,14 @@ export const SupermemoryPlugin: Plugin = async (ctx: PluginInput) => {
                   });
                 }
 
+                const mergedProject = mergeSearchResults(projectResult, legacyProjectResult);
+
                 const combined = [
                   ...(userResult.results || []).map((r) => ({
                     ...r,
                     scope: "user" as const,
                   })),
-                  ...(projectResult.results || []).map((r) => ({
+                  ...(mergedProject.results || []).map((r) => ({
                     ...r,
                     scope: "project" as const,
                   })),
@@ -414,11 +429,15 @@ export const SupermemoryPlugin: Plugin = async (ctx: PluginInput) => {
                 const limit = args.limit || 20;
                 const containerTag =
                   scope === "user" ? tags.user : tags.project;
-
-                const result = await supermemoryClient.listMemories(
-                  containerTag,
-                  limit
-                );
+                const legacyTag =
+                  scope === "project" ? tags.legacyProject : undefined;
+
+                const [result, legacyListResult] = await Promise.all([
+                  supermemoryClient.listMemories(containerTag, limit),
+                  legacyTag
+                    ? supermemoryClient.listMemories(legacyTag, limit)
+                    : Promise.resolve({ success: true, memories: [] } as const),
+                ]);
 
                 if (!result.success) {
                   return JSON.stringify({
@@ -427,7 +446,10 @@ export const SupermemoryPlugin: Plugin = async (ctx: PluginInput) => {
                   });
                 }
 
-                const memories = result.memories || [];
+                const currentMems = result.memories || [];
+                const legacyMems = legacyListResult.success ? (legacyListResult.memories || []) : [];
+                const listSeenIds = new Set(currentMems.map((m: any) => m.id));
+                const memories = [...currentMems, ...legacyMems.filter((m: any) => !listSeenIds.has(m.id))];
                 return JSON.stringify({
                   success: true,
                   scope,
@@ -492,10 +514,23 @@ export const SupermemoryPlugin: Plugin = async (ctx: PluginInput) => {
   };
 };
 
+type SearchResult = { id: string; memory?: string; chunk?: string; similarity?: number };
+type SearchResponse = { success?: boolean; results?: SearchResult[] };
+
+function mergeSearchResults(primary: SearchResponse, legacy: SearchResponse): SearchResponse {
+  const primaryResults = primary.results || [];
+  const legacyResults = legacy.success ? (legacy.results || []) : [];
+  const seenIds = new Set(primaryResults.map((r) => r.id));
+  return {
+    ...primary,
+    results: [...primaryResults, ...legacyResults.filter((r) => !seenIds.has(r.id))],
+  };
+}
+
 function formatSearchResults(
   query: string,
   scope: string | undefined,
-  results: { results?: Array<{ id: string; memory?: string; chunk?: string; similarity?: number }> },
+  results: SearchResponse,
   limit?: number
 ): string {
   const memoryResults = results.results || [];
diff --git a/src/services/compaction.ts b/src/services/compaction.ts
@@ -248,7 +248,7 @@ export interface CompactionContext {
 
 export function createCompactionHook(
   ctx: CompactionContext,
-  tags: { user: string; project: string },
+  tags: { user: string; project: string; legacyProject?: string },
   options?: CompactionOptions
 ) {
   const state: CompactionState = {
@@ -262,9 +262,17 @@ export function createCompactionHook(
 
   async function fetchProjectMemoriesForCompaction(): Promise<string[]> {
     try {
-      const result = await supermemoryClient.listMemories(tags.project, CONFIG.maxProjectMemories);
-      const memories = result.memories || [];
-      return memories.map((m: any) => m.summary || m.content || "").filter(Boolean);
+      const [result, legacyResult] = await Promise.all([
+        supermemoryClient.listMemories(tags.project, CONFIG.maxProjectMemories),
+        tags.legacyProject
+          ? supermemoryClient.listMemories(tags.legacyProject, CONFIG.maxProjectMemories)
+          : Promise.resolve({ success: true, memories: [] } as const),
+      ]);
+      const currentMems = result.memories || [];
+      const legacyMems = legacyResult.success ? (legacyResult.memories || []) : [];
+      const seenIds = new Set(currentMems.map((m: any) => m.id));
+      const allMemories = [...currentMems, ...legacyMems.filter((m: any) => !seenIds.has(m.id))];
+      return allMemories.map((m: any) => m.summary || m.content || "").filter(Boolean);
     } catch (err) {
       log("[compaction] failed to fetch project memories", { error: String(err) });
       return [];
diff --git a/src/services/tags.ts b/src/services/tags.ts
@@ -84,9 +84,26 @@ export function getProjectTag(directory: string): string {
   return `${CONFIG.containerTagPrefix}_project_${sha256(directory)}`;
 }
 
-export function getTags(directory: string): { user: string; project: string } {
+/**
+ * Returns the legacy directory-hash project tag if it differs from the
+ * current (remote-based) tag. Used to query old memories created before
+ * the git-remote-based tagging was introduced.
+ */
+export function getLegacyProjectTag(directory: string): string | undefined {
+  if (CONFIG.projectContainerTag) return undefined;
+
+  const remoteUrl = getGitRemoteUrl(directory);
+  if (!remoteUrl) return undefined;
+
+  // A remote exists, so the canonical tag is remote-based.
+  // Return the old directory-based tag for migration reads.
+  return `${CONFIG.containerTagPrefix}_project_${sha256(directory)}`;
+}
+
+export function getTags(directory: string): { user: string; project: string; legacyProject?: string } {
   return {
     user: getUserTag(),
     project: getProjectTag(directory),
+    legacyProject: getLegacyProjectTag(directory),
   };
 }
