claude-code-session-manager 0.112.0 → 0.114.0

package/src/main/lib/scheduler/runLogRetention.cjs

@@ -1,8 +1,7 @@
 'use strict';
 
 /**
- * runLogRetention.cjs — computes (and, only when explicitly opted in,
- * applies) a retention policy over `scheduled-plans/runs/`.
+ * runLogRetention.cjs — computes and applies a retention policy over `scheduled-plans/runs/`.
  *
  * That directory is a machine-level Session-Manager runtime artifact store
  * (execution logs of the scheduler's own `claude -p` runs), not anything
@@ -26,10 +25,10 @@
  * slug's own files.
  *
  * SAFETY MODEL (the point of this module — see the PRD that added it):
- *   - Nothing is ever deleted unless the caller passes settings with
- *     `schedulerRunLogRetention.enabled === true` AND a non-empty policy.
- *     Everywhere else (computeReport, and applyRetention with no opt-in)
- *     this module only READS the filesystem.
+ *   - Retention is ON by default (DEFAULT_RUN_LOG_RETENTION) when settings
+ *     carry no `schedulerRunLogRetention`. An explicit `enabled: false` (or a
+ *     config with no non-empty policy) opts out: computeReport, and
+ *     applyRetention when opted out, only READ the filesystem.
  *   - An entry belonging to a job that is currently live — status `pending`
  *     (queued), `running`, `needs_review`, or `investigating` (the exact
  *     literals scheduler.cjs uses; see LIVE_STATUSES) — is never eligible,
@@ -51,6 +50,16 @@ const schedulerPaths = require('./schedulerPaths.cjs');
 // checks) — 'completed' and 'failed' are the only terminal ones.
 const LIVE_STATUSES = new Set(['pending', 'running', 'needs_review', 'investigating']);
 
+/**
+ * Built-in policy applied when settings carry no `schedulerRunLogRetention`:
+ * drop runs older than 14 days but always keep each slug's newest 3.
+ * (Policy keys follow the module's own names: maxAgeDays / keepPerSlug.)
+ */
+const DEFAULT_RUN_LOG_RETENTION = Object.freeze({
+  enabled: true,
+  policy: Object.freeze({ maxAgeDays: 14, keepPerSlug: 3 }),
+});
+
 const META_SUFFIX = '.meta.json';
 const DAY_MS = 24 * 60 * 60 * 1000;
 
@@ -259,11 +268,21 @@ function computeReport(runsDir, policy, opts) {
 }
 
 /**
- * True only when settings carry an explicit, well-formed opt-in:
- * `schedulerRunLogRetention.enabled === true` plus a non-empty policy.
+ * The effective retention config: the caller's `schedulerRunLogRetention`
+ * when present, else DEFAULT_RUN_LOG_RETENTION.
  */
