claude-code-session-manager 0.35.17 → 0.36.0

package/src/main/files.cjs

@@ -14,6 +14,7 @@
  */
 
 const { ipcMain, shell } = require('electron');
+const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
@@ -21,6 +22,7 @@ const os = require('node:os');
 const { z } = require('zod');
 const { assertInsideHome } = require('./lib/insideHome.cjs');
 const { expandHome } = require('./lib/expandHome.cjs');
+const { schemas } = require('./ipcSchemas.cjs');
 
 /**
  * Validates that the path is under the home directory. Returns the realpath
@@ -238,6 +240,51 @@ async function renameEntry(oldPath, newName) {
   }
 }
 
+// Pure name generator for files:duplicate — `<stem>-copy<ext>`, then
+// `<stem>-copy-2<ext>`, `-copy-3`, … `exists(fullPath)` is injected so tests
+// can probe collisions without touching the filesystem.
+const DUPLICATE_MAX_ATTEMPTS = 20;
+function duplicateNameFor(dir, base, exists) {
+  const ext = path.extname(base);
+  const stem = base.slice(0, base.length - ext.length);
+  for (let i = 0; i < DUPLICATE_MAX_ATTEMPTS; i++) {
+    const candidate = i === 0 ? `${stem}-copy${ext}` : `${stem}-copy-${i + 1}${ext}`;
+    if (!exists(path.join(dir, candidate))) return { ok: true, name: candidate };
+  }
+  return { ok: false, error: 'Too many copies of this file already exist' };
+}
+
+async function duplicateEntry(filePath) {
+  let resolved;
+  try { resolved = validateHomePath(filePath); }
+  catch (e) { return { ok: false, error: e.message }; }
+  try { rejectCredentials(resolved); }
+  catch (e) { return { ok: false, error: e.message }; }
+
+  let st;
+  try { st = await fsp.stat(resolved); }
+  catch (e) { return { ok: false, error: e.message }; }
+  if (st.isDirectory()) return { ok: false, error: 'Cannot duplicate a directory' };
+
+  const dir = path.dirname(resolved);
+  const base = path.basename(resolved);
+  const nameResult = duplicateNameFor(dir, base, (full) => {
+    try { fs.accessSync(full); return true; } catch { return false; }
+  });
+  if (!nameResult.ok) return nameResult;
+
+  const target = path.join(dir, nameResult.name);
+  try { validateHomePath(target); } catch (e) { return { ok: false, error: e.message }; }
+  try { rejectCredentials(target); } catch (e) { return { ok: false, error: e.message }; }
+
+  try {
+    await fsp.copyFile(resolved, target, fs.constants.COPYFILE_EXCL);
+    return { ok: true, path: target, error: null };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
 const CRITICAL_PATHS = new Set([os.homedir(), '/', '/usr', '/bin', '/etc', '/var', '/System', '/Applications']);
 
 async function deleteEntry(filePath) {
@@ -330,6 +377,10 @@ function registerFilesHandlers() {
     const { path: p, newName } = filesRename.parse(payload);
     return renameEntry(p, newName);
   });
+  ipcMain.handle('files:duplicate', (_e, payload) => {
+    const { path: p } = schemas.filesDuplicate.parse(payload);
+    return duplicateEntry(p);
+  });
   ipcMain.handle('files:delete', (_e, payload) => {
     const { path: p } = filesPath.parse(payload);
     return deleteEntry(p);
@@ -353,4 +404,6 @@ module.exports = {
   createEntry,
   renameEntry,
   deleteEntry,
+  duplicateEntry,
+  duplicateNameFor,
 };

package/src/main/historyAggregator.cjs

@@ -317,7 +317,7 @@ async function aggregate(req) {
   try {
     projectDirs = await fsp.readdir(PROJECTS_DIR, { withFileTypes: true });
   } catch {
-    return { rows: [], partial: false, truncated: false, scannedMs: Date.now() - t0 };
+    return { rows: [], partial: false, truncated: false, scannedMs: Date.now() - t0, cacheSavingsUsd: 0 };
   }
 
   outer:

package/src/main/index.cjs

@@ -48,6 +48,7 @@ const agentMemory = require('./agentMemory.cjs');
 const git = require('./git.cjs');
 const superagent = require('./superagent.cjs');
 const filesIpc = require('./files.cjs');
+const { registerDocEditHandlers } = require('./docEdit.cjs');
 const searchIpc = require('./search.cjs');
 const repoAnalyzer = require('./repoAnalyzer.cjs');
 const hivesIpc = require('./hives.cjs');
@@ -749,6 +750,7 @@ agentMemory.registerAgentMemoryHandlers();
 git.register(ipcMain);
 superagent.registerSuperAgentHandlers();
 filesIpc.registerFilesHandlers();
+registerDocEditHandlers();
 searchIpc.registerSearchHandlers();
 repoAnalyzer.register(ipcMain);
 hivesIpc.registerHiveHandlers();

package/src/main/ipcSchemas.cjs

@@ -351,6 +351,14 @@ const memoryCreate = z.object({
   description: z.string().max(2048).optional(),
 }).strict();
 
+// memory:stale — deterministic staleness scorer (PRD 601). `cwd`, when given,
+// is only used for the dead-ref existence check and is re-validated via
+// config.validatePath in memoryTool.cjs before use.
+const memoryStale = z.object({
+  workspace: z.string().regex(MEMORY_WORKSPACE_RE).optional(),
+  cwd: z.string().max(4096).optional(),
+}).strict();
+
 // memory:aggregate — Memory Clusters (PRD 356). `workspace` here is already
 // the encoded cwd slug (memoryAggregate.cjs reads directly from
 // ~/.claude/projects/<workspace>/memory/), same regex as the other memory:*
@@ -401,6 +409,19 @@ const exchangesList = z.object({
   offset: z.number().int().min(0).max(100000).optional(),
 }).strict();
 
+// ──────────────────────────────────────────── Files (duplicate)
+// files:duplicate — the rest of files:* keeps its schemas local to files.cjs;
+// this one lives here per PRD 638 so it's reusable without importing files.cjs.
+const filesDuplicate = z.object({ path: z.string().min(1).max(4096) });
+
+// ──────────────────────────────────────────── Doc Edit (PRD 638 rewrite runner)
+// docedit:run — consumed by docEdit.cjs's registerDocEditHandlers.
+const docEditRun = z.object({
+  path: z.string().min(1).max(4096),
+  before: z.string().min(1).max(8000),
+  instruction: z.string().min(1).max(2000),
+}).strict();
+
 // ──────────────────────────────────────────── Chat runner (PRD 319)
 // Prompt cap: 100 KiB. Matches a generous interactive message budget while
 // preventing accidental megabyte pastes from reaching claude -p.
@@ -705,6 +726,7 @@ module.exports = {
     memoryDelete,
     memoryCreate,
     memoryAggregate,
+    memoryStale,
     agentMemoryList,
     agentMemoryGet,
     agentMemorySet,
@@ -713,6 +735,8 @@ module.exports = {
     watchersList,
     watchersRemove,
     watchersKillTab,
+    filesDuplicate,
+    docEditRun,
     chatRun,
     chatCancel,
     chatProbeContext,

package/src/main/lib/memoryStale.cjs

@@ -0,0 +1,116 @@
+'use strict';
+
+/**
+ * Pure, deterministic staleness scorer for workspace memories. No fs/electron
+ * access — all IO is injected via `entries` (pre-read) and `existsPath`
+ * (predicate), so this module is unit-testable with zero mocking.
+ */
+
+const DAY_MS = 86_400_000;
+const AGE_STALE_DAYS = 90;
+const MAX_DEAD_REF_CANDIDATES = 20;
+
+const WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
+// Backtick-quoted repo-path-shaped tokens, optionally suffixed with a :line.
+const PATH_TOKEN_RE = /`([A-Za-z0-9_./-]+\.[A-Za-z0-9]{1,5}(?::\d+)?)`/g;
+
+const KNOWN_SOURCE_EXTENSIONS = new Set([
+  'js', 'jsx', 'ts', 'tsx', 'cjs', 'mjs', 'json', 'md', 'py', 'rb', 'go', 'rs',
+  'java', 'c', 'h', 'cpp', 'hpp', 'css', 'scss', 'html', 'yml', 'yaml', 'sh',
+  'txt', 'toml', 'lock', 'sql', 'php', 'swift', 'kt', 'vue',
+]);
+
+function stripName(name) {
+  return name.replace(/\.md$/, '');
+}
+
+/**
+ * Extract dead-ref candidate paths from a memory body.
+ * Complexity: O(body length) — one regex pass, then O(candidates) filtering.
+ */
+function extractCandidates(body) {
+  const seen = new Set();
+  const out = [];
+  let m;
+  PATH_TOKEN_RE.lastIndex = 0;
+  while ((m = PATH_TOKEN_RE.exec(body)) !== null) {
+    if (out.length >= MAX_DEAD_REF_CANDIDATES) break;
+    let token = m[1].replace(/:\d+$/, '');
+    if (token.startsWith('/') || token.startsWith('~')) continue; // not repo-relative
+    const ext = token.includes('.') ? token.split('.').pop().toLowerCase() : '';
+    const hasSlash = token.includes('/');
+    if (!hasSlash && !KNOWN_SOURCE_EXTENSIONS.has(ext)) continue;
+    if (seen.has(token)) continue;
+    seen.add(token);
+    out.push(token);
+  }
+  return out;
+}
+
+/**
+ * scoreMemories({ entries, now, existsPath })
+ *
+ * entries: Array<{ name, mtimeMs, body }>
+ * now: ms epoch
+ * existsPath: (relPath: string) => boolean
+ *
+ * Complexity: O(total body bytes) — a single pass per entry to extract
+ * wikilink targets and dead-ref candidates; the inbound-link fold is
+ * O(entries + total links), NOT O(n^2) substring scans.
+ */
+function scoreMemories({ entries, now, existsPath }) {
+  // Signal 2 (pass 1): per-entry set of wikilink targets, deduped so repeated
+  // links to the same slug within one body count once toward that slug's
+  // inbound count.
+  const perEntryTargets = entries.map((e) => {
+    const targets = new Set();
+    let m;
+    WIKILINK_RE.lastIndex = 0;
+    while ((m = WIKILINK_RE.exec(e.body)) !== null) {
+      targets.add(m[1].trim());
+    }
+    return targets;
+  });
+
+  const inboundCounts = new Map();
+  entries.forEach((e, i) => {
+    const selfSlug = stripName(e.name);
+    for (const target of perEntryTargets[i]) {
+      if (target === selfSlug) continue; // a memory linking itself isn't an inbound reference
+      inboundCounts.set(target, (inboundCounts.get(target) || 0) + 1);
+    }
+  });
+
+  return entries.map((e) => {
+    const ageDays = Math.floor((now - e.mtimeMs) / DAY_MS);
+    const slug = stripName(e.name);
+    const inboundLinks = inboundCounts.get(slug) || 0;
+
+    const candidates = extractCandidates(e.body);
+    const deadRefs = candidates.filter((c) => !existsPath(c));
+
+    const reasons = [];
+    if (deadRefs.length > 0) {
+      reasons.push(
+        deadRefs.length === 1
+          ? 'references 1 path that no longer exists'
+          : `references ${deadRefs.length} paths that no longer exist`
+      );
+    }
+    const oldAndUnlinked = ageDays > AGE_STALE_DAYS && inboundLinks === 0;
+    if (oldAndUnlinked) {
+      reasons.push('90+ days old with no inbound links');
+    }
+
+    return {
+      name: e.name,
+      ageDays,
+      inboundLinks,
+      deadRefs,
+      stale: deadRefs.length > 0 || oldAndUnlinked,
+      reasons,
+    };
+  });
+}
+
+module.exports = { scoreMemories };

