claude-memory-admin 1.0.0 → 1.0.1

package/src/model.mjs

@@ -1,5 +1,10 @@
-// Builds the full view model for one project: its index, its memory files, the
-// wikilink graph between them, and the consistency problems worth surfacing.
+// Builds the full view model for one memory store: its index, its memory files,
+// the wikilink graph between them, and the consistency problems worth surfacing.
+//
+// A store is addressed by its directory, not by a root and a slug. Auto memory
+// and subagent memory sit in unrelated places on disk but hold the same shape, so
+// everything below is written against the shape and knows nothing about which
+// kind it was handed.
 //
 // The whole store is a few hundred kilobytes, so this runs per request. No
 // cache, no watcher, no invalidation bugs.
@@ -8,6 +13,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parseIndex, parseFrontmatter, extractWikilinks } from './parse.mjs';
 import { listMemoryFiles, memoryDir, resolveProjectPath, shortLabel } from './projects.mjs';
+import { autoMemoryState } from './settings.mjs';
 import { ageInDays, estimateTokens, findDuplicates, indexStats } from './stats.mjs';
 
 export const TRASH_DIR = '.trash';
@@ -46,6 +52,13 @@ export function loadMemory(dir, file) {
     stat = fs.statSync(path.join(dir, file));
   } catch { /* raced with a delete */ }
 