-function isRetentionEnabled(settings) {
+function resolveRetentionConfig(settings) {
   const cfg = settings && settings.schedulerRunLogRetention;
+  return cfg == null ? DEFAULT_RUN_LOG_RETENTION : cfg;
+}
+
+/**
+ * True when the effective config (see resolveRetentionConfig) has
+ * `enabled === true` plus a non-empty policy. An absent setting resolves to
+ * the default (enabled); an explicit `enabled: false` opts out.
+ */
+function isRetentionEnabled(settings) {
+  const cfg = resolveRetentionConfig(settings);
   if (!cfg || cfg.enabled !== true) return false;
   const policy = cfg.policy;
   return !!policy && (policy.maxAgeDays != null || policy.keepPerSlug != null);
@@ -372,7 +391,7 @@ function sweepOrphanDirs(runsDir, runningRunIds, errors) {
  * nothing removed.
  */
 function applyRetention(runsDir, settings, opts) {
-  const cfg = (settings && settings.schedulerRunLogRetention) || null;
+  const cfg = resolveRetentionConfig(settings);
   const policy = (cfg && cfg.policy) || {};
   const enabled = isRetentionEnabled(settings);
   const liveKeys = resolveLiveKeysForApply(runsDir, opts, enabled);
@@ -381,7 +400,7 @@ function applyRetention(runsDir, settings, opts) {
   if (!enabled) {
     return {
       deleted: false,
-      reason: 'dry-run: schedulerRunLogRetention.enabled is not true (or has no policy)',
+      reason: 'dry-run: schedulerRunLogRetention is disabled (enabled !== true, or has no policy)',
       report,
     };
   }
@@ -424,8 +443,8 @@ function applyRetention(runsDir, settings, opts) {
  * applyRetention's own internal queueStore fallback (resolveLiveKeysForApply
  * above), which exists only as a defensive net for callers who forget to
  * thread live-job info through, not as this module's primary path. Deletion
- * still only happens when the read config carries an explicit
- * schedulerRunLogRetention.enabled === true (see isRetentionEnabled).
+ * happens unless the read config opts out with
+ * schedulerRunLogRetention.enabled === false (see isRetentionEnabled).
  *
  * Intended to be called once per app boot (see index.cjs's deferred 30s
  * startup timer, alongside finalizeClosedDays) — never on its own timer.
@@ -438,6 +457,8 @@ function runBootSweep(opts) {
 }
 
 module.exports = {
+  DEFAULT_RUN_LOG_RETENTION,
+  resolveRetentionConfig,
   LIVE_STATUSES,
   isLiveJob,
   liveKeysFromJobs,

package/src/main/lib/scheduler/schedulerBatch.cjs

@@ -15,7 +15,7 @@
 const path = require('node:path');
 const os = require('node:os');
 const { projectJobCap, quietMachineWaitMs } = require('./schedulerConfig.cjs');
-const { bareSlug } = require('../prd/depSlugResolve.cjs');
+const { bareSlug, isSatisfiedDepRow } = require('../prd/depSlugResolve.cjs');
 
 const DEFAULT_PROJECT_CWD = path.join(os.homedir(), 'Projects', 'session-manager');
 
@@ -127,20 +127,16 @@ function findUnresolvableDepRoots(projectJobs, satisfiedSlugs = new Set()) {
 
 function findBlockingDep(job, projectJobs, satisfiedSlugs = new Set()) {
   const { rowsForDep, isKnownSatisfied } = makeDepResolver(projectJobs, satisfiedSlugs);
-  // A dep row is blocking unless it's 'completed', OR it's a 'skipped' row
-  // stamped `needsReviewAutoResolvedSkip` — the bounded needs_review
-  // auto-resolve terminal decision (scheduler.cjs's
-  // applyNeedsReviewAutoResolve). That skip is deliberately NOT the
+  // A dep row is blocking unless isSatisfiedDepRow — 'completed', or a
+  // `needsReviewAutoResolvedSkip` skip. That skip is deliberately NOT the
   // "PRD source vanished, a human must author a fresh PRD" skip the
-  // heldBySkippedDep messaging above describes — it already got every
-  // bounded chance to resolve itself, so treating it as a permanent
-  // dependsOn block would defeat the whole point of that auto-resolve pass
-  // (a chain that never drains without an operator).
-  const isSatisfiedRow = (dep) => dep.status === 'completed'
-    || (dep.status === 'skipped' && dep.needsReviewAutoResolvedSkip === true);
+  // heldBySkippedDep messaging describes — it already got every bounded
+  // chance to resolve itself, so treating it as a permanent dependsOn block
+  // would defeat the auto-resolve pass. runVerify.checkDeps MUST use the same
+  // predicate, or every run of the dependent is downgraded and re-dispatched.
   return (job.dependsOn ?? []).find((slug) => {
     const rows = rowsForDep(slug);
-    if (rows.length > 0) return rows.some((dep) => !isSatisfiedRow(dep));
+    if (rows.length > 0) return rows.some((dep) => !isSatisfiedDepRow(dep));
     return !isKnownSatisfied(slug);
   });
 }

package/src/main/lib/telemetry/telemetryClient.cjs

@@ -647,18 +647,20 @@ function describeFailureStatus(status) {
   return status === 0 ? 'network error' : `HTTP ${status}`;
 }
 
-function applyFailureBackoff(status) {
+function applyFailureBackoff(status, channel) {
   if (status === 429 || status === 0 || status >= 500) {
     S.consecutiveFailures += 1;
     const ms = Math.min(BACKOFF_BASE_MS * (2 ** (S.consecutiveFailures - 1)), BACKOFF_MAX_MS);
     S.backoffUntil = Date.now() + ms;
     S.lastError = { status, message: describeFailureStatus(status), at: Date.now() };
+    logWarn('telemetry send failed', { channel, status, consecutiveFailures: S.consecutiveFailures, backoffMs: ms });
     return;
   }
   if (status >= 400 && status < 500) {
     // Malformed-contract circuit breaker (includes 401) — not retried.
     S.disabledForProcess = true;
     S.lastError = { status, message: describeFailureStatus(status), at: Date.now() };
+    logWarn('telemetry disabled for process', { status });
   }
 }
 
@@ -705,7 +707,7 @@ async function flushImpl(reason) {
             result.sent.push(r.recordId);
           } else {
             result.failed.push(r.recordId);
-            applyFailureBackoff(res.status);
+            applyFailureBackoff(res.status, channel);
             sawFailure = true;
             break;
           }
@@ -726,7 +728,7 @@ async function flushImpl(reason) {
           }
         } else {
           for (const r of batch) result.failed.push(r.recordId);
-          applyFailureBackoff(res.status);
+          applyFailureBackoff(res.status, channel);
           sawFailure = true;
           break;
         }
@@ -739,7 +741,9 @@ async function flushImpl(reason) {
     if (safeReason === 'daily' && result.failed.length === 0) {
       S.settings = await telemetrySettings.save({ lastDailyFlushAt: new Date().toISOString() });
     }
-  } catch { /* fail-inert */ }
+  } catch (e) {
+    logWarn('telemetry flush threw', { error: e && e.message ? e.message : String(e) });
+  }
   S.lastFlushAt = Date.now();
   S.lastFlushReason = safeReason;
   return result;

package/src/main/lib/util/atomicFs.cjs

@@ -105,7 +105,49 @@ function readJsonOrSync(file, fallback) {
   }
 }
 
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === 'EPERM'; // exists but owned by someone else
+  }
+}
+
+/**
+ * Remove orphaned `<file>.tmp-<pid>-<ts>-<rand>` files left by crashed
+ * writers. Direct children of `dir` only (no recursion); a file goes only when
+ * its mtime is older than `olderThanMs` AND its embedded pid is not alive.
+ * `.corrupt-*` / `.bak*` forensics never match. Never throws.
+ */
+function sweepStaleTmpFiles(dir, { olderThanMs = 3600000, isPidAlive = defaultIsPidAlive } = {}) {
+  const removed = [];
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return { removed };
+  }
+  const now = Date.now();
+  for (const name of names) {
+    try {
+      const m = /\.tmp-(\d+)-/.exec(name);
+      if (!m) continue;
+      if (/\.(corrupt|bak)/.test(name)) continue;
+      const full = path.join(dir, name);
+      const st = fs.lstatSync(full);
+      if (!st.isFile()) continue;
+      if (now - st.mtimeMs <= olderThanMs) continue;
+      if (isPidAlive(Number(m[1]))) continue;
+      fs.unlinkSync(full);
+      removed.push(full);
+    } catch { /* per-file errors are skipped */ }
+  }
+  return { removed };
+}
+
 module.exports = {
+  sweepStaleTmpFiles,
   tmpPathFor,
   writeTextAtomic,
   writeTextAtomicSync,

package/src/main/lib/util/loopDelay.cjs

@@ -11,7 +11,7 @@ const { monitorEventLoopDelay } = require('node:perf_hooks');
 
 const LOOP_DELAY_RESOLUTION_MS = 20;
 // A single beat whose worst loop delay exceeds this is a visible main-thread stall.
-const LOOP_STALL_WARN_MS = 250;
+const LOOP_STALL_WARN_MS = 1000;
 
 const NS_PER_MS = 1e6;
 const toMs = (ns) => Math.round(ns / NS_PER_MS * 10) / 10;

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,
 };

package/src/main/runVerify.cjs

@@ -41,6 +41,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
 const { parsePrdFile } = require('./lib/prd/prdFrontmatter.cjs');
+const { isSatisfiedDepRow } = require('./lib/prd/depSlugResolve.cjs');
 
 const VERDICTS_SCHEMA_VERSION = 1;
 
@@ -468,7 +469,9 @@ function checkDeps(queueEntry, allJobs, prdBody) {
     // bare dep name that never matched any row, and ended up on disk with no
     // queue row at all.
     if (deps.length === 0) continue;
-    const unfinished = deps.find((d) => d.status !== 'completed');
+    // Same predicate as findBlockingDep — an auto-resolve skip the picker
+    // dispatched past must not be re-judged unmet here (same infinite re-run).
+    const unfinished = deps.find((d) => !isSatisfiedDepRow(d));
     if (unfinished) {
       return { ok: false, reason: `dependsOn: "${depSlug}" is ${unfinished.status} (need completed)` };
     }
@@ -488,7 +491,7 @@ function checkDeps(queueEntry, allJobs, prdBody) {
       if (matches.length === 0) continue; // unresolvable fragment — skip
 
       for (const dep of matches) {
-        if (dep.status !== 'completed') {
+        if (!isSatisfiedDepRow(dep)) {
           return {
             ok: false,
             reason: `PRD body dep "${frag}" → "${dep.slug}" is ${dep.status} (need completed)`,