package/src/main/memoryTool.cjs

@@ -31,6 +31,7 @@ const os = require('node:os');
 const config = require('./config.cjs');
 
 const { MEMORY_SLUG_RE: SLUG_RE } = require('./lib/memorySlug.cjs');
+const { scoreMemories } = require('./lib/memoryStale.cjs');
 
 const MAX_FILE_BYTES = 1024 * 1024; // 1 MiB
 const MAX_ENTRIES = 1000;
@@ -192,6 +193,52 @@ async function create({ workspace, name, description }) {
   return await write({ workspace: ws, name, content: fm });
 }
 
+/**
+ * Deterministic, zero-LLM-cost staleness report for a workspace's memories.
+ * `cwd`, when supplied, is validated through config.validatePath (same
+ * home-boundary contract as every other path in this file) and used only for
+ * the dead-ref existence check. Absent/invalid cwd disables dead-ref
+ * detection entirely rather than mass-flagging memories.
+ */
+async function stale({ workspace, cwd }) {
+  const ws = validWorkspaceName(workspace) ? workspace : 'default';
+  const dir = workspaceDir(ws);
+  const r = await config.listDir(dir, { filesOnly: true });
+  if (!r.ok) {
+    return { entries: [], workspace: ws, error: r.error };
+  }
+  const names = r.entries.map((e) => e.name).filter((n) => SLUG_RE.test(n)).sort();
+
+  let baseDir = null;
+  if (typeof cwd === 'string' && cwd) {
+    try {
+      const validated = config.validatePath(cwd);
+      if (fs.existsSync(validated) && fs.statSync(validated).isDirectory()) {
+        baseDir = validated;
+      }
+    } catch {
+      baseDir = null;
+    }
+  }
+  const existsPath = baseDir
+    ? (relPath) => {
+        const full = path.resolve(baseDir, relPath);
+        if (full !== baseDir && !full.startsWith(baseDir + path.sep)) return false;
+        return fs.existsSync(full);
+      }
+    : () => true;
+
+  const entries = [];
+  for (const name of names) {
+    const abs = path.join(dir, name);
+    const r2 = await config.readText(abs);
+    if (!r2.exists) continue;
+    entries.push({ name, mtimeMs: r2.mtimeMs, body: r2.text });
+  }
+
+  return { entries: scoreMemories({ entries, now: Date.now(), existsPath }), workspace: ws, error: null };
+}
+
 function registerMemoryHandlers() {
   const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
   ipcMain.handle('memory:list', v(s.memoryList, list));
@@ -199,6 +246,7 @@ function registerMemoryHandlers() {
   ipcMain.handle('memory:write', v(s.memoryWrite, write));
   ipcMain.handle('memory:delete', v(s.memoryDelete, deleteEntry));
   ipcMain.handle('memory:create', v(s.memoryCreate, create));
+  ipcMain.handle('memory:stale', v(s.memoryStale, stale));
 }
 
 module.exports = {
@@ -207,4 +255,5 @@ module.exports = {
   // exported for tests
   memoryRoot,
   workspaceDir,
+  stale,
 };

package/src/main/pty.cjs

@@ -188,19 +188,19 @@ class PtyManager {
       // Tab was removed or never existed — tell the renderer so it can surface
       // "skipped" feedback rather than silently dropping the write.
       sendIfAlive(this.window, 'pty:write-error', { tabId, reason: 'no-pty' });
-      return;
+      return { ok: false, reason: 'no-pty' };
     }
     try {
       s.proc.write(data);
+      return { ok: true };
     } catch (err) {
       // node-pty throws synchronously (or the underlying net.Socket emits an
       // error that node-pty re-throws) when writing to an exited process.
       // Catch here so the uncaught-exception handler never sees it, and notify
       // the renderer to surface "skipped" feedback.
-      sendIfAlive(this.window, 'pty:write-error', {
-        tabId,
-        reason: String(err?.message || 'write-failed'),
-      });
+      const reason = String(err?.message || 'write-failed');
+      sendIfAlive(this.window, 'pty:write-error', { tabId, reason });
+      return { ok: false, reason };
     }
   }
 

package/src/main/webRemote.cjs

@@ -189,6 +189,11 @@ let _destroyed = false; // set at app shutdown to stop reconnect loops
 // E2E session state — reset on each new WS connection.
 // .state: 'idle' | 'pending_sas' | 'authenticated' | 'failed'
 let _e2e = makeState();
+// Browser SPKI pubkey (base64url) that produced the current _e2e session, and the
+// deviceId it was received on — tracked so a manual SAS confirmation can pin it to
+// that device's `verifiedPeerPubKey` for auto-trust on future reconnects.
+let _e2ePeerPubKey = null;
+let _e2eDeviceId = null;
 
 // ─── Config helpers ───────────────────────────────────────────────────────────
 
@@ -317,6 +322,8 @@ async function getDeviceTicket(deviceToken) {
 
 function resetE2e(state = 'idle') {
   _e2e = makeState(state);
+  _e2ePeerPubKey = null;
+  _e2eDeviceId = null;
 }
 
 // ─── WebSocket lifecycle ──────────────────────────────────────────────────────
@@ -781,6 +788,19 @@ async function maybeSummarize(w) {
   });
 }
 
