claude-code-session-manager 0.113.0 → 0.114.0

package/src/main/lib/memoryDirResolve.cjs

@@ -0,0 +1,139 @@
+/**
+ * memoryDirResolve.cjs — where Claude Code itself keeps memory.
+ *
+ * Pure resolver (all IO injected) so the Memory tab reads and writes exactly the native locations:
+ *   - workspace memory: ~/.claude/projects/<encoded git-repo root>/memory/ (all worktrees of a
+ *     repo share it), unless the `autoMemoryDirectory` setting overrides it.
+ *   - subagent memory: enabled by a `memory:` frontmatter field on the agent.
+ *
+ * Top-level in lib/ because it spans settings, git and agent files (no single domain folder fits).
+ */
+'use strict';
+
+const path = require('node:path');
+const { encodeCwd } = require('./util/encodeCwd.cjs');
+
+const SCOPES = ['user', 'project', 'local'];
+const NAME_RE = /^[A-Za-z0-9._-]{1,128}$/;
+
+/** Highest-precedence value (local > project > user) of `key` passing `pred`. */
+function pick(settings, key, pred) {
+  for (const layer of ['local', 'project', 'user']) {
+    const s = settings && settings[layer];
+    if (s && typeof s === 'object' && pred(s[key])) return s[key];
+  }
+  return undefined;
+}
+
+function expandDir(value, home, cwd) {
+  if (value === '~') return home;
+  if (value.startsWith('~/')) return path.join(home, value.slice(2));
+  return path.resolve(cwd, value);
+}
+
+function resolveWorkspaceMemoryDir({ home, cwd, settings, repoRoot }) {
+  const override = pick(settings, 'autoMemoryDirectory', (v) => typeof v === 'string' && v.trim() !== '');
+  if (override !== undefined) {
+    return { dir: expandDir(override.trim(), home, cwd), source: 'autoMemoryDirectory' };
+  }
+  return {
+    dir: path.join(home, '.claude', 'projects', encodeCwd(repoRoot || cwd), 'memory'),
+    source: 'default',
+  };
+}
+
+function autoMemoryEnabled(settings) {
+  return pick(settings, 'autoMemoryEnabled', (v) => typeof v === 'boolean') !== false;
+}
+
+function resolveAgentMemoryDir({ home, root, name, scope }) {
+  if (typeof name !== 'string' || !NAME_RE.test(name) || name === '.' || name === '..') {
+    throw new Error(`invalid agent name: ${JSON.stringify(name)}`);
+  }
+  if (!SCOPES.includes(scope)) throw new Error(`unknown memory scope: ${JSON.stringify(scope)}`);
+  if (scope === 'user') return path.join(home, '.claude', 'agent-memory', name);
+  if (typeof root !== 'string' || !root) throw new Error(`scope '${scope}' requires a project root`);
+  return path.join(root, '.claude', scope === 'project' ? 'agent-memory' : 'agent-memory-local', name);
+}
+
+/** Parse the leading `---` block into a flat key -> string map. */
+function parseFrontmatter(text) {
+  const out = {};
+  if (typeof text !== 'string') return out;
+  const lines = text.replace(/^/, '').split(/\r?\n/);
+  if (lines[0].trim() !== '---') return out;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') return out;
+    const m = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(lines[i]);
+    if (m) out[m[1]] = m[2].trim().replace(/^(["'])(.*)\1$/, '$2');
+  }
+  return {}; // unterminated block: not frontmatter
+}
+
+function scanAgents(dir, origin, readDir, readText) {
+  let names;
+  try {
+    names = readDir(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file of names || []) {
+    if (typeof file !== 'string' || !file.endsWith('.md')) continue;
+    const agentFile = path.join(dir, file);
+    let text;
+    try {
+      text = readText(agentFile);
+    } catch {
+      continue;
+    }
+    if (text == null) continue;
+    const fm = parseFrontmatter(text);
+    out.push({
+      name: fm.name || file.slice(0, -3),
+      origin,
+      memoryScope: SCOPES.includes(fm.memory) ? fm.memory : null,
+      agentFile,
+    });
+  }
+  return out;
+}
+
+function listMemoryAgents({ home, root, readDir, readText }) {
+  const byName = new Map();
+  for (const a of scanAgents(path.join(home, '.claude', 'agents'), 'user', readDir, readText)) byName.set(a.name, a);
+  if (root) {
+    for (const a of scanAgents(path.join(root, '.claude', 'agents'), 'project', readDir, readText)) byName.set(a.name, a);
+  }
+  return [...byName.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+
+const rootCache = new Map();
+
+function gitRepoRoot(cwd, execFileSync) {
+  if (rootCache.has(cwd)) return rootCache.get(cwd);
+  let root = null;
+  try {
+    const out = String(
+      execFileSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], {
+        cwd,
+        timeout: 5000,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }),
+    ).trim();
+    if (out.endsWith('/.git')) root = out.slice(0, -'/.git'.length) || null;
+  } catch {
+    root = null;
+  }
+  rootCache.set(cwd, root);
+  return root;
+}
+
+module.exports = {
+  resolveWorkspaceMemoryDir,
+  autoMemoryEnabled,
+  resolveAgentMemoryDir,
+  listMemoryAgents,
+  gitRepoRoot,
+};

package/src/main/lib/memoryIndex.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+/**
+ * Pure helpers for Claude Code's auto-memory index file (MEMORY.md): one line
+ * per memory, `- [Title](file.md) — hook`. Claude Code loads only the first
+ * 200 lines / 25KB of it per session, so an unlisted memory is invisible.
+ * No fs/electron access; callers pass text in and write text out.
+ *
+ * Top-level (not in a lib/ subfolder) to sit beside its sibling memoryStale.cjs.
+ */
+
+const MAX_LINES = 200;
+const MAX_BYTES = 25600;
+const NEAR_LINES = 180;
+const NEAR_BYTES = 23040;
+
+// `- [Title](name.md)` with optional ` — hook` / ` - hook`. Bare file names only
+// (no path separators), so links into subfolders or URLs never match.
+const LINE_RE = /^\s*[-*]\s+\[([^\]]*)\]\(([^)\s/\\]+\.md)\)(?:\s+(?:—|-)\s+(.*?))?\s*$/;
+
+/** Split into lines; a trailing newline does not add a line. */
+function splitLines(text) {
+  if (typeof text !== 'string' || text === '') return [];
+  const lines = text.split('\n');
+  if (lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+function matchLine(raw) {
+  return LINE_RE.exec(raw.replace(/\r$/, ''));
+}
+
+/**
+ * Parse index link lines. Complexity: O(lines).
+ * @param {string|null} text
+ * @returns {{line: string, lineNo: number, title: string, file: string, hook: string}[]}
+ */
+function parseIndex(text) {
+  const out = [];
+  splitLines(text).forEach((raw, i) => {
+    const m = matchLine(raw);
+    if (!m) return;
+    out.push({ line: raw.replace(/\r$/, ''), lineNo: i + 1, title: m[1], file: m[2], hook: m[3] || '' });
+  });
+  return out;
+}
+
+/**
+ * Append an index line unless `file` is already linked. Complexity: O(lines).
+ * @param {string|null} text
+ * @param {{file: string, title: string, hook?: string}} entry
+ * @returns {string}
+ */
+function addIndexLine(text, { file, title, hook }) {
+  const base = typeof text === 'string' ? text : '';
+  if (parseIndex(base).some((e) => e.file === file)) return base;
+  const line = `- [${title}](${file})${hook ? ` — ${hook}` : ''}`;
+  const trimmed = base.replace(/(\r?\n)+$/, '');
+  return `${trimmed === '' ? '' : `${trimmed}\n`}${line}\n`;
+}
+
+/**
+ * Remove every line linking to `file`; other lines are untouched.
+ * Complexity: O(lines).
+ * @param {string|null} text
+ * @param {string} file
+ * @returns {string}
+ */
+function removeIndexLines(text, file) {
+  if (typeof text !== 'string' || text === '') return '';
+  const parts = text.split('\n');
+  const hadTrailing = parts[parts.length - 1] === '';
+  if (hadTrailing) parts.pop();
+  const kept = parts.filter((raw) => {
+    const m = matchLine(raw);
+    return !(m && m[2] === file);
+  });
+  return kept.length === 0 ? '' : kept.join('\n') + (hadTrailing ? '\n' : '');
+}
+
+/**
+ * Index budget + consistency report. Complexity: O((lines + files) log n).
+ * @param {{indexText: string|null, files: string[]}} args
+ */
+function indexHealth({ indexText, files }) {
+  const text = typeof indexText === 'string' ? indexText : '';
+  const lines = splitLines(text).length;
+  const bytes = Buffer.byteLength(text, 'utf8');
+  const overBudget = lines > MAX_LINES || bytes > MAX_BYTES;
+  const nearBudget = !overBudget && (lines >= NEAR_LINES || bytes >= NEAR_BYTES);
+  const present = new Set((files || []).filter((f) => f !== 'MEMORY.md'));
+  const linked = new Set(parseIndex(text).map((e) => e.file));
+  const orphans = [...present].filter((f) => !linked.has(f)).sort();
+  const dangling = [...linked].filter((f) => f !== 'MEMORY.md' && !present.has(f)).sort();
+  return { lines, bytes, maxLines: MAX_LINES, maxBytes: MAX_BYTES, overBudget, nearBudget, orphans, dangling };
+}
+
+module.exports = { parseIndex, addIndexLine, removeIndexLines, indexHealth };

package/src/main/memoryAggregate.cjs

@@ -33,8 +33,15 @@ const { MEMORY_SLUG_RE } = require('./lib/memorySlug.cjs');
 const HOME = os.homedir();
 const CACHE_WRITER = 'memory-clusters';
 
-function memoryDir(workspace) {
-  return path.join(HOME, '.claude', 'projects', workspace, 'memory');
+// Resolved through memoryTool.cjs so cwd-addressed callers read Claude Code's
+// native dir (git root + autoMemoryDirectory); no cwd -> legacy workspace dir.
+async function memoryDir(workspace, cwd) {
+  const { resolveDir } = require('./memoryTool.cjs');
+  try {
+    return (await resolveDir({ workspace, cwd })).dir;
+  } catch {
+    return path.join(HOME, '.claude', 'projects', workspace, 'memory');
+  }
 }
 
 function clustersCachePath(cwd) {
@@ -94,15 +101,15 @@ function parseFrontmatter(text) {
   return { type, description, body: m[2] };
 }
 
-async function listMemoryFiles(workspace) {
-  const dir = memoryDir(workspace);
+async function listMemoryFiles(workspace, cwd) {
+  const dir = await memoryDir(workspace, cwd);
   const r = await config.listDir(dir, { filesOnly: true });
   if (!r.ok) return [];
   return r.entries.filter((e) => MEMORY_SLUG_RE.test(e.name)).map((e) => e.name).sort();
 }
 
-async function readMemories(workspace, names) {
-  const dir = memoryDir(workspace);
+async function readMemories(workspace, names, cwd) {
+  const dir = await memoryDir(workspace, cwd);
   const out = [];
   for (const name of names) {
     const abs = path.join(dir, name);
@@ -178,8 +185,8 @@ async function aggregate({ workspace, refresh, cwd }) {
     return { workspace: ws, generatedAt: null, clusters: [], orphans: [], cached: false };
   }
 
-  const names = await listMemoryFiles(ws);
-  const memories = await readMemories(ws, names);
+  const names = await listMemoryFiles(ws, cwd);
+  const memories = await readMemories(ws, names, cwd);
   const slugs = memories.map((m) => m.slug);
 
   let clusters = [];

package/src/main/memoryTool.cjs

@@ -32,6 +32,14 @@ const config = require('./config.cjs');
 
 const { MEMORY_SLUG_RE: SLUG_RE } = require('./lib/memorySlug.cjs');
 const { scoreMemories } = require('./lib/memoryStale.cjs');
+const { addIndexLine, removeIndexLines, indexHealth } = require('./lib/memoryIndex.cjs');
+const {
+  resolveWorkspaceMemoryDir,
+  autoMemoryEnabled,
+  resolveAgentMemoryDir,
+  listMemoryAgents,
+  gitRepoRoot,
+} = require('./lib/memoryDirResolve.cjs');
 
 const MAX_FILE_BYTES = 1024 * 1024; // 1 MiB
 const MAX_ENTRIES = 1000;
@@ -52,13 +60,59 @@ function workspaceDir(workspace) {
   return path.join(memoryRoot(), workspace, 'memory');
 }
 
+/** Read + parse a settings file; missing/malformed -> null. */
+async function readSettings(abs) {
+  try {
+    const r = await config.readText(abs);
+    if (!r.exists) return null;
+    const parsed = JSON.parse(r.text);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The one place a memory directory is chosen.
+ *   agent -> native subagent memory dir (root = git root of cwd, or cwd)
+ *   cwd   -> Claude Code's native workspace dir (git root + autoMemoryDirectory)
+ *   else  -> legacy ~/.claude/projects/<workspace>/memory
+ * Returns { dir, autoMemoryEnabled }. Throws on an invalid cwd/agent; every path
+ * the callers derive from `dir` still goes through config.validatePath/validateWrite.
+ */
+async function resolveDir({ workspace, cwd, agent } = {}) {
+  const home = os.homedir();
+  const ws = validWorkspaceName(workspace) ? workspace : 'default';
+  if (typeof cwd !== 'string' || !cwd) {
+    if (agent) throw new Error('agent memory requires a cwd');
+    return { dir: workspaceDir(ws), autoMemoryEnabled: true };
+  }
+  const realCwd = config.validatePath(cwd);
+  const root = gitRepoRoot(realCwd, require('node:child_process').execFileSync) || realCwd;
+  const realRoot = config.validatePath(root);
+  // Project-scoped native dirs live under <root>/.claude; validateWrite only
+  // permits that subtree for registered roots.
+  config.addAllowedRoot(realRoot);
+  const settings = {
+    user: await readSettings(path.join(home, '.claude', 'settings.json')),
+    project: await readSettings(path.join(realRoot, '.claude', 'settings.json')),
+    local: await readSettings(path.join(realRoot, '.claude', 'settings.local.json')),
+  };
+  const enabled = autoMemoryEnabled(settings);
+  if (agent) {
+    return { dir: resolveAgentMemoryDir({ home, root: realRoot, name: agent.name, scope: agent.scope }), autoMemoryEnabled: enabled };
+  }
+  const r = resolveWorkspaceMemoryDir({ home, cwd: realCwd, settings, repoRoot: realRoot });
+  return { dir: r.dir, autoMemoryEnabled: enabled };
+}
+
 /**
  * Reject NUL chars, '..' segments, absolute paths, or anything that would
  * resolve outside the workspace dir. Returns the resolved absolute path.
  * The downstream config.cjs helpers add a second layer of validation, but
  * this lets us return a clean error message before we get there.
  */
-function resolveEntryPath(workspace, name) {
+function resolveEntryPath(dir, name) {
   if (typeof name !== 'string' || !name) {
     throw new Error('invalid entry name');
   }
@@ -66,7 +120,6 @@ function resolveEntryPath(workspace, name) {
   if (!SLUG_RE.test(name)) {
     throw new Error(`invalid slug (must match ${SLUG_RE.source}): ${name}`);
   }
-  const dir = workspaceDir(workspace);
   const full = path.resolve(dir, name);
   // path.resolve normalizes; verify the result is still under dir to guard
   // against bizarre name inputs.
@@ -84,12 +137,15 @@ function validWorkspaceName(name) {
   return typeof name === 'string' && /^[a-zA-Z0-9-_]{1,256}$/.test(name);
 }
 
-async function list({ workspace }) {
+async function list({ workspace, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const dir = workspaceDir(ws);
+  let resolved;
+  try { resolved = await resolveDir({ workspace: ws, cwd, agent }); }
+  catch (e) { return { entries: [], workspace: ws, dir: null, autoMemoryEnabled: true, error: e.message }; }
+  const { dir } = resolved;
   const r = await config.listDir(dir, { filesOnly: true });
   if (!r.ok) {
-    return { entries: [], workspace: ws, error: r.error };
+    return { entries: [], workspace: ws, dir, autoMemoryEnabled: resolved.autoMemoryEnabled, error: r.error };
   }
   const entries = r.entries
     .filter((e) => e.name.endsWith('.md'))
@@ -100,12 +156,14 @@ async function list({ workspace }) {
       bytes: e.size,
     }))
     .sort((a, b) => a.name.localeCompare(b.name));
-  return { entries, workspace: ws, error: null };
+  return { entries, workspace: ws, dir, autoMemoryEnabled: resolved.autoMemoryEnabled, error: null };
 }
 
-async function read({ workspace, name }) {
+async function read({ workspace, name, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const abs = resolveEntryPath(ws, name);
+  let abs;
+  try { abs = resolveEntryPath((await resolveDir({ workspace: ws, cwd, agent })).dir, name); }
+  catch (e) { return { content: '', exists: false, mtimeMs: 0, bytes: 0, error: e.message }; }
   const r = await config.readText(abs);
   if (!r.exists) {
     return { content: '', exists: false, mtimeMs: 0, bytes: 0, error: r.error };
@@ -119,7 +177,7 @@ async function read({ workspace, name }) {
   };
 }
 
-async function write({ workspace, name, content }) {
+async function write({ workspace, name, content, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
   if (typeof content !== 'string') {
     return { ok: false, error: 'content must be a string' };
@@ -128,7 +186,9 @@ async function write({ workspace, name, content }) {
   if (bytes > MAX_FILE_BYTES) {
     return { ok: false, error: `file exceeds 1 MiB cap (${bytes} bytes)` };
   }
-  const abs = resolveEntryPath(ws, name);
+  let abs;
+  try { abs = resolveEntryPath((await resolveDir({ workspace: ws, cwd, agent })).dir, name); }
+  catch (e) { return { ok: false, error: e.message }; }
   // Enforce per-workspace entry cap on creates (writes to existing files are
   // always allowed regardless of count). Cheap fs.stat check rather than a
   // full directory enumeration where possible.
@@ -136,7 +196,7 @@ async function write({ workspace, name, content }) {
   try { await fsp.access(abs, fs.constants.F_OK); }
   catch { exists = false; }
   if (!exists) {
-    const l = await list({ workspace: ws });
+    const l = await list({ workspace: ws, cwd, agent });
     if (l.entries.length >= MAX_ENTRIES) {
       return { ok: false, error: `workspace at ${MAX_ENTRIES}-entry cap` };
     }
@@ -149,9 +209,22 @@ async function write({ workspace, name, content }) {
   }
 }
 
-async function deleteEntry({ workspace, name }) {
+const INDEX_NAME = 'MEMORY.md';
+
+/** Read <dir>/MEMORY.md; missing/unreadable -> null. */
+async function readIndexText(dir) {
+  const r = await config.readText(path.join(dir, INDEX_NAME));
+  return r.exists ? r.text : null;
+}
+
+async function deleteEntry({ workspace, name, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const abs = resolveEntryPath(ws, name);
+  let abs;
+  let dir;
+  try {
+    dir = (await resolveDir({ workspace: ws, cwd, agent })).dir;
+    abs = resolveEntryPath(dir, name);
+  } catch (e) { return { ok: false, error: e.message }; }
   // Route through config.cjs::validatePath (home-boundary pin, symlink-safe)
   // plus validateWrite (write-prefix pin) — same contract every other
   // mutating call in the codebase follows. Complexity: O(1) per call.
@@ -164,16 +237,30 @@ async function deleteEntry({ workspace, name }) {
   }
   try {
     await fsp.unlink(real);
-    return { ok: true, error: null };
   } catch (e) {
-    if (e.code === 'ENOENT') return { ok: true, error: null };
-    return { ok: false, error: e.message };
+    if (e.code !== 'ENOENT') return { ok: false, error: e.message };
+  }
+  if (name === INDEX_NAME) return { ok: true, error: null };
+  try {
+    const text = await readIndexText(dir);
+    if (text !== null) {
+      const next = removeIndexLines(text, name);
+      if (next !== text) await config.writeTextAtomic(path.join(dir, INDEX_NAME), next);
+    }
+  } catch (e) {
+    return { ok: true, error: null, indexError: e.message };
   }
+  return { ok: true, error: null };
 }
 
-async function create({ workspace, name, description }) {
+async function create({ workspace, name, description, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const abs = resolveEntryPath(ws, name);
+  let abs;
+  let dir;
+  try {
+    dir = (await resolveDir({ workspace: ws, cwd, agent })).dir;
+    abs = resolveEntryPath(dir, name);
+  } catch (e) { return { ok: false, error: e.message }; }
   // Refuse to overwrite — create is strictly "new file".
   try {
     await fsp.access(abs, fs.constants.F_OK);
@@ -190,7 +277,16 @@ async function create({ workspace, name, description }) {
     desc || `# ${stem}`,
     '',
   ].join('\n');
-  return await write({ workspace: ws, name, content: fm });
+  const w = await write({ workspace: ws, name, content: fm, cwd, agent });
+  if (!w.ok || name === INDEX_NAME) return w;
+  try {
+    const text = (await readIndexText(dir)) || '';
+    const next = addIndexLine(text, { file: name, title: stem, hook: desc.replace(/\n/g, ' ') });
+    if (next !== text) await config.writeTextAtomic(path.join(dir, INDEX_NAME), next);
+  } catch (e) {
+    return { ...w, indexError: e.message };
+  }
+  return w;
 }
 
 /**
@@ -200,9 +296,11 @@ async function create({ workspace, name, description }) {
  * the dead-ref existence check. Absent/invalid cwd disables dead-ref
  * detection entirely rather than mass-flagging memories.
  */
-async function stale({ workspace, cwd }) {
+async function stale({ workspace, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const dir = workspaceDir(ws);
+  let dir;
+  try { dir = (await resolveDir({ workspace: ws, cwd, agent })).dir; }
+  catch (e) { return { entries: [], workspace: ws, error: e.message }; }
   const r = await config.listDir(dir, { filesOnly: true });
   if (!r.ok) {
     return { entries: [], workspace: ws, error: r.error };
@@ -236,7 +334,30 @@ async function stale({ workspace, cwd }) {
     entries.push({ name, mtimeMs: r2.mtimeMs, body: r2.text });
   }
 
-  return { entries: scoreMemories({ entries, now: Date.now(), existsPath }), workspace: ws, error: null };
+  const index = indexHealth({ indexText: await readIndexText(dir), files: r.entries.map((e) => e.name).filter((n) => n.endsWith('.md')) });
+  return { entries: scoreMemories({ entries, now: Date.now(), existsPath }), workspace: ws, error: null, index };
+}
+
+/** Agents (user + project) with their `memory:` frontmatter scope. */
+async function agents({ cwd } = {}) {
+  const home = os.homedir();
+  let root = null;
+  if (typeof cwd === 'string' && cwd) {
+    try {
+      const realCwd = config.validatePath(cwd);
+      root = config.validatePath(gitRepoRoot(realCwd, require('node:child_process').execFileSync) || realCwd);
+    } catch {
+      root = null;
+    }
+  }
+  return {
+    agents: listMemoryAgents({
+      home,
+      root,
+      readDir: (d) => fs.readdirSync(d),
+      readText: (f) => fs.readFileSync(f, 'utf8'),
+    }),
+  };
 }
 
 function registerMemoryHandlers() {
@@ -247,6 +368,7 @@ function registerMemoryHandlers() {
   ipcMain.handle('memory:delete', v(s.memoryDelete, deleteEntry));
   ipcMain.handle('memory:create', v(s.memoryCreate, create));
   ipcMain.handle('memory:stale', v(s.memoryStale, stale));
+  ipcMain.handle('memory:agents', v(s.memoryAgents, agents));
 }
 
 module.exports = {
@@ -255,5 +377,12 @@ module.exports = {
   // exported for tests
   memoryRoot,
   workspaceDir,
+  resolveDir,
+  list,
+  read,
+  write,
+  create,
+  deleteEntry,
+  agents,
   stale,
 };