monomind 2.0.3 → 2.1.0

package/packages/@monomind/cli/.claude/helpers/token-tracker.cjs

@@ -351,7 +351,7 @@ function parseSessionFile(filePath, project, seenMsgIds, dateStart, dateEnd) {
 function collectJsonlFiles(dirPath) {
   var files = [];
   var entries;
-  try { entries = fs.readdirSync(dirPath); } catch (e) { return files; }
+  try { entries = fs.readdirSync(dirPath).filter(function(f) { return !f.startsWith('._'); }); } catch (e) { return files; }
   for (var i = 0; i < entries.length; i++) {
     var e = entries[i];
     if (e.endsWith('.jsonl')) {
@@ -360,7 +360,7 @@ function collectJsonlFiles(dirPath) {
       // Check subagents
       var subDir = path.join(dirPath, e, 'subagents');
       var subFiles;
-      try { subFiles = fs.readdirSync(subDir); } catch (_) { continue; }
+      try { subFiles = fs.readdirSync(subDir).filter(function(f) { return !f.startsWith('._'); }); } catch (_) { continue; }
       for (var j = 0; j < subFiles.length; j++) {
         if (subFiles[j].endsWith('.jsonl')) {
           files.push(path.join(subDir, subFiles[j]));
@@ -389,7 +389,7 @@ function unsanitize(name) {
 function parseAllSessions(dateStart, dateEnd) {
   var projectsDir = getClaudeProjectsDir();
   var projectDirs;
-  try { projectDirs = fs.readdirSync(projectsDir); } catch (e) { return []; }
+  try { projectDirs = fs.readdirSync(projectsDir).filter(function(f) { return !f.startsWith('._'); }); } catch (e) { return []; }
 
   var seenMsgIds = new Set();
   var projectMap = {};

package/packages/@monomind/cli/.claude/helpers/utils/agent-registrations.cjs

@@ -0,0 +1,41 @@
+'use strict';
+// Shared agent-registration purge logic.
+//
+// .monomind/agents/registrations/*.json accumulate one file per subagent
+// spawn. The only purge used to be the FIFO-oldest-removal + stale sweep in
+// task-handler.cjs's handlePostTask, which only fires on TeammateIdle/
+// TaskCompleted — so any session that spawns agents but never emits those
+// events (crashes, single-shot Task calls outside a team, etc.) leaked
+// registrations forever. agent-start-handler.cjs already reads this
+// directory on every subagent start, so it also runs this same stale sweep.
+
+const path = require('path');
+const fs = require('fs');
+const { cleanEntries } = require('./fs-helpers.cjs');
+
+const DEFAULT_MAX_AGE_MS = 30 * 60 * 1000; // 30 minutes
+
+/**
+ * Delete registration files older than maxAgeMs. Returns the number of
+ * registrations remaining after the purge (or null if regDir doesn't exist
+ * or an error occurred).
+ */
+function purgeStaleRegistrations(regDir, maxAgeMs) {
+  maxAgeMs = maxAgeMs || DEFAULT_MAX_AGE_MS;
+  try {
+    if (!fs.existsSync(regDir)) return null;
+    const now = Date.now();
+    for (const f of cleanEntries(regDir, f => f.endsWith('.json'))) {
+      try {
+        if (now - fs.statSync(path.join(regDir, f)).mtimeMs > maxAgeMs) {
+          fs.unlinkSync(path.join(regDir, f));
+        }
+      } catch { /* ignore */ }
+    }
+    return cleanEntries(regDir, f => f.endsWith('.json')).length;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { purgeStaleRegistrations, DEFAULT_MAX_AGE_MS };

package/packages/@monomind/cli/.claude/helpers/utils/fs-helpers.cjs

@@ -0,0 +1,183 @@
+'use strict';
+// Shared fs helpers for hook handlers.
+//
+// exFAT / macOS AppleDouble junk files (`._foo.json`, `.__protocol.md`, etc.)
+// get created whenever files touch an exFAT volume (external drives, some
+// network shares) and then get picked up by naive `readdirSync().filter(...)`
+// calls as if they were real data — corrupting counts, getting parsed as
+// JSON and failing, or (worst case) surfacing as garbage entries in
+// Claude Code's own skill/command list. Every readdir in the hook handlers
+// should route through `cleanEntries()` so this is filtered exactly once.
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Read a directory and filter out exFAT AppleDouble junk (`._*`) before
+ * applying the caller's own filter predicate.
+ * @param {string} dir - directory to read
+ * @param {(name: string) => boolean} [filterFn] - optional additional filter
+ * @returns {string[]} entry names (not full paths), junk-free
+ */
+function cleanEntries(dir, filterFn) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  entries = entries.filter(f => !f.startsWith('._'));
+  return filterFn ? entries.filter(filterFn) : entries;
+}
+
+/**
+ * Same as cleanEntries but returns full paths.
+ */
+function cleanEntryPaths(dir, filterFn) {
+  return cleanEntries(dir, filterFn).map(f => path.join(dir, f));
+}
+
+/**
+ * Synchronous sleep (blocks the event loop) — used for tiny lock-retry
+ * backoffs where an async setTimeout would require restructuring a
+ * short-lived hook script into a promise chain for no real benefit.
+ * Falls back to a busy-wait if Atomics.wait is unavailable.
+ */
+function sleepSync(ms) {
+  try {
+    const sab = new SharedArrayBuffer(4);
+    Atomics.wait(new Int32Array(sab), 0, 0, ms);
+  } catch {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { /* spin */ }
+  }
+}
+
+/**
+ * Write a file atomically: write to a unique temp path then rename into
+ * place. `fs.renameSync` is atomic on POSIX and Windows (same volume), so
+ * concurrent readers of `filePath` never observe a partially-written file
+ * (torn read) — they see either the old complete file or the new complete
+ * file, never a half-written one. Does not by itself prevent lost updates
+ * from concurrent read-modify-write cycles — pair with `claimLock` when
+ * that matters (see hook-latency.json / swarm-activity.json writers).
+ */
+function atomicWriteFileSync(filePath, data, encoding) {
+  const dir = path.dirname(filePath);
+  try { fs.mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, data, encoding);
+  fs.renameSync(tmp, filePath);
+}
+
+/**
+ * Claim an exclusive lock file for short-lived critical sections (e.g. a
+ * rebuild-cooldown or spawn-once guard). Uses `wx` (exclusive create) so
+ * the claim itself is atomic — no read-check-write window.
+ *
+ * On contention, a lock older than `staleMs` is treated as abandoned (the
+ * holder crashed or never released it) and broken via an atomic RENAME
+ * (never unlink-then-create): renaming the stale lock path away is only
+ * ever won by exactly one racing process, so a concurrent process that
+ * also decided the lock was stale cannot delete *this* process's
+ * freshly-reclaimed lock out from under it (the TOCTOU race an
+ * unlink-then-create approach is vulnerable to). The loser of the rename
+ * race backs off and retries the whole claim sequence from the top rather
+ * than assuming it owns anything.
+ *
+ * Returns true if the lock was claimed (caller must eventually call
+ * `releaseLock`), false if another live/fresh owner holds it.
+ */
+function claimLock(lockPath, staleMs, maxAttempts) {
+  staleMs = staleMs || 30000;
+  maxAttempts = maxAttempts || 3;
+  try { fs.mkdirSync(path.dirname(lockPath), { recursive: true }); } catch { /* ignore */ }
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
+      return true;
+    } catch {
+      let stat;
+      try {
+        stat = fs.statSync(lockPath);
+      } catch {
+        // Lock vanished between our failed wx-create and this stat check —
+        // retry the create immediately.
+        continue;
+      }
+      if (Date.now() - stat.mtimeMs < staleMs) return false; // held by a live/fresh owner
+
+      const claimedName = `${lockPath}.${process.pid}.${Date.now()}.stale`;
+      try {
+        fs.renameSync(lockPath, claimedName);
+      } catch {
+        // Someone else already renamed the stale lock away — they're
+        // claiming it. Back off briefly and retry from the top rather than
+        // proceeding as if we own it.
+        sleepSync(5);
+        continue;
+      }
+      try { fs.unlinkSync(claimedName); } catch { /* ignore */ }
+      // We won the rename race — loop back and attempt the wx-create fresh.
+    }
+  }
+  return false;
+}
+
+/** Release a lock previously claimed by this process via `claimLock`. */
+function releaseLock(lockPath) {
+  try {
+    if (Number(fs.readFileSync(lockPath, 'utf-8')) === process.pid) fs.unlinkSync(lockPath);
+  } catch { /* ignore */ }
+}
+
+/**
+ * Run `fn` while holding a lock (see `claimLock`) so a read-modify-write
+ * cycle is protected end-to-end, not just the final write. If the lock
+ * can't be claimed after retries, `fn` still runs (never block a hook) but
+ * without lost-update protection — best-effort, matching this codebase's
+ * "hooks must not block the session" rule.
+ */
+function withLock(lockPath, fn, staleMs, maxAttempts) {
+  const acquired = claimLock(lockPath, staleMs, maxAttempts);
+  try {
+    return fn();
+  } finally {
+    if (acquired) releaseLock(lockPath);
+  }
+}
+
+/**
+ * Append a JSONL line and rotate the file down to `maxLines` (keep the
+ * most recent lines) when it exceeds that count — mirrors the size-cap
+ * pattern already used for intelligence-outcomes.jsonl (500 lines) and
+ * episodes.jsonl. Prevents unbounded JSONL growth. Rotation write is
+ * atomic (tmp+rename).
+ */
+function appendJsonlWithRotation(filePath, line, maxLines) {
+  maxLines = maxLines || 500;
+  try { fs.mkdirSync(path.dirname(filePath), { recursive: true }); } catch { /* ignore */ }
+  fs.appendFileSync(filePath, line.endsWith('\n') ? line : line + '\n');
+  try {
+    const st = fs.statSync(filePath);
+    // Cheap heuristic to skip reading huge files line-by-line on every
+    // append: only bother counting lines once the file is already
+    // suspiciously large relative to a plausible maxLines * avg-line-size.
+    if (st.size < 4096) return;
+    const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+    if (lines.length > maxLines) {
+      atomicWriteFileSync(filePath, lines.slice(-maxLines).join('\n') + '\n', 'utf-8');
+    }
+  } catch { /* non-fatal — rotation is best-effort */ }
+}
+
+module.exports = {
+  cleanEntries,
+  cleanEntryPaths,
+  sleepSync,
+  atomicWriteFileSync,
+  claimLock,
+  releaseLock,
+  withLock,
+  appendJsonlWithRotation,
+};

package/packages/@monomind/cli/.claude/helpers/utils/micro-agents.cjs

@@ -5,6 +5,7 @@ const path = require('path');
 const fs = require('fs');
 
 const { _openMonographDb } = require('./monograph.cjs');
+const { cleanEntries, atomicWriteFileSync } = require('./fs-helpers.cjs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
@@ -82,7 +83,7 @@ function _triggerCollectMdFiles(dir, _depth) {
   if (depth > 5) return []; // cap recursion depth to prevent stack overflow DoS
   var results = [];
   try {
-    var entries = fs.readdirSync(dir);
+    var entries = cleanEntries(dir);
     for (var i = 0; i < entries.length; i++) {
       if (results.length >= 200) break; // cap total file count to prevent DoS
       var full = path.join(dir, entries[i]);
@@ -135,8 +136,11 @@ function scanMicroAgentTriggers(prompt) {
   if (!cacheLoaded) {
     patterns = _triggerBuildIndex(agentDir);
     try {
-      fs.mkdirSync(path.join(CWD, '.monomind'), { recursive: true });
-      fs.writeFileSync(indexPath, JSON.stringify({ patterns: patterns, builtAt: new Date().toISOString(), totalAgentsScanned: patterns.length }));
+      // P2-21: tmp+rename — multiple concurrent hook processes (route-handler
+      // invocations fire per prompt/subagent) can all miss the cache at once
+      // and rebuild+write trigger-index.json simultaneously; atomic write
+      // prevents a concurrent reader from parsing a half-written file.
+      atomicWriteFileSync(indexPath, JSON.stringify({ patterns: patterns, builtAt: new Date().toISOString(), totalAgentsScanned: patterns.length }));
     } catch (e) {}
   }
 
@@ -334,9 +338,9 @@ function _autoIndexKnowledge(knowledgeDir) {
   } catch (e) { /* graph not available yet */ }
 
   try {
-    fs.mkdirSync(knowledgeDir, { recursive: true });
-    fs.writeFileSync(chunksFile, newLines.length > 0 ? newLines.join('\n') + '\n' : '', 'utf-8');
-    fs.writeFileSync(hashFile, contentHash, 'utf-8');
+    // Same torn-read hazard as trigger-index.json above — atomic write.
+    atomicWriteFileSync(chunksFile, newLines.length > 0 ? newLines.join('\n') + '\n' : '', 'utf-8');
+    atomicWriteFileSync(hashFile, contentHash, 'utf-8');
   } catch (e) {}
   return newLines.length;
 }

package/packages/@monomind/cli/.claude/helpers/utils/telemetry.cjs

@@ -4,6 +4,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const { atomicWriteFileSync, withLock, appendJsonlWithRotation } = require('./fs-helpers.cjs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
@@ -19,7 +20,11 @@ function _recordRecentEdit(filePath) {
     d.edits = d.edits.filter(function(e) { return e.file !== storedPath; });
     d.edits.unshift({ file: storedPath, editedAt: Date.now() });
     if (d.edits.length > 10) d.edits = d.edits.slice(0, 10);
-    fs.writeFileSync(f, JSON.stringify(d));
+    // P2-21: tmp+rename so a concurrent reader of recent-edits.json (fired by
+    // another PostToolUse hook process in the same batched Edit) never sees a
+    // partially-written file. Last-writer-wins on the merge itself is
+    // acceptable here — losing one recent-edit entry is low-stakes.
+    atomicWriteFileSync(f, JSON.stringify(d));
   } catch (e) { /* non-fatal */ }
 }
 
@@ -45,7 +50,8 @@ function _recordToolCall(signature) {
       d = { startedAt: Date.now(), calls: {} };
     }
     d.calls[signature] = (d.calls[signature] || 0) + 1;
-    fs.writeFileSync(f, JSON.stringify(d));
+    // P2-21: atomic write — see _recordRecentEdit above for rationale.
+    atomicWriteFileSync(f, JSON.stringify(d));
     return d.calls[signature];
   } catch (e) { return 0; }
 }
@@ -77,8 +83,8 @@ function _getBudgetStatus() {
         monthlyLimit = Math.max(monthlyLimit || 0, Math.ceil(dailyAvg * 1.5 * 30));
         autoTuned = true;
         try {
-          fs.mkdirSync(path.dirname(budgetFile), { recursive: true });
-          fs.writeFileSync(budgetFile, JSON.stringify({
+          // P2-21: atomic write — see _recordRecentEdit above for rationale.
+          atomicWriteFileSync(budgetFile, JSON.stringify({
             dailyLimit: dailyLimit, monthlyLimit: monthlyLimit,
             autoTuned: true, tunedAt: now.toISOString(),
             basis: 'rolling avg $' + dailyAvg.toFixed(2) + '/day × 1.5',
@@ -106,20 +112,28 @@ function _getBudgetStatus() {
 }
 
 function _recordHookLatency(handlerName, durationMs) {
+  var f = path.join(CWD, '.monomind', 'metrics', 'hook-latency.json');
+  // P2-21: hook-latency.json's per-handler count/total/max are aggregated
+  // counters written by every hook invocation — a plain read-modify-write
+  // silently drops whichever concurrent process wrote last (lost update),
+  // not just torn reads. Wrap the whole cycle in a lock (see
+  // utils/fs-helpers.cjs claimLock/withLock, same TOCTOU-safe pattern used
+  // for the rebuild/spawn locks) so the read and the write happen as one
+  // critical section instead of racing.
   try {
-    var f = path.join(CWD, '.monomind', 'metrics', 'hook-latency.json');
-    fs.mkdirSync(path.dirname(f), { recursive: true });
-    var d = {};
-    try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
-    if (typeof d !== 'object' || d === null) d = {};
-    var entry = d[handlerName] || { count: 0, total: 0, max: 0 };
-    entry.count++;
-    entry.total += durationMs;
-    entry.max = Math.max(entry.max, durationMs);
-    entry.mean = Math.round(entry.total / entry.count);
-    d[handlerName] = entry;
-    d.lastUpdated = Date.now();
-    fs.writeFileSync(f, JSON.stringify(d));
+    withLock(f + '.lock', function() {
+      var d = {};
+      try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
+      if (typeof d !== 'object' || d === null) d = {};
+      var entry = d[handlerName] || { count: 0, total: 0, max: 0 };
+      entry.count++;
+      entry.total += durationMs;
+      entry.max = Math.max(entry.max, durationMs);
+      entry.mean = Math.round(entry.total / entry.count);
+      d[handlerName] = entry;
+      d.lastUpdated = Date.now();
+      atomicWriteFileSync(f, JSON.stringify(d));
+    }, 5000);
   } catch (e) {}
 }
 
@@ -130,9 +144,11 @@ function _recordDecisionMarkers(promptText) {
   if (!matches || matches.length === 0) return;
   try {
     var f = path.join(CWD, '.monomind', 'decisions.jsonl');
-    fs.mkdirSync(path.dirname(f), { recursive: true });
     var entry = JSON.stringify({ ts: Date.now(), excerpts: matches.slice(0, 3), prompt: promptText.slice(0, 400) });
-    fs.appendFileSync(f, entry + '\n');
+    // P2-26: decisions.jsonl was a pure appendFileSync with no rotation —
+    // unlike intelligence-outcomes.jsonl (capped at 500 lines). Cap it the
+    // same way so it can't grow unbounded across a long project history.
+    appendJsonlWithRotation(f, entry, 500);
   } catch (e) {}
 }
 

package/packages/@monomind/cli/bin/cli.js

@@ -241,8 +241,17 @@ if (isMCPMode) {
 
   const { CLI } = await import('../dist/src/index.js');
   const cli = new CLI();
+  // A detached daemon child (`start --daemon --foreground-worker-internal`,
+  // see src/commands/start.ts) intentionally keeps a ref'd setInterval alive
+  // after its action resolves — that's what holds the process open as a real
+  // daemon. Unconditionally calling process.exit() here would kill it the
+  // instant the action's promise resolves, defeating the whole point.
+  const isDaemonChild = cliArgs.includes('--foreground-worker-internal');
   cli.run().then(() => {
-    process.exit(process.exitCode ?? 0);
+    if (!isDaemonChild) {
+      process.exit(process.exitCode ?? 0);
+    }
+    // Daemon child: let the event loop stay alive on its own ref'd interval.
   }).catch((error) => {
     console.error('Fatal error:', safeMsg(error && error.message));
     process.exit(1);

package/packages/@monomind/cli/dist/src/commands/agent-ops.js

@@ -8,11 +8,7 @@ import { formatStatus } from './agent-lifecycle.js';
 export const metricsCommand = {
     name: 'metrics',
     description: 'Show agent performance metrics',
-    options: [
-        { name: 'period', short: 'p', description: 'Time period (1h, 24h, 7d, 30d)', type: 'string', default: '24h' },
-    ],
     action: async (ctx) => {
-        const period = ctx.flags.period;
         const { existsSync, readFileSync, readdirSync, statSync } = await import('fs');
         const { join } = await import('path');
         let totalAgents = 0;
@@ -61,13 +57,12 @@ export const metricsCommand = {
             catch { /* ignore */ }
         }
         let vectorCount = 0;
-        const dbPath = join(swarmDir, 'memory.db');
-        if (existsSync(dbPath)) {
-            try {
-                vectorCount = Math.floor(statSync(dbPath).size / 2048);
-            }
-            catch { /* ignore */ }
+        try {
+            const { bridgeGetBackendStats } = await import('../memory/memory-bridge.js');
+            const backendStats = await bridgeGetBackendStats();
+            vectorCount = backendStats?.totalEntries ?? 0;
         }
+        catch { /* backend unavailable */ }
         const byType = Object.entries(typeCounts).map(([type, data]) => ({
             type, count: data.count, tasks: data.tasks,
             successRate: data.tasks > 0 ? `${Math.round((data.success / data.tasks) * 100)}%` : 'N/A',
@@ -76,20 +71,19 @@ export const metricsCommand = {
             ? `${Math.round(Object.values(typeCounts).reduce((a, d) => a + d.success, 0) / tasksCompleted * 100)}%`
             : 'N/A';
         const metrics = {
-            period,
             summary: {
                 totalAgents, activeAgents, tasksCompleted, avgSuccessRate, vectorCount,
                 note: totalAgents === 0 ? 'No agents spawned yet. Use: agent spawn -t coder' : undefined,
             },
             byType,
-            performance: { memoryVectors: `${vectorCount} vectors`, searchBackend: vectorCount > 0 ? 'HNSW-indexed' : 'none' },
+            performance: { memoryEntries: `${vectorCount} entries`, searchBackend: vectorCount > 0 ? 'LanceDB' : 'none' },
         };
         if (ctx.flags.format === 'json') {
             output.printJson(metrics);
             return { success: true, data: metrics };
         }
         output.writeln();
-        output.writeln(output.bold(`Agent Metrics (${period})`));
+        output.writeln(output.bold('Agent Metrics'));
         output.writeln();
         output.printTable({
             columns: [
@@ -101,7 +95,7 @@ export const metricsCommand = {
                 { metric: 'Active Agents', value: metrics.summary.activeAgents },
                 { metric: 'Tasks Completed', value: metrics.summary.tasksCompleted },
                 { metric: 'Success Rate', value: metrics.summary.avgSuccessRate },
-                { metric: 'Memory Vectors', value: metrics.summary.vectorCount },
+                { metric: 'Memory Entries', value: metrics.summary.vectorCount },
             ],
         });
         output.writeln();
@@ -122,7 +116,7 @@ export const metricsCommand = {
         output.writeln();
         output.writeln(output.bold('Memory'));
         output.printList([
-            `Vectors: ${output.success(metrics.performance.memoryVectors)}`,
+            `Entries: ${output.success(metrics.performance.memoryEntries)}`,
             `Backend: ${output.success(metrics.performance.searchBackend)}`,
         ]);
         return { success: true, data: metrics };

package/packages/@monomind/cli/dist/src/commands/cleanup.js

@@ -5,8 +5,8 @@
  * github.com/monoes/monomind
  */
 import { output } from '../output.js';
-import { existsSync, lstatSync, rmSync, readdirSync } from 'fs';
-import { join } from 'path';
+import { existsSync, lstatSync, rmSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
 /**
  * Artifact directories and files that monomind/monomind may create
  */
@@ -190,13 +190,29 @@ export const cleanupCommand = {
                 // Actually delete
                 try {
                     const fullPath = join(cwd, item.path);
-                    if (item.type === 'dir') {
+                    // Special-case: `.claude/` is scanned and removed as a single unit,
+                    // but KEEP_CONFIG_PATHS promises `.claude/settings.json` survives
+                    // --keep-config. Back the file up, wipe the directory, then
+                    // restore just that one file — the rest of `.claude/` is still
+                    // removed as normal.
+                    const settingsPath = join(cwd, '.claude', 'settings.json');
+                    const isClaudeDirWithPreservedSettings = item.type === 'dir' && item.path === '.claude' && keepConfig && existsSync(settingsPath);
+                    if (isClaudeDirWithPreservedSettings) {
+                        const settingsBackup = readFileSync(settingsPath);
                         rmSync(fullPath, { recursive: true, force: true });
+                        mkdirSync(dirname(settingsPath), { recursive: true });
+                        writeFileSync(settingsPath, settingsBackup);
+                        output.writeln(output.success(`  [removed] ${typeLabel}  ${item.path}  (${sizeStr}) - ${item.description}`));
+                        output.writeln(output.dim(`  [kept]    file  .claude/settings.json - preserved (--keep-config)`));
+                    }
+                    else if (item.type === 'dir') {
+                        rmSync(fullPath, { recursive: true, force: true });
+                        output.writeln(output.success(`  [removed] ${typeLabel}  ${item.path}  (${sizeStr}) - ${item.description}`));
                     }
                     else {
                         rmSync(fullPath, { force: true });
+                        output.writeln(output.success(`  [removed] ${typeLabel}  ${item.path}  (${sizeStr}) - ${item.description}`));
                     }
-                    output.writeln(output.success(`  [removed] ${typeLabel}  ${item.path}  (${sizeStr}) - ${item.description}`));
                     removedCount++;
                     removedSize += item.size;
                 }