+  // Claude Code stamps `modified` only on files that already begin with
+  // frontmatter, and never adds frontmatter to a file that has none, so for those
+  // files the mtime fallback is permanent. mtime is also reset by any copy, rsync
+  // or restore - including this tool's own trash round-trip - so which of the two
+  // a date came from is the difference between evidence and a guess.
+  const stamped = typeof metadata.modified === 'string' && metadata.modified ? metadata.modified : null;
+
   return {
     file,
     stem,
@@ -60,7 +73,8 @@ export function loadMemory(dir, file) {
     body,
     raw,
     bytes: stat ? stat.size : raw.length,
-    modified: metadata.modified || (stat ? new Date(stat.mtimeMs).toISOString() : null),
+    modified: stamped || (stat ? new Date(stat.mtimeMs).toISOString() : null),
+    modifiedFrom: stamped ? 'frontmatter' : (stat ? 'mtime' : null),
     tokens: estimateTokens(raw),
     outbound: extractWikilinks(body).map((w) => w.target),
   };
@@ -80,10 +94,8 @@ function buildResolver(memories) {
   return (target) => byName.get(target) || byStem.get(target) || null;
 }
 
-export function buildProject(root, slug) {
-  const dir = memoryDir(root, slug);
-  const projectDir = path.join(root, slug);
-  const resolved = resolveProjectPath(projectDir, slug);
+export function buildStore(store) {
+  const { dir } = store;
   const hasMemoryDir = fs.existsSync(dir);
 
   const indexRaw = readIfExists(path.join(dir, 'MEMORY.md'));
@@ -165,10 +177,7 @@ export function buildProject(root, slug) {
   health.issueCount = health.issues.length;
 
   return {
-    slug,
-    path: resolved.path,
-    label: shortLabel(resolved.path),
-    resolvedBy: resolved.resolvedBy,
+    ...store,
     hasMemoryDir,
     hasIndex: index !== null,
     index: index
@@ -197,6 +206,30 @@ export function buildProject(root, slug) {
   };
 }
 
+/**
+ * The auto-memory store for one project. Everything the project model carries
+ * beyond the store itself - its real path, the directories that feed it, whether
+ * Claude is still writing to it - is resolved here and handed to buildStore.
+ */
+export function buildProject(root, slug) {
+  const resolved = resolveProjectPath(path.join(root, slug), slug);
+  return buildStore({
+    slug,
+    kind: 'auto',
+    dir: memoryDir(root, slug),
+    path: resolved.path,
+    label: shortLabel(resolved.path),
+    resolvedBy: resolved.resolvedBy,
+    // The decode that could not be confirmed, offered as a starting point when
+    // the user is asked to name the path themselves.
+    guess: resolved.guess || null,
+    workingDirs: resolved.workingDirs || [],
+    // Off means this store will never grow again, which on disk looks exactly
+    // like a project Claude has not learned anything about yet.
+    autoMemory: autoMemoryState({ projectDir: resolved.exists ? resolved.path : null }),
+  });
+}
+
 /** Restore records left behind by soft deletes, newest first. */
 export function listTrash(dir) {
   const trashPath = path.join(dir, TRASH_DIR);

package/src/mutate.mjs

@@ -1,4 +1,9 @@
-// The only code in the app that writes. Everything else is read-only.
+// The only code that writes inside a memory store. Everything else is read-only.
+//
+// Every entry point takes the store's directory rather than a root and a slug:
+// auto memory and subagent memory live in unrelated places on disk but hold the
+// same MEMORY.md-plus-topic-files shape, so nothing below needs to know which
+// kind it is working on.
 //
 // Deletes are soft: the file moves into memory/.trash/ and a restore record
 // captures the MEMORY.md lines that were removed, with their original indices,
@@ -8,7 +13,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { parseIndex, removeIndexEntries, removeLine, insertLines, unwrapWikilink } from './parse.mjs';
-import { listMemoryFiles, memoryDir } from './projects.mjs';
+import { listMemoryFiles } from './projects.mjs';
 import { TRASH_DIR, loadMemory } from './model.mjs';
 
 function sha256(text) {
@@ -94,8 +99,7 @@ const writeIndexAtomic = (dir, text) => writeFileAtomic(dir, 'MEMORY.md', text);
  * What a delete would do, without doing it. This is what the confirm dialog
  * renders, so it has to be exhaustive about the collateral.
  */
-export function deletePreview(root, slug, file) {
-  const dir = memoryDir(root, slug);
+export function deletePreview(dir, file) {
   const full = safeMemoryPath(dir, file);
   const exists = fs.existsSync(full);
   const indexText = readIndex(dir);
@@ -165,8 +169,7 @@ export function deletePreview(root, slug, file) {
  * clearing a whole project both come through here, so there is a single restore
  * path rather than three.
  */
-export function deleteMemories(root, slug, files, { includeIndex = false, label = null } = {}) {
-  const dir = memoryDir(root, slug);
+export function deleteMemories(dir, files, { includeIndex = false, label = null } = {}) {
   const wanted = [...new Set([].concat(files))];
   if (!wanted.length) throw new Error('Nothing selected to delete');
 
@@ -221,7 +224,6 @@ export function deleteMemories(root, slug, files, { includeIndex = false, label
     id: `${stamp}_${includeIndex ? 'project' : targets[0].file}`,
     label: label || (targets.length === 1 ? targets[0].name : `${targets.length} memories`),
     deletedAt: new Date().toISOString(),
-    slug,
     files: moved.map(({ file, trashedFile, name, description }) => ({ file, trashedFile, name, description })),
     indexTrashedFile: moved.indexTrashed || null,
     removedLines: removed,
@@ -233,18 +235,16 @@ export function deleteMemories(root, slug, files, { includeIndex = false, label
 }
 
 /** Single-memory delete, optionally cascading to the memories that link to it. */
-export function deleteMemory(root, slug, file, alsoDelete = []) {
+export function deleteMemory(dir, file, alsoDelete = []) {
   const extra = [].concat(alsoDelete).filter((f) => f && f !== file);
-  return deleteMemories(root, slug, [file, ...extra]);
+  return deleteMemories(dir, [file, ...extra]);
 }
 
 /** What clearing a whole project would remove. */
-export function projectDeletePreview(root, slug) {
-  const dir = memoryDir(root, slug);
+export function projectDeletePreview(dir) {
   const files = listMemoryFiles(dir);
   const indexText = readIndex(dir);
   return {
-    slug,
     files: files.map((file) => {
       const memory = loadMemory(dir, file);
       return { file, name: memory?.name || file, description: memory?.description || '' };
@@ -255,8 +255,7 @@ export function projectDeletePreview(root, slug) {
 }
 
 /** Trash every memory in a project, MEMORY.md included, as one operation. */
-export function deleteProject(root, slug) {
-  const dir = memoryDir(root, slug);
+export function deleteProject(dir) {
   const files = listMemoryFiles(dir);
   const indexText = readIndex(dir);
   if (!files.length && indexText === null) throw new Error('This project has no memory to delete');
@@ -274,7 +273,6 @@ export function deleteProject(root, slug) {
       id: `${stamp}_project`,
       label: 'MEMORY.md',
       deletedAt: new Date().toISOString(),
-      slug,
       files: [],
       indexTrashedFile: trashedIndex,
       removedLines: [],
@@ -285,7 +283,7 @@ export function deleteProject(root, slug) {
     return { deleted: true, record };
   }
 
-  return deleteMemories(root, slug, files, {
+  return deleteMemories(dir, files, {
     includeIndex: indexText !== null,
     label: `whole project (${files.length} memories)`,
   });
@@ -295,8 +293,7 @@ export function deleteProject(root, slug) {
  * Turn a broken `[[target]]` into plain text in one memory. The original file
  * is copied into .trash first so the edit can be undone like any delete.
  */
-export function removeWikilink(root, slug, file, target) {
-  const dir = memoryDir(root, slug);
+export function removeWikilink(dir, file, target) {
   const full = safeMemoryPath(dir, file);
   if (!fs.existsSync(full)) throw new Error(`No such memory: ${file}`);
   if (typeof target !== 'string' || !target.trim()) throw new Error('No link target given');
@@ -324,7 +321,6 @@ export function removeWikilink(root, slug, file, target) {
     id: `${stamp}_${file}.unlink`,
     label: `[[${target}]] in ${file}`,
     deletedAt: new Date().toISOString(),
-    slug,
     sourceFile: file,
     target,
     occurrences: count,
@@ -337,8 +333,7 @@ export function removeWikilink(root, slug, file, target) {
 }
 
 /** Undo any trashed operation: a delete, a cascade, a project clear, or an unlink. */
-export function restoreMemory(root, slug, id) {
-  const dir = memoryDir(root, slug);
+export function restoreMemory(dir, id) {
   const trashPath = path.join(dir, TRASH_DIR);
   const recordPath = path.join(trashPath, `${id}.restore.json`);
   if (!fs.existsSync(recordPath)) throw new Error('No such trash record');
@@ -403,8 +398,7 @@ export function restoreMemory(root, slug, id) {
 }
 
 /** Drop a single MEMORY.md line, used to clear a pointer whose file is gone. */
-export function deleteIndexLine(root, slug, lineIndex, expectedText) {
-  const dir = memoryDir(root, slug);
+export function deleteIndexLine(dir, lineIndex, expectedText) {
   const current = readIndex(dir);
   if (current === null) throw new Error('This project has no MEMORY.md');
 

package/src/pathcache.mjs

@@ -0,0 +1,93 @@
+// An opt-in record of project paths the user has confirmed.
+//
+// Claude Code sweeps session transcripts after cleanupPeriodDays but explicitly
+// never touches the memory directory, so the evidence this tool uses to name a
+// store expires while the store itself does not. A project whose transcripts
+// have aged out shows its raw slug forever, and no amount of re-reading brings
+// the name back.
+//
+// Nothing here runs on its own. The file is created only when the user asks for
+// a path to be remembered, and it holds slugs and directory paths - never memory
+// content. That keeps the default behaviour a pure read of the store, and keeps
+// this the only writer outside a memory/ directory.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const CACHE_DIR = process.env.MEMORY_PATH_CACHE_DIR || path.join(os.homedir(), '.claude-memory-admin');
+export const CACHE_FILE = path.join(CACHE_DIR, 'paths.json');
+
+/** Remembered paths by slug, or an empty map. Never throws: a bad file is ignored. */
+export function readPathCache() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/** The remembered path for one slug, only if it still exists on disk. */
+export function rememberedPath(slug) {
+  const entry = readPathCache()[slug];
+  const dir = entry && typeof entry.path === 'string' ? entry.path : null;
+  if (!dir) return null;
+  try {
+    return fs.statSync(dir).isDirectory() ? dir : null;
+  } catch {
+    // Remembered, then moved or deleted. Say nothing rather than assert a path
+    // that is no longer there.
+    return null;
+  }
+}
+
+function writeCache(data) {
+  fs.mkdirSync(CACHE_DIR, { recursive: true });
+  const tmp = `${CACHE_FILE}.tmp-${process.pid}`;
+  const fd = fs.openSync(tmp, 'w');
+  try {
+    fs.writeFileSync(fd, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, CACHE_FILE);
+}
+
+/**
+ * Record a path for a slug. Only an existing directory is accepted: the point is
+ * to preserve a fact that was verifiable once, not to let a typo become the
+ * label a project carries from now on.
+ */
+export function rememberPath(slug, dir) {
+  if (typeof slug !== 'string' || !slug) throw new Error('Invalid project');
+  if (typeof dir !== 'string' || !path.isAbsolute(dir)) {
+    throw new Error('Path must be absolute');
+  }
+  let stat;
+  try {
+    stat = fs.statSync(dir);
+  } catch {
+    throw new Error(`${dir} does not exist`);
+  }
+  if (!stat.isDirectory()) throw new Error(`${dir} is not a directory`);
+
+  const cache = readPathCache();
+  cache[slug] = { path: dir, rememberedAt: new Date().toISOString() };
+  writeCache(cache);
+  return { slug, path: dir };
+}
+
+/** Drop a remembered path. Removing the last one removes the file entirely. */
+export function forgetPath(slug) {
+  const cache = readPathCache();
+  if (!(slug in cache)) return { slug, forgotten: false };
+  delete cache[slug];
+  if (Object.keys(cache).length === 0) {
+    try { fs.unlinkSync(CACHE_FILE); } catch { /* already gone */ }
+  } else {
+    writeCache(cache);
+  }
+  return { slug, forgotten: true };
+}

package/src/projects.mjs

@@ -6,42 +6,57 @@
 // from a path separator. So decoding the slug is a fallback, not the primary
 // method. The reliable source is the session transcripts sitting next to the
 // memory dir, whose JSONL lines carry the true `cwd`.
+//
+// One memory directory can serve several working directories: Claude Code keys
+// the store on the git repository, so every worktree and subdirectory of a repo
+// shares it. Reading a single `cwd` therefore names the store after whichever
+// directory happened to run last, which is why every distinct cwd is collected
+// and the repository root preferred as the store's identity.
 
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { rememberedPath } from './pathcache.mjs';
+import { autoMemoryState, expandHome, resolveMemoryDirectory } from './settings.mjs';
 
 export const DEFAULT_ROOT = path.join(os.homedir(), '.claude', 'projects');
-const USER_SETTINGS = path.join(os.homedir(), '.claude', 'settings.json');
-
-function expandHome(value) {
-  if (value.startsWith('~/')) return path.join(os.homedir(), value.slice(2));
-  return value;
-}
 
 /**
- * Claude Code lets `autoMemoryDirectory` in settings.json move the memory store
- * somewhere else entirely. Honour it, or this tool would confidently show an
- * empty store to anyone who has set it.
+ * Which store to read, and what decided it. The source travels with the path so
+ * the UI can say where a non-default store came from; a tool that silently reads
+ * somewhere other than the default is worse than one that reads nothing.
  */
-export function configuredMemoryDirectory() {
-  try {
-    const settings = JSON.parse(fs.readFileSync(USER_SETTINGS, 'utf8'));
-    const configured = settings?.autoMemoryDirectory;
-    if (typeof configured === 'string' && configured.trim()) return expandHome(configured.trim());
-  } catch {
-    // No settings file, or not readable/parseable: fall through to the default.
+export function resolveRoot() {
+  if (process.env.MEMORY_ROOT) {
+    return { path: expandHome(process.env.MEMORY_ROOT), source: 'flag', file: null, invalid: null };
   }
-  return null;
+  const configured = resolveMemoryDirectory({ projectDir: process.cwd() });
+  if (configured?.path) {
+    return { path: configured.path, source: configured.scope, file: configured.file, invalid: null };
+  }
+  if (configured?.invalid) {
+    // Set, but to something Claude Code would not accept either. Fall back, and
+    // carry the reason so it can be reported rather than swallowed.
+    return {
+      path: DEFAULT_ROOT,
+      source: 'default',
+      file: configured.file,
+      invalid: `autoMemoryDirectory "${configured.raw}" is ${configured.invalid}`,
+    };
+  }
+  return { path: DEFAULT_ROOT, source: 'default', file: null, invalid: null };
 }
 
 export function projectsRoot() {
-  if (process.env.MEMORY_ROOT) return expandHome(process.env.MEMORY_ROOT);
-  return configuredMemoryDirectory() || DEFAULT_ROOT;
+  return resolveRoot().path;
 }
 
-/** Read the first chunk of a file without pulling a multi-megabyte transcript into memory. */
-function readHead(file, bytes = 131072) {
+/**
+ * Read the head of a file without pulling a multi-megabyte transcript into
+ * memory. The `cwd` field shows up within the first few lines in practice, so
+ * the small read almost always suffices and the large one is a fallback.
+ */
+function readHead(file, bytes) {
   const fd = fs.openSync(file, 'r');
   try {
     const buf = Buffer.alloc(bytes);
@@ -73,15 +88,14 @@ function findTranscripts(dir, depth = 2) {
   return out;
 }
 
-/** Pull `cwd` out of the newest transcripts. Authoritative when present. */
-function cwdFromTranscripts(dir) {
-  const transcripts = findTranscripts(dir).sort((a, b) => b.mtime - a.mtime);
-  for (const { file } of transcripts.slice(0, 3)) {
+/** The first `cwd` in one transcript, escalating the read only if the small one missed. */
+function cwdInTranscript(file) {
+  for (const size of [16384, 131072]) {
     let head;
     try {
-      head = readHead(file);
+      head = readHead(file, size);
     } catch {
-      continue;
+      return null;
     }
     for (const line of head.split('\n')) {
       if (!line.includes('"cwd"')) continue;
@@ -92,10 +106,71 @@ function cwdFromTranscripts(dir) {
         // Truncated final line of the chunk, or a non-object line. Skip it.
       }
     }
+    if (head.length < size) return null; // Read the whole file already.
   }
   return null;
 }
 
+/**
+ * Distinct `cwd` values across the newest transcripts, newest first.
+ *
+ * The cap keeps this cheap on projects with hundreds of sessions. It biases
+ * towards recent directories, which is the right bias: a worktree deleted a year
+ * ago is not worth naming the store after.
+ */
+export function cwdsFromTranscripts(dir, { limit = 12 } = {}) {
+  const transcripts = findTranscripts(dir).sort((a, b) => b.mtime - a.mtime);
+  const seen = new Set();
+  for (const { file } of transcripts.slice(0, limit)) {
+    const cwd = cwdInTranscript(file);
+    if (cwd) seen.add(cwd);
+  }
+  return [...seen];
+}
+
+/** Longest path prefix shared by every input, or null when they share only "/". */
+function commonAncestor(paths) {
+  if (paths.length === 0) return null;
+  let parts = paths[0].split('/');
+  for (const other of paths.slice(1)) {
+    const segments = other.split('/');
+    let i = 0;
+    while (i < parts.length && i < segments.length && parts[i] === segments[i]) i += 1;
+    parts = parts.slice(0, i);
+  }
+  const joined = parts.join('/');
+  return joined.length > 1 ? joined : null;
+}
+
+function isGitRoot(dir) {
+  try {
+    return fs.existsSync(path.join(dir, '.git'));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Which of several working directories names the store.
+ *
+ * Claude Code derives the store from the git repository, so when the cwds share
+ * an ancestor that is a repository root, that root is the store's real identity
+ * and every cwd is a worktree or subdirectory of it. When they do not - two
+ * worktrees checked out in unrelated places share a repo but not a path prefix -
+ * there is nothing to confirm, so the newest cwd is used exactly as before
+ * rather than inventing a common parent that means nothing.
+ */
+export function storeIdentity(cwds) {
+  if (cwds.length === 0) return null;
+  if (cwds.length === 1) return { path: cwds[0], resolvedBy: 'transcript' };
+
+  const ancestor = commonAncestor(cwds);
+  if (ancestor && isGitRoot(ancestor)) {
+    return { path: ancestor, resolvedBy: 'repo-root' };
+  }
+  return { path: cwds[0], resolvedBy: 'transcript' };
+}
+
 /**
  * Best-effort slug decode, used only when there is no transcript to read.
  * Candidates are verified against the filesystem so a wrong guess is reported
@@ -116,21 +191,30 @@ function decodeSlug(slug) {
 }
 
 export function resolveProjectPath(dir, slug) {
-  const fromTranscript = cwdFromTranscripts(dir);
-  if (fromTranscript) {
+  const cwds = cwdsFromTranscripts(dir);
+  const identity = storeIdentity(cwds);
+  if (identity) {
     return {
-      path: fromTranscript,
-      resolvedBy: 'transcript',
-      exists: fs.existsSync(fromTranscript),
+      path: identity.path,
+      resolvedBy: identity.resolvedBy,
+      exists: fs.existsSync(identity.path),
+      workingDirs: cwds,
     };
   }
+  // A path the user confirmed once outranks a decode, and is the only thing that
+  // survives Claude Code sweeping the transcripts this store was named from.
+  const remembered = rememberedPath(slug);
+  if (remembered) {
+    return { path: remembered, resolvedBy: 'remembered', exists: true, workingDirs: [] };
+  }
+
   const decoded = decodeSlug(slug);
   if (decoded.verified) {
-    return { path: decoded.path, resolvedBy: 'slug', exists: true };
+    return { path: decoded.path, resolvedBy: 'slug', exists: true, workingDirs: [] };
   }
   // Nothing confirmed the guess, so show the slug rather than a path that
   // looks authoritative and is probably wrong.
-  return { path: slug, resolvedBy: 'unresolved', exists: false, guess: decoded.path };
+  return { path: slug, resolvedBy: 'unresolved', exists: false, guess: decoded.path, workingDirs: [] };
 }
 
 /** A short label for the sidebar: the last two path segments. */
@@ -181,6 +265,8 @@ export function listProjects(root = projectsRoot()) {
         label: shortLabel(resolved.path),
         resolvedBy: resolved.resolvedBy,
         pathExists: resolved.exists,
+        workingDirs: resolved.workingDirs,
+        autoMemory: autoMemoryState({ projectDir: resolved.exists ? resolved.path : null }),
         hasMemoryDir,
         hasIndex: hasMemoryDir && fs.existsSync(path.join(mem, 'MEMORY.md')),
         memoryCount: files.length,

package/src/search.mjs

@@ -3,8 +3,8 @@
 // The whole store is a few hundred kilobytes, so this scans it directly on each
 // query rather than maintaining an index that could go stale.
 
-import { buildProject } from './model.mjs';
-import { listProjects } from './projects.mjs';
+import { buildStore } from './model.mjs';
+import { listStores } from './stores.mjs';
 
 const FIELD_WEIGHT = { name: 6, description: 3, hook: 2, body: 1 };
 
@@ -102,26 +102,28 @@ export function searchProject(project, terms) {
   return { results: results.sort((a, b) => b.score - a.score), indexHits };
 }
 
-/** Search every project under `root`. */
+/** Search every store: auto memory and subagent memory alike. */
 export function searchAll(root, query, { limit = 200 } = {}) {
   const terms = fold(query).split(/\s+/).filter(Boolean);
   if (!terms.length) return { terms, total: 0, projects: [] };
 
-  const projects = [];
+  const stores = [];
   let total = 0;
-  for (const listed of listProjects(root)) {
+  for (const listed of listStores(root)) {
     if (!listed.hasMemoryDir) continue;
-    const project = buildProject(root, listed.slug);
-    const { results, indexHits } = searchProject(project, terms);
+    const store = buildStore(listed);
+    const { results, indexHits } = searchProject(store, terms);
     if (!results.length && !indexHits.length) continue;
     total += results.length;
-    projects.push({
-      slug: listed.slug,
-      label: project.label,
+    stores.push({
+      id: listed.id,
+      kind: listed.kind,
+      label: store.label,
+      sublabel: listed.sublabel || null,
       results: results.slice(0, limit),
       indexHits: indexHits.slice(0, 20),
     });
   }
 
-  return { terms, total, projects: projects.sort((a, b) => b.results.length - a.results.length) };
+  return { terms, total, stores: stores.sort((a, b) => b.results.length - a.results.length) };
 }