+/**
+ * Shared finish-up for any path that transitions _e2e into 'authenticated'
+ * (manual SAS confirmation or pinned-key auto-trust): log, broadcast the new
+ * status, and flush the session list immediately rather than waiting for the
+ * next SESSION_LIST_PUSH_MS tick.
+ */
+function finalizeE2eAuthenticated(logMessage) {
+  logs.writeLine({ scope: 'webRemote', level: 'info', message: logMessage });
+  broadcastStatus();
+  _lastSessionListJson = null;
+  pushSessionList().catch(() => {});
+}
+
 // ─── Message handling & command dispatch ─────────────────────────────────────
 
 async function handleMessage(raw, device) {
@@ -883,6 +903,18 @@ async function handleMessage(raw, device) {
         broadcastStatus();
         return;
       }
+      _e2ePeerPubKey = browserPubKey;
+      _e2eDeviceId = device.deviceId;
+      // TOFU pinning: if this exact (deviceId, browserPubKey) pair was already
+      // manually SAS-confirmed once, skip pending_sas and auto-authenticate — the
+      // user already verified this browser. A different/first-seen pubKey always
+      // falls through to the manual pending_sas flow below, unchanged.
+      if (device.verifiedPeerPubKey && device.verifiedPeerPubKey === browserPubKey) {
+        _e2e = makeState('authenticated', sessionKey, null);
+        finalizeE2eAuthenticated('E2E session auto-authenticated — pinned browser key matched');
+        respond(id, undefined, 'e2e:ready');
+        return;
+      }
       _e2e = makeState('pending_sas', sessionKey, pendingSas);
       logs.writeLine({ scope: 'webRemote', level: 'info', message: 'E2E session key established — SAS pending confirmation' });
       broadcastStatus();
@@ -1047,8 +1079,7 @@ function getDispatchMap() {
 
     'cmd:pty:write': async (payload) => {
       const parsed = schemas.ptyWrite.parse(payload);
-      ptyManager.write(parsed);
-      return { ok: true };
+      return ptyManager.write(parsed);
     },
 
     'cmd:pty:resize': async (payload) => {
@@ -1167,6 +1198,9 @@ async function pair(otp) {
     deviceName: `Device (paired ${new Date().toISOString().slice(0, 10)})`,
     issuedAt: new Date().toISOString(),
     lastConnectedAt: null,
+    // Set once a browser's SAS is manually confirmed; TOFU-pinned for auto-trust
+    // on future reconnects from the same (deviceId, browserPubKey) pair.
+    verifiedPeerPubKey: null,
   }];
 
   await saveConfig({ ...cfg, devices });
@@ -1234,13 +1268,23 @@ function registerRemoteHandlers() {
       return { ok: false, error };
     }
     _e2e = next;
-    logs.writeLine({ scope: 'webRemote', level: 'info', message: 'E2E session authenticated — SAS confirmed by user' });
-    broadcastStatus();
+    // Pin this browser's pubkey to the device so future reconnects with the same
+    // key auto-authenticate (see e2e:hello above) instead of re-prompting forever.
+    if (_e2ePeerPubKey && _e2eDeviceId) {
+      try {
+        const cfg = await loadConfig();
+        const devices = (cfg.devices || []).map((d) =>
+          d.deviceId === _e2eDeviceId ? { ...d, verifiedPeerPubKey: _e2ePeerPubKey } : d
+        );
+        await saveConfig({ ...cfg, devices });
+      } catch (e) {
+        logs.writeLine({ scope: 'webRemote', level: 'warn', message: 'failed to persist pinned peer pubkey', meta: { error: e?.message } });
+      }
+    }
     // Flush the session list immediately — the push loop was suppressed while
     // state !== 'authenticated', so the mobile app would otherwise wait up to
     // SESSION_LIST_PUSH_MS for the first useful data.
-    _lastSessionListJson = null;
-    pushSessionList().catch(() => {});
+    finalizeE2eAuthenticated('E2E session authenticated — SAS confirmed by user');
     return { ok: true };
   });
 
@@ -1334,4 +1378,11 @@ module.exports = {
   registerRemoteHandlers,
   init,
   destroy,
+  // Test-only internals — not part of the IPC surface. Lets unit tests drive
+  // e2e:hello / SAS-pinning transitions without a real relay WS connection.
+  _internal: {
+    handleMessage,
+    resetE2e,
+    getE2eState: () => _e2e,
+  },
 };

package/src/preload/api.d.ts

@@ -583,6 +583,8 @@ export interface FilesWriteResult { ok: boolean; error: string | null }
 export interface FilesCreateResult { ok: boolean; path?: string; error: string | null }
 export interface FilesRenameResult { ok: boolean; newPath?: string; error: string | null }
 export interface FilesDeleteResult { ok: boolean; error: string | null }
+export interface FilesDuplicateResult { ok: boolean; path?: string; error?: string | null }
+export interface DocEditResult { ok: boolean; after?: string; error?: string }
 
 export interface SearchFileEntry {
   name: string;
@@ -796,6 +798,21 @@ export interface MemoryAggregateResult {
   error?: string;
 }
 
+export interface MemoryStaleEntry {
+  name: string;
+  ageDays: number;
+  inboundLinks: number;
+  deadRefs: string[];
+  stale: boolean;
+  reasons: string[];
+}
+
+export interface MemoryStaleResult {
+  entries: MemoryStaleEntry[];
+  workspace: string;
+  error: string | null;
+}
+
 // ────────────────────────────────────────────── Per-subagent memory
 // Stored at ~/.claude/session-manager/agent-memory/<agentId>.json. Keyed by
 // agent name (the .md filename in ~/.claude/agents/), not by workspace cwd.
@@ -1185,6 +1202,10 @@ export interface SessionManagerAPI {
     create: (parentPath: string, name: string, kind: 'file' | 'folder') => Promise<FilesCreateResult>;
     rename: (path: string, newName: string) => Promise<FilesRenameResult>;
     delete: (path: string) => Promise<FilesDeleteResult>;
+    duplicate: (path: string) => Promise<FilesDuplicateResult>;
+  };
+  docEdit: {
+    run: (payload: { path: string; before: string; instruction: string }) => Promise<DocEditResult>;
   };
   /** Consolidated shell open/reveal. One method, discriminated on `as`, replaces
    *  the former app.openIn* / app.openExternal / files.openExternal / files.showInFinder.
@@ -1301,6 +1322,8 @@ export interface SessionManagerAPI {
     create: (name: string, description?: string, workspace?: string) => Promise<MemoryMutationResult>;
     /** Aggregate workspace memories into semantic clusters. `refresh:true` fires a cost-gated `claude -p` pass; otherwise returns the cache only. */
     aggregate: (workspace: string, refresh?: boolean) => Promise<MemoryAggregateResult>;
+    /** Deterministic, zero-LLM-cost staleness report. `cwd` (optional) scopes the dead-repo-ref check. */
+    stale: (workspace?: string, cwd?: string) => Promise<MemoryStaleResult>;
   };
   agentMemory: {
     /** List all memory entries for one subagent. Sorted newest first. */

package/src/preload/index.cjs

@@ -224,6 +224,10 @@ contextBridge.exposeInMainWorld('api', {
     create: (parentPath, name, kind) => ipcRenderer.invoke('files:create', { parentPath, name, kind }),
     rename: (path, newName) => ipcRenderer.invoke('files:rename', { path, newName }),
     delete: (path) => ipcRenderer.invoke('files:delete', { path }),
+    duplicate: (path) => ipcRenderer.invoke('files:duplicate', { path }),
+  },
+  docEdit: {
+    run: (payload) => ipcRenderer.invoke('docedit:run', payload),
   },
   // Consolidated shell open/reveal — see shell:open in index.cjs.
   // as: 'editor' | 'fileInEditor' | 'finder' | 'terminal' | 'external' | 'openPath' | 'revealPath'
@@ -307,6 +311,8 @@ contextBridge.exposeInMainWorld('api', {
     },
     aggregate: (workspace, refresh) =>
       ipcRenderer.invoke('memory:aggregate', refresh ? { workspace, refresh: true } : { workspace }),
+    stale: (workspace, cwd) =>
+      ipcRenderer.invoke('memory:stale', { ...(workspace ? { workspace } : {}), ...(cwd ? { cwd } : {}) }),
   },
   agentMemory: {
     list: (agentId) => ipcRenderer.invoke('agent-memory:list', { agentId }),