@nemus-cli/nemus 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-09-02
+
+### Added
+
+- **`nemus prune`** — bulk-delete workspaces with no recent activity, **safe by
+  default.** It selects workspaces whose most recent agent session (or, absent
+  any session, whose `createdAt`) is older than `--days` (default 30), and
+  **holds back any workspace with uncommitted or unpushed changes** — listing
+  each protected one and why. Preview with `--dry-run` or `--json` (both never
+  delete); otherwise it deletes after a confirmation (`-y/--yes` to skip).
+  `--include-dirty` overrides the safety guard. Deletions go through the same
+  validated `safeWorkspacePath()` choke point as `nemus delete`. The
+  stale/protected decision logic is pure and unit-tested.
+
 ## [0.10.0] - 2026-09-01
 
 ### Changed

package/README.md

@@ -202,9 +202,22 @@ nemus create           # (c) interactive create
 nemus list             # (l) list workspaces
 nemus update           # (u) add repos to a workspace
 nemus delete           # (del) delete a workspace
+nemus prune            # delete workspaces with no recent activity (safe by default)
 nemus go [name]        # jump to a workspace directory
 ```
 
+> **`prune`** clears out workspaces you've finished with. It selects those with
+> no agent session (or, failing that, no `createdAt`) in the last **N days**
+> (`--days`, default 30) and — crucially — **protects any workspace with
+> uncommitted or unpushed work**, listing why it was skipped. Preview with
+> `--dry-run` (or `--json`), then delete after a confirmation (`--yes` to skip).
+> `--include-dirty` overrides the safety guard. Example:
+>
+> ```bash
+> nemus prune --days 30 --dry-run   # see what would go, nothing deleted
+> nemus prune --days 30             # prune stale + clean workspaces, with a prompt
+> ```
+
 ### Operate across all repos
 
 ```bash

package/dist/commands/prune.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPruneCommand = registerPruneCommand;
+exports.handlePrune = handlePrune;
+const fs = __importStar(require("fs/promises"));
+const validation_1 = require("../utils/validation");
+const workspace_meta_1 = require("../utils/workspace-meta");
+const claude_sessions_1 = require("../utils/claude-sessions");
+const git_status_1 = require("../utils/git-status");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+const prompt_1 = require("../utils/prompt");
+const command_helpers_1 = require("../utils/command-helpers");
+const output_1 = require("../utils/output");
+const prune_1 = require("../utils/prune");
+const DEFAULT_DAYS = 30;
+function registerPruneCommand(parent) {
+    parent
+        .command('prune')
+        .description('Delete workspaces with no recent activity (safe by default)')
+        .option('-d, --days <n>', `Consider a workspace stale after N days of inactivity (default ${DEFAULT_DAYS})`)
+        .option('--include-dirty', 'Also prune workspaces with uncommitted/unpushed changes (default: protected)')
+        .option('--dry-run', 'Show what would be pruned without deleting anything')
+        .option('-y, --yes', 'Skip the confirmation prompt')
+        .option('--json', 'Output the prune plan as JSON (never deletes)')
+        .action(async (opts, cmd) => {
+        const globalOpts = (0, command_helpers_1.getGlobalOpts)(cmd);
+        await handlePrune({ ...opts, ...globalOpts });
+    });
+}
+function parseDays(raw) {
+    if (raw === undefined)
+        return DEFAULT_DAYS;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 0)
+        return null;
+    return Math.floor(n);
+}
+async function handlePrune(opts) {
+    const json = !!opts.json;
+    const days = parseDays(opts.days);
+    if (days === null) {
+        if (json)
+            (0, output_1.outputJsonError)('--days must be a non-negative number');
+        else
+            (0, logger_1.logError)('--days must be a non-negative number');
+        process.exit(1);
+    }
+    try {
+        const [workspaces, sessions] = await Promise.all([(0, workspace_meta_1.listWorkspaces)(), (0, claude_sessions_1.getWorkspaceSessions)()]);
+        const sessionMap = new Map(sessions.map((s) => [s.workspaceName, s]));
+        const now = Date.now();
+        const candidates = workspaces.map((ws) => {
+            const session = sessionMap.get(ws.name);
+            const createdRaw = ws.metadata?.createdAt ? Date.parse(ws.metadata.createdAt) : NaN;
+            const forPrune = {
+                name: ws.name,
+                path: ws.path,
+                repoDirNames: (ws.metadata?.repositories ?? []).map((r) => r.directoryName),
+                lastActiveAt: session ? session.lastActiveAt.getTime() : 0,
+                createdAt: Number.isFinite(createdRaw) ? createdRaw : 0,
+            };
+            return (0, prune_1.toCandidate)(forPrune, now);
+        });
+        const stale = candidates.filter((c) => (0, prune_1.isStale)(c, days));
+        if (stale.length === 0) {
+            if (json) {
+                (0, output_1.outputJson)({ ok: true, days, prunable: [], protected: [], scanned: workspaces.length });
+            }
+            else {
+                (0, logger_1.logInfo)(`No workspaces inactive for ${days}+ days (scanned ${workspaces.length}).`);
+            }
+            return;
+        }
+        // Compute the plan. The git safety check only runs for stale workspaces.
+        const plan = await (0, prune_1.planPrune)(stale, (c) => (0, git_status_1.getAllReposStatus)(c.path, c.repoDirNames, 3), !!opts.includeDirty);
+        if (json) {
+            (0, output_1.outputJson)({
+                ok: true,
+                days,
+                scanned: workspaces.length,
+                prunable: plan.prunable.map((c) => ({ name: c.name, path: c.path, ageDays: c.ageDays, repos: c.repoDirNames.length })),
+                protected: plan.protected.map((p) => ({ name: p.candidate.name, ageDays: p.candidate.ageDays, reason: p.reason })),
+            });
+            return;
+        }
+        // Human report.
+        console.log('\n' + '='.repeat(60));
+        console.log((0, colors_1.colorize)(`Prune — workspaces inactive for ${days}+ days`, 'bright'));
+        console.log('='.repeat(60) + '\n');
+        if (plan.protected.length > 0) {
+            (0, logger_1.logWarning)(`Protected (${plan.protected.length}) — skipped due to unsaved work:`);
+            for (const p of plan.protected) {
+                console.log(`  ${(0, colors_1.colorize)('•', 'yellow')} ${(0, colors_1.colorize)(p.candidate.name, 'cyan')} — ${p.reason} ${(0, colors_1.colorize)(`(${ageLabel(p.candidate)})`, 'gray')}`);
+            }
+            console.log('');
+        }
+        if (plan.prunable.length === 0) {
+            (0, logger_1.logInfo)('Nothing safe to prune.');
+            if (plan.protected.length > 0)
+                (0, logger_1.logInfo)('Re-run with --include-dirty to include the protected ones (careful).');
+            return;
+        }
+        console.log(`${(0, colors_1.colorize)('Prunable', 'bright')} (${plan.prunable.length}):`);
+        for (const c of plan.prunable) {
+            const repoLabel = c.repoDirNames.length === 1 ? '1 repo' : `${c.repoDirNames.length} repos`;
+            console.log(`  ${(0, colors_1.colorize)('✗', 'red')} ${(0, colors_1.colorize)(c.name, 'cyan')} ${(0, colors_1.colorize)(`(${ageLabel(c)}, ${repoLabel})`, 'gray')}`);
+        }
+        console.log('');
+        if (opts.dryRun) {
+            (0, logger_1.logInfo)(`Dry run — nothing deleted. ${plan.prunable.length} workspace(s) would be pruned.`);
+            return;
+        }
+        (0, logger_1.logWarning)('This permanently deletes the selected workspaces and every cloned repo inside them!');
+        if (!opts.yes) {
+            const confirmed = await (0, prompt_1.confirm)({
+                message: plan.prunable.length === 1
+                    ? `Prune workspace ${plan.prunable[0].name}?`
+                    : `Prune these ${plan.prunable.length} workspaces?`,
+                default: false,
+            });
+            if (!confirmed) {
+                (0, logger_1.logInfo)('Prune cancelled');
+                return;
+            }
+        }
+        let deleted = 0;
+        for (const c of plan.prunable) {
+            let target;
+            try {
+                // Re-validate through the same choke point delete uses: enforces the
+                // name allowlist and pins the path inside WORKSPACES_DIR.
+                target = (0, validation_1.safeWorkspacePath)(c.name);
+            }
+            catch (error) {
+                (0, logger_1.logError)(error instanceof Error ? error.message : `Invalid workspace name "${c.name}"`);
+                continue;
+            }
+            try {
+                await fs.rm(target, { recursive: true, force: true });
+                (0, logger_1.logSuccess)(`Pruned "${(0, colors_1.colorize)(c.name, 'cyan')}"`);
+                deleted++;
+            }
+            catch (error) {
+                (0, logger_1.logError)(`Failed to prune "${c.name}"`);
+                if (error instanceof Error)
+                    (0, logger_1.logError)(error.message);
+            }
+        }
+        (0, logger_1.logStep)(`Pruned ${deleted} of ${plan.prunable.length} workspace(s).`);
+    }
+    catch (error) {
+        if (json)
+            (0, output_1.outputJsonError)(error instanceof Error ? error.message : 'prune failed');
+        else
+            (0, logger_1.logError)(error instanceof Error ? error.message : 'prune failed');
+        process.exit(1);
+    }
+}
+function ageLabel(c) {
+    const base = c.ageDays === 1 ? '1 day' : `${c.ageDays} days`;
+    return c.fromSession ? `${base} since last session` : `${base} since created, no sessions`;
+}

package/dist/program.js

@@ -70,6 +70,7 @@ const create_1 = require("./commands/create");
 const list_1 = require("./commands/list");
 const update_1 = require("./commands/update");
 const delete_1 = require("./commands/delete");
+const prune_1 = require("./commands/prune");
 const sync_1 = require("./commands/sync");
 const status_1 = require("./commands/status");
 const diff_1 = require("./commands/diff");
@@ -96,6 +97,7 @@ const reflect_1 = require("./commands/reflect");
 (0, list_1.registerListCommand)(exports.program);
 (0, update_1.registerUpdateCommand)(exports.program);
 (0, delete_1.registerDeleteCommand)(exports.program);
+(0, prune_1.registerPruneCommand)(exports.program);
 (0, sync_1.registerSyncCommand)(exports.program);
 (0, status_1.registerStatusCommand)(exports.program);
 (0, diff_1.registerDiffCommand)(exports.program);

package/dist/utils/prune.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCandidate = toCandidate;
+exports.isStale = isStale;
+exports.protectionReason = protectionReason;
+exports.planPrune = planPrune;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/** Build a dated candidate for a workspace. `now` is injected for testability. */
+function toCandidate(ws, now) {
+    const referenceAt = ws.lastActiveAt > 0 ? ws.lastActiveAt : ws.createdAt;
+    const undatable = !(referenceAt > 0);
+    const ageDays = undatable ? 0 : Math.floor((now - referenceAt) / MS_PER_DAY);
+    return {
+        name: ws.name,
+        path: ws.path,
+        repoDirNames: ws.repoDirNames,
+        referenceAt,
+        fromSession: ws.lastActiveAt > 0,
+        ageDays,
+        undatable,
+    };
+}
+/**
+ * A workspace is a prune candidate when it is datable and its age meets the
+ * threshold. Undatable workspaces are never auto-selected — we won't delete
+ * something we can't put a date on. A future `referenceAt` (clock skew) yields
+ * a negative age and is therefore not stale.
+ */
+function isStale(c, days) {
+    return !c.undatable && c.ageDays >= days;
+}
+/**
+ * Why a stale workspace should be held back from deletion, or null if it's safe.
+ * Unsafe = any repo has uncommitted changes (`!clean`) or unpushed commits
+ * (`ahead > 0`). With `includeDirty`, nothing is held back. An empty workspace
+ * (no repos) is always safe.
+ */
+function protectionReason(statuses, includeDirty) {
+    if (includeDirty)
+        return null;
+    const dirty = statuses.filter((s) => !s.clean).length;
+    const unpushed = statuses.filter((s) => s.ahead > 0).length;
+    if (dirty === 0 && unpushed === 0)
+        return null;
+    const parts = [];
+    if (dirty > 0)
+        parts.push(`${dirty} repo${dirty === 1 ? '' : 's'} with uncommitted changes`);
+    if (unpushed > 0)
+        parts.push(`${unpushed} repo${unpushed === 1 ? '' : 's'} with unpushed commits`);
+    return parts.join(', ');
+}
+/**
+ * Partition stale candidates into prunable vs. protected, given a resolver that
+ * returns each workspace's per-repo git status. The resolver is only invoked
+ * for workspaces that actually have repos, so empty stale workspaces cost no git
+ * calls. Injecting the resolver keeps this function pure and unit-testable.
+ */
+async function planPrune(staleCandidates, getStatuses, includeDirty) {
+    const prunable = [];
+    const protectedList = [];
+    for (const c of staleCandidates) {
+        const statuses = c.repoDirNames.length > 0 ? await getStatuses(c) : [];
+        const reason = protectionReason(statuses, includeDirty);
+        if (reason)
+            protectedList.push({ candidate: c, reason });
+        else
+            prunable.push(c);
+    }
+    return { prunable, protected: protectedList };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nemus-cli/nemus",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "workspaces": [
     "packages/*"
   ],

package/scripts/release-notes.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// Emit GitHub Release notes for a given version by extracting that version's
+// section from CHANGELOG.md (newest-first "Keep a Changelog" format), prepended
+// with an install snippet and followed by a compare link to the previous tag.
+//
+// Usage: node scripts/release-notes.mjs <version> [repo]
+//   repo defaults to $GITHUB_REPOSITORY or "me-public/nemus".
+//
+// If the version has no CHANGELOG section, prints a minimal fallback (so a
+// release is never blocked on a missing entry). Dependency-free; prints to
+// stdout so the workflow can redirect it into `gh release --notes-file`.
+import { readFileSync } from 'node:fs';
+
+const version = (process.argv[2] || '').trim();
+const repo = (process.argv[3] || process.env.GITHUB_REPOSITORY || 'me-public/nemus').trim();
+if (!version) {
+  process.stderr.write('usage: release-notes.mjs <version> [repo]\n');
+  process.exit(2);
+}
+
+const install = `\`\`\`bash\nnpm install -g @nemus-cli/nemus@${version}\n\`\`\``;
+
+let body = '';
+let prev = null;
+try {
+  const changelog = readFileSync(new URL('../CHANGELOG.md', import.meta.url), 'utf8');
+  const lines = changelog.split('\n');
+  // Collect version headers in file order (newest first) with their line index.
+  const heads = [];
+  lines.forEach((line, i) => {
+    const m = line.match(/^## \[(\d+\.\d+\.\d+)\]/);
+    if (m) heads.push({ version: m[1], line: i });
+  });
+  const idx = heads.findIndex((h) => h.version === version);
+  if (idx !== -1) {
+    const start = heads[idx].line + 1;
+    const end = idx + 1 < heads.length ? heads[idx + 1].line : lines.length;
+    body = lines.slice(start, end).join('\n').trim();
+    // Newest-first: the NEXT header in the file is the previous release.
+    prev = idx + 1 < heads.length ? heads[idx + 1].version : null;
+  }
+} catch {
+  // fall through to fallback
+}
+
+const compare = prev
+  ? `[\`v${prev}...v${version}\`](https://github.com/${repo}/compare/v${prev}...v${version})`
+  : `[\`v${version}\`](https://github.com/${repo}/releases/tag/v${version})`;
+
+const parts = [`## Nemus v${version}`, '', install];
+if (body) parts.push('', body);
+parts.push('', '---', '', `**Full diff:** ${compare} · [Full changelog](https://github.com/${repo}/blob/main/CHANGELOG.md)`);
+
+process.stdout.write(parts.join('\n') + '\n');

package/skills/config.md

@@ -0,0 +1,17 @@
+---
+name: config
+description: Read and write Nemus configuration non-interactively (get/set/unset/list/path/edit)
+---
+
+Non-interactive configuration in `~/.nemus/config.json` (no wizard):
+```bash
+nemus config list                 # all keys + resolved values (alias: ls; --json)
+nemus config get <key>            # print one value (--json)
+nemus config set <key> <value>    # set + validate + persist
+nemus config unset <key>          # revert a key to its default
+nemus config path                 # print the config file path
+```
+
+- Values are validated/coerced per key: booleans accept `true/false/yes/no/on/off/1/0`; enums (e.g. `cloneProtocol=ssh|https`) are checked. Invalid key/value exits non-zero.
+- Common keys: `workspacesDir`, `githubOrg`, `cloneProtocol`, `aiAgent`, `primaryAgent`. Run `nemus config list` to see all.
+- For a guided first-time setup, use `nemus configure` instead.

package/skills/nemus/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: nemus
 description: Manage multi-repo development workspaces — create, sync, branch, diff, clone, archive, analyze dependencies, run commands across repos, check status, clean up, delete, list org repos, search repos, list suites, remove repo, cache, suite management, sessions, history, generate docs, configure, MCP server, AI prompt. Use when working with workspaces, repos, branches, git operations across multiple repos, or the `nemus` CLI tool. NEVER use `git clone` directly — always use `nemus update` to add repos and `nemus create` to create workspaces.
-bashPattern: "\\bnemus\\s+(create|list|update|delete|sync|status|diff|run|go|doctor|analyze-deps|history|cleanup|remove-repo|archive|sessions|generate-docs|configure|configure-claude|ghq-status|tui|dashboard|dash|branch|suite|cache|mcp|--)\\b"
+bashPattern: "\\bnemus\\s+(create|list|update|delete|prune|sync|status|diff|run|go|doctor|analyze-deps|reflect|retro|history|cleanup|remove-repo|archive|sessions|save-context|ctx|generate-docs|configure|config|configure-claude|ghq-status|completion|tui|dashboard|dash|branch|suite|cache|mcp|--)\\b"
 ---
 
 # Nemus
@@ -33,6 +33,7 @@ Global flags: `-f/--force-refresh` (skip repo cache), `-y/--yes` (skip prompts),
 | Create new workspace | [create-workspace](references/create-workspace.md) | `nemus create` | `c` |
 | Add repos to workspace | [update-workspace](references/update-workspace.md) | `nemus update` | `u` |
 | Delete workspace permanently | [delete-workspace](references/delete-workspace.md) | `nemus delete` | `d` |
+| Prune inactive workspaces (safe) | [prune](references/prune.md) | `nemus prune` | — |
 | Archive / unarchive workspace | [archive-workspace](references/archive-workspace.md) | `nemus archive` | `a` |
 | List all workspaces | [list-workspaces](references/list-workspaces.md) | `nemus list` | `l` |
 | Navigate to workspace | [go](references/go.md) | `nemus go [name]` | — |
@@ -88,14 +89,18 @@ Global flags: `-f/--force-refresh` (skip repo cache), `-y/--yes` (skip prompts),
 | Resume Claude session | [sessions](references/sessions.md) | `nemus sessions` | `ses` |
 | Agent management dashboard | [dashboard](references/dashboard.md) | `nemus dashboard` | `dash` |
 | View operation history | [history](references/history.md) | `nemus history` | `h` |
+| Save progress/context to a workspace | [save-context](references/save-context.md) | `nemus save-context` | `ctx` |
+| Retrospective on recent sessions | [reflect](references/reflect.md) | `nemus reflect` | `retro` |
 
 ### Configuration & MCP
 
 | Intent | Reference | CLI |
 |---|---|---|
-| Configure Nemus | [configure](references/configure.md) | `nemus configure` |
+| Configure Nemus (interactive wizard) | [configure](references/configure.md) | `nemus configure` |
+| Get/set config non-interactively | [config](references/config.md) | `nemus config get\|set\|list\|edit` |
 | Configure Claude integration | [configure-claude](references/configure-claude.md) | `nemus configure-claude` |
 | Check ghq status | [ghq-status](references/ghq-status.md) | `nemus ghq-status` |
+| Shell completions (bash/zsh/fish) | [completion](references/completion.md) | `nemus completion <shell>` |
 | Install / manage MCP server | [mcp](references/mcp.md) | `nemus mcp install\|status\|upgrade\|uninstall` |
 
 ### AI Assistant & TUI

package/skills/nemus/references/completion.md

@@ -0,0 +1,22 @@
+# Shell Completions
+
+`nemus completion <shell>` prints a completion script for `bash`, `zsh`, or
+`fish`. It completes subcommands and, for workspace-scoped commands, live
+workspace names (the script calls back into `nemus completion --workspaces`, so
+completions stay fresh without regenerating). Registered for both `nemus` and
+`nem`.
+
+Install (pick your shell):
+```bash
+# bash
+nemus completion bash > /etc/bash_completion.d/nemus     # or: >> ~/.bashrc
+
+# zsh — save on your $fpath as _nemus
+nemus completion zsh > "${fpath[1]}/_nemus"
+
+# fish
+nemus completion fish > ~/.config/fish/completions/nemus.fish
+```
+
+Then restart the shell (or `source` the file). Requires a shell argument —
+one of `bash|zsh|fish`.

package/skills/nemus/references/config.md

@@ -0,0 +1,32 @@
+# Config — non-interactive configuration
+
+`nemus config` reads and writes `~/.nemus/config.json` without the interactive
+`nemus configure` wizard. Ideal for scripting and for setting one value.
+
+```bash
+nemus config list                 # show all keys + resolved values (alias: ls)
+nemus config list --json          # machine-readable
+nemus config get <key>            # print one value (--json for structured)
+nemus config set <key> <value>    # set + validate + persist
+nemus config unset <key>          # remove a key (revert to default)
+nemus config path                 # print the config file path
+nemus config edit                 # open the file in $VISUAL/$EDITOR (needs a TTY)
+```
+
+Values are validated and coerced per key: booleans accept
+`true/false/yes/no/on/off/1/0`; enums (e.g. `cloneProtocol` = `ssh|https`) are
+checked. An unknown key or invalid value exits non-zero with a clear message.
+
+Common keys: `workspacesDir`, `githubOrg`, `cloneProtocol`, `aiAgent`,
+`primaryAgent`, `autoLaunchClaude`, `generateClaudeContext`, `installMcp`.
+Run `nemus config list` to see them all.
+
+```bash
+# examples
+nemus config set githubOrg acme
+nemus config set cloneProtocol https
+nemus config get workspacesDir --json
+```
+
+Pairs well with `--quiet` for scripts. For a guided first-time setup, use
+`nemus configure` instead.

package/skills/nemus/references/prune.md

@@ -0,0 +1,44 @@
+# Prune Inactive Workspaces
+
+Bulk-delete workspaces with no recent activity. **Safe by default** — it holds
+back any workspace with uncommitted or unpushed work.
+
+1. **Always preview first.** Show the user exactly what would be deleted (and
+   what is protected) before removing anything:
+   ```bash
+   nemus prune --days <n> --dry-run
+   ```
+   A workspace is *stale* when its most recent agent session — or, if it has no
+   session, its `createdAt` — is older than `--days` (default 30). Workspaces
+   with no date at all are never selected.
+
+2. **Review the two lists.** `prune` prints:
+   - **Protected** — stale workspaces skipped because a repo has uncommitted
+     changes or unpushed commits (with the reason). These are NOT deleted.
+   - **Prunable** — stale workspaces that are safe to remove.
+
+3. **Confirm with the user, then prune.** This permanently deletes the
+   workspace directories and every cloned repo inside them:
+   ```bash
+   nemus prune --days <n>          # prompts for confirmation (default: No)
+   nemus prune --days <n> --yes    # non-interactive (only when the user is sure)
+   ```
+
+4. **`--json`** gives a machine-readable plan (`{ prunable, protected }`) and,
+   like `--dry-run`, never deletes.
+
+Deletions go through the same validated path as `nemus delete` (name allowlist +
+path pinned inside the workspaces directory).
+
+## Flags
+
+| Flag | Short | Description |
+|---|---|---|
+| `--days <n>` | `-d` | Stale after N days of inactivity (default 30) |
+| `--dry-run` | | Show the plan without deleting anything |
+| `--json` | | Output the plan as JSON (never deletes) |
+| `--yes` | `-y` | Skip the confirmation prompt |
+| `--include-dirty` | | Also prune workspaces with uncommitted/unpushed work (overrides the safety guard — use with care) |
+
+> **Only** pass `--include-dirty` when the user has explicitly accepted losing
+> uncommitted/unpushed work in the protected workspaces.

package/skills/nemus/references/reflect.md

@@ -0,0 +1,43 @@
+# Reflect — retrospective on recent sessions
+
+`nemus reflect` (alias `retro`) reads your recent workspaces' agent session
+transcripts and asks *your own* configured agent (claude/pi/opencode — no API key
+of Nemus's) to recommend concrete setup improvements: skills to add, missing
+`AGENTS.md`/context rules, missing connectivity/smoke tests, and prompt/workflow
+habits — each with a priority and an example.
+
+```bash
+nemus reflect                     # analyze the most recent workspaces (default 10)
+nemus reflect --limit 20          # widen the window
+nemus reflect --workspace <name>  # analyze a single workspace
+```
+
+Output / sharing:
+```bash
+nemus reflect --json              # structured report ({ ok:false, error } on failure)
+nemus reflect --markdown > reflection.md   # paste into an issue/PR
+nemus reflect --group-by kind     # group recommendations by kind (default: priority)
+```
+
+Review saved reports (each run is saved under `~/.nemus/reflect/` unless
+`--no-save`):
+```bash
+nemus reflect history             # list saved reports
+nemus reflect show [id]           # show one (id or id-prefix; defaults to latest)
+```
+
+## Flags
+
+| Flag | Description |
+|---|---|
+| `--limit <n>` / `-n` | How many recent workspaces to analyze (default 10) |
+| `--workspace <name>` / `-w` | Analyze a single workspace (ignores `--limit`) |
+| `--json` | Structured JSON report to stdout |
+| `--markdown` | Markdown report to stdout |
+| `--group-by <how>` | `priority` (default) or `kind` |
+| `--no-save` | Don't save the report to `~/.nemus/reflect/` |
+| `--model` / `--thinking` | Judge model / pi thinking-level overrides |
+| `--dry-run` | Print the assembled corpus + judge prompt without calling the agent |
+
+Read-only and safe — it analyzes transcripts and prints advice; it changes no
+repos. Use it to coach setup, not to modify anything.

package/skills/nemus/references/save-context.md

@@ -0,0 +1,25 @@
+# Save Context
+
+`nemus save-context` (alias `ctx`) writes a progress summary to the workspace's
+`CONTEXT.md`, so work survives `/clear` or a new session. Read `CONTEXT.md` back
+at the start of a session to resume. The workspace defaults to the current
+directory; pass `-w` to target another.
+
+```bash
+nemus save-context -m "…"                 # save to the current workspace
+nemus save-context -w <name> -m "…"       # target a specific workspace
+nemus save-context                        # interactive: prompts for the summary
+nemus save-context -f notes.md --append   # read from a file, append (don't replace)
+```
+
+Use it to capture: what was done, what's in progress, key decisions, and the
+next steps — before a context reset or when handing off.
+
+## Flags
+
+| Flag | Short | Description |
+|---|---|---|
+| `--workspace <name>` | `-w` | Workspace name (default: current directory) |
+| `--message <text>` | `-m` | Summary text to save (skips the prompt) |
+| `--file <path>` | `-f` | Read the summary from a file |
+| `--append` | | Append to existing context instead of replacing |

package/skills/prune-workspaces.md

@@ -0,0 +1,23 @@
+---
+name: prune-workspaces
+description: Bulk-delete workspaces with no recent activity, safe by default (protects uncommitted/unpushed work)
+---
+
+Preview first — never delete without showing the user the plan:
+```bash
+nemus prune --days 30 --dry-run
+```
+
+Then prune after confirming with the user:
+```bash
+nemus prune --days 30          # prompts (default: No)
+nemus prune --days 30 --yes    # non-interactive — only when the user is sure
+```
+
+- **Stale** = no agent session (or, failing that, no `createdAt`) in the last N
+  days (`--days`, default 30). Undatable workspaces are never selected.
+- **Safe by default:** workspaces with uncommitted or unpushed changes are
+  **protected** and listed with the reason — not deleted. `--include-dirty`
+  overrides this (only with explicit user consent to lose that work).
+- `--json` and `--dry-run` never delete.
+- Deletion is permanent — repos must be re-cloned. Always confirm first.

package/skills/reflect.md

@@ -0,0 +1,21 @@
+---
+name: reflect
+description: Retrospective on recent agent sessions — get concrete tips to improve skills, context, and prompts
+---
+
+Analyze recent workspaces' agent sessions and get setup improvement tips (read-only; changes no repos):
+```bash
+nemus reflect                     # most recent workspaces (default 10)
+nemus reflect --workspace <name>  # a single workspace
+nemus reflect --markdown > reflection.md   # shareable report
+```
+
+Review saved reports (saved under `~/.nemus/reflect/` unless `--no-save`):
+```bash
+nemus reflect history      # list past reports
+nemus reflect show [id]    # show one (defaults to latest)
+```
+
+- Uses *your own* configured agent (claude/pi/opencode) as the judge — no API key of Nemus's.
+- `--json` / `--markdown` for machine or shareable output; `--group-by kind|priority`.
+- Safe: it reads transcripts and prints advice, nothing is modified.

package/src/commands/prune.ts

@@ -0,0 +1,183 @@
+import { Command } from 'commander';
+import * as fs from 'fs/promises';
+import { safeWorkspacePath } from '../utils/validation';
+import { listWorkspaces } from '../utils/workspace-meta';
+import { getWorkspaceSessions } from '../utils/claude-sessions';
+import { getAllReposStatus } from '../utils/git-status';
+import { logInfo, logSuccess, logError, logWarning, logStep } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { confirm } from '../utils/prompt';
+import { getGlobalOpts } from '../utils/command-helpers';
+import { outputJson, outputJsonError } from '../utils/output';
+import {
+  toCandidate,
+  isStale,
+  planPrune,
+  type WorkspaceForPrune,
+  type PruneCandidate,
+} from '../utils/prune';
+
+const DEFAULT_DAYS = 30;
+
+export function registerPruneCommand(parent: Command) {
+  parent
+    .command('prune')
+    .description('Delete workspaces with no recent activity (safe by default)')
+    .option('-d, --days <n>', `Consider a workspace stale after N days of inactivity (default ${DEFAULT_DAYS})`)
+    .option('--include-dirty', 'Also prune workspaces with uncommitted/unpushed changes (default: protected)')
+    .option('--dry-run', 'Show what would be pruned without deleting anything')
+    .option('-y, --yes', 'Skip the confirmation prompt')
+    .option('--json', 'Output the prune plan as JSON (never deletes)')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      await handlePrune({ ...opts, ...globalOpts });
+    });
+}
+
+function parseDays(raw: unknown): number | null {
+  if (raw === undefined) return DEFAULT_DAYS;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) return null;
+  return Math.floor(n);
+}
+
+export async function handlePrune(opts: {
+  days?: string;
+  includeDirty?: boolean;
+  dryRun?: boolean;
+  yes?: boolean;
+  json?: boolean;
+}) {
+  const json = !!opts.json;
+  const days = parseDays(opts.days);
+  if (days === null) {
+    if (json) outputJsonError('--days must be a non-negative number');
+    else logError('--days must be a non-negative number');
+    process.exit(1);
+  }
+
+  try {
+    const [workspaces, sessions] = await Promise.all([listWorkspaces(), getWorkspaceSessions()]);
+    const sessionMap = new Map(sessions.map((s) => [s.workspaceName, s]));
+    const now = Date.now();
+
+    const candidates: PruneCandidate[] = workspaces.map((ws) => {
+      const session = sessionMap.get(ws.name);
+      const createdRaw = ws.metadata?.createdAt ? Date.parse(ws.metadata.createdAt) : NaN;
+      const forPrune: WorkspaceForPrune = {
+        name: ws.name,
+        path: ws.path,
+        repoDirNames: (ws.metadata?.repositories ?? []).map((r) => r.directoryName),
+        lastActiveAt: session ? session.lastActiveAt.getTime() : 0,
+        createdAt: Number.isFinite(createdRaw) ? createdRaw : 0,
+      };
+      return toCandidate(forPrune, now);
+    });
+
+    const stale = candidates.filter((c) => isStale(c, days));
+
+    if (stale.length === 0) {
+      if (json) {
+        outputJson({ ok: true, days, prunable: [], protected: [], scanned: workspaces.length });
+      } else {
+        logInfo(`No workspaces inactive for ${days}+ days (scanned ${workspaces.length}).`);
+      }
+      return;
+    }
+
+    // Compute the plan. The git safety check only runs for stale workspaces.
+    const plan = await planPrune(
+      stale,
+      (c) => getAllReposStatus(c.path, c.repoDirNames, 3),
+      !!opts.includeDirty,
+    );
+
+    if (json) {
+      outputJson({
+        ok: true,
+        days,
+        scanned: workspaces.length,
+        prunable: plan.prunable.map((c) => ({ name: c.name, path: c.path, ageDays: c.ageDays, repos: c.repoDirNames.length })),
+        protected: plan.protected.map((p) => ({ name: p.candidate.name, ageDays: p.candidate.ageDays, reason: p.reason })),
+      });
+      return;
+    }
+
+    // Human report.
+    console.log('\n' + '='.repeat(60));
+    console.log(colorize(`Prune — workspaces inactive for ${days}+ days`, 'bright'));
+    console.log('='.repeat(60) + '\n');
+
+    if (plan.protected.length > 0) {
+      logWarning(`Protected (${plan.protected.length}) — skipped due to unsaved work:`);
+      for (const p of plan.protected) {
+        console.log(`  ${colorize('•', 'yellow')} ${colorize(p.candidate.name, 'cyan')} — ${p.reason} ${colorize(`(${ageLabel(p.candidate)})`, 'gray')}`);
+      }
+      console.log('');
+    }
+
+    if (plan.prunable.length === 0) {
+      logInfo('Nothing safe to prune.');
+      if (plan.protected.length > 0) logInfo('Re-run with --include-dirty to include the protected ones (careful).');
+      return;
+    }
+
+    console.log(`${colorize('Prunable', 'bright')} (${plan.prunable.length}):`);
+    for (const c of plan.prunable) {
+      const repoLabel = c.repoDirNames.length === 1 ? '1 repo' : `${c.repoDirNames.length} repos`;
+      console.log(`  ${colorize('✗', 'red')} ${colorize(c.name, 'cyan')} ${colorize(`(${ageLabel(c)}, ${repoLabel})`, 'gray')}`);
+    }
+    console.log('');
+
+    if (opts.dryRun) {
+      logInfo(`Dry run — nothing deleted. ${plan.prunable.length} workspace(s) would be pruned.`);
+      return;
+    }
+
+    logWarning('This permanently deletes the selected workspaces and every cloned repo inside them!');
+
+    if (!opts.yes) {
+      const confirmed = await confirm({
+        message: plan.prunable.length === 1
+          ? `Prune workspace ${plan.prunable[0].name}?`
+          : `Prune these ${plan.prunable.length} workspaces?`,
+        default: false,
+      });
+      if (!confirmed) {
+        logInfo('Prune cancelled');
+        return;
+      }
+    }
+
+    let deleted = 0;
+    for (const c of plan.prunable) {
+      let target: string;
+      try {
+        // Re-validate through the same choke point delete uses: enforces the
+        // name allowlist and pins the path inside WORKSPACES_DIR.
+        target = safeWorkspacePath(c.name);
+      } catch (error) {
+        logError(error instanceof Error ? error.message : `Invalid workspace name "${c.name}"`);
+        continue;
+      }
+      try {
+        await fs.rm(target, { recursive: true, force: true });
+        logSuccess(`Pruned "${colorize(c.name, 'cyan')}"`);
+        deleted++;
+      } catch (error) {
+        logError(`Failed to prune "${c.name}"`);
+        if (error instanceof Error) logError(error.message);
+      }
+    }
+    logStep(`Pruned ${deleted} of ${plan.prunable.length} workspace(s).`);
+  } catch (error) {
+    if (json) outputJsonError(error instanceof Error ? error.message : 'prune failed');
+    else logError(error instanceof Error ? error.message : 'prune failed');
+    process.exit(1);
+  }
+}
+
+function ageLabel(c: PruneCandidate): string {
+  const base = c.ageDays === 1 ? '1 day' : `${c.ageDays} days`;
+  return c.fromSession ? `${base} since last session` : `${base} since created, no sessions`;
+}

package/src/program.ts

@@ -39,6 +39,7 @@ import { registerCreateCommand } from './commands/create';
 import { registerListCommand } from './commands/list';
 import { registerUpdateCommand } from './commands/update';
 import { registerDeleteCommand } from './commands/delete';
+import { registerPruneCommand } from './commands/prune';
 import { registerSyncCommand } from './commands/sync';
 import { registerStatusCommand } from './commands/status';
 import { registerDiffCommand } from './commands/diff';
@@ -66,6 +67,7 @@ registerCreateCommand(program);
 registerListCommand(program);
 registerUpdateCommand(program);
 registerDeleteCommand(program);
+registerPruneCommand(program);
 registerSyncCommand(program);
 registerStatusCommand(program);
 registerDiffCommand(program);

package/src/utils/prune.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import {
+  toCandidate,
+  isStale,
+  protectionReason,
+  planPrune,
+  type WorkspaceForPrune,
+  type PruneCandidate,
+} from './prune';
+import type { GitStatus } from '../types';
+
+const NOW = Date.parse('2026-09-01T00:00:00Z');
+const daysAgo = (n: number) => NOW - n * 24 * 60 * 60 * 1000;
+
+function ws(over: Partial<WorkspaceForPrune> = {}): WorkspaceForPrune {
+  return { name: 'w', path: '/w', repoDirNames: [], lastActiveAt: 0, createdAt: 0, ...over };
+}
+function status(over: Partial<GitStatus> = {}): GitStatus {
+  return {
+    repo: 'r', branch: 'main', clean: true, ahead: 0, behind: 0,
+    modifiedFiles: 0, untrackedFiles: 0, hasRemote: true, detachedHead: false, ...over,
+  };
+}
+
+describe('toCandidate', () => {
+  it('prefers lastActive over createdAt and marks fromSession', () => {
+    const c = toCandidate(ws({ lastActiveAt: daysAgo(5), createdAt: daysAgo(40) }), NOW);
+    expect(c.fromSession).toBe(true);
+    expect(c.ageDays).toBe(5);
+    expect(c.undatable).toBe(false);
+  });
+
+  it('falls back to createdAt when there is no session', () => {
+    const c = toCandidate(ws({ lastActiveAt: 0, createdAt: daysAgo(40) }), NOW);
+    expect(c.fromSession).toBe(false);
+    expect(c.ageDays).toBe(40);
+  });
+
+  it('is undatable when neither timestamp is present', () => {
+    const c = toCandidate(ws({ lastActiveAt: 0, createdAt: 0 }), NOW);
+    expect(c.undatable).toBe(true);
+    expect(c.ageDays).toBe(0);
+  });
+
+  it('floors a future reference to a negative age (clock skew) without marking undatable', () => {
+    const c = toCandidate(ws({ lastActiveAt: NOW + 60_000 }), NOW);
+    expect(c.undatable).toBe(false);
+    expect(c.ageDays).toBeLessThan(0);
+  });
+});
+
+describe('isStale', () => {
+  const c = (over: Partial<WorkspaceForPrune>) => toCandidate(ws(over), NOW);
+
+  it('is true at or beyond the threshold', () => {
+    expect(isStale(c({ lastActiveAt: daysAgo(30) }), 30)).toBe(true);
+    expect(isStale(c({ lastActiveAt: daysAgo(31) }), 30)).toBe(true);
+  });
+  it('is false below the threshold', () => {
+    expect(isStale(c({ lastActiveAt: daysAgo(29) }), 30)).toBe(false);
+  });
+  it('never selects an undatable workspace', () => {
+    expect(isStale(c({ lastActiveAt: 0, createdAt: 0 }), 0)).toBe(false);
+  });
+  it('never selects a future-dated (skewed) workspace', () => {
+    expect(isStale(c({ lastActiveAt: NOW + 86_400_000 }), 0)).toBe(false);
+  });
+});
+
+describe('protectionReason', () => {
+  it('returns null for an all-clean workspace', () => {
+    expect(protectionReason([status(), status()], false)).toBeNull();
+  });
+  it('returns null for an empty workspace', () => {
+    expect(protectionReason([], false)).toBeNull();
+  });
+  it('flags uncommitted changes', () => {
+    expect(protectionReason([status({ clean: false })], false)).toBe('1 repo with uncommitted changes');
+  });
+  it('flags unpushed commits', () => {
+    expect(protectionReason([status({ ahead: 2 })], false)).toBe('1 repo with unpushed commits');
+  });
+  it('combines both reasons and pluralizes', () => {
+    expect(
+      protectionReason([status({ clean: false }), status({ clean: false }), status({ ahead: 1 })], false),
+    ).toBe('2 repos with uncommitted changes, 1 repo with unpushed commits');
+  });
+  it('returns null when includeDirty overrides protection', () => {
+    expect(protectionReason([status({ clean: false, ahead: 3 })], true)).toBeNull();
+  });
+});
+
+describe('planPrune', () => {
+  const mk = (name: string, repos: string[]): PruneCandidate =>
+    toCandidate(ws({ name, path: `/w/${name}`, repoDirNames: repos, lastActiveAt: daysAgo(40) }), NOW);
+
+  it('partitions prunable vs protected and skips git calls for empty workspaces', async () => {
+    const empty = mk('empty', []);
+    const clean = mk('clean', ['a']);
+    const dirty = mk('dirty', ['b']);
+    let calls = 0;
+    const resolver = async (c: PruneCandidate): Promise<GitStatus[]> => {
+      calls++;
+      return c.name === 'dirty' ? [status({ clean: false })] : [status()];
+    };
+
+    const plan = await planPrune([empty, clean, dirty], resolver, false);
+
+    expect(plan.prunable.map((c) => c.name)).toEqual(['empty', 'clean']);
+    expect(plan.protected.map((p) => p.candidate.name)).toEqual(['dirty']);
+    expect(plan.protected[0].reason).toBe('1 repo with uncommitted changes');
+    expect(calls).toBe(2); // empty workspace incurred no status call
+  });
+
+  it('includeDirty moves everything to prunable', async () => {
+    const dirty = mk('dirty', ['b']);
+    const plan = await planPrune([dirty], async () => [status({ clean: false, ahead: 2 })], true);
+    expect(plan.prunable.map((c) => c.name)).toEqual(['dirty']);
+    expect(plan.protected).toHaveLength(0);
+  });
+});

package/src/utils/prune.ts

@@ -0,0 +1,109 @@
+// Pure logic for `nemus prune` — deciding which workspaces are stale and which
+// are unsafe to delete. Kept free of I/O so it can be unit-tested exhaustively;
+// the command layer (src/commands/prune.ts) does the filesystem/git work and
+// feeds the results in here.
+import type { GitStatus } from '../types';
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+export interface WorkspaceForPrune {
+  name: string;
+  path: string;
+  /** Repo directory names inside the workspace (for the git safety check). */
+  repoDirNames: string[];
+  /** Epoch ms of the most recent agent session, or 0 if none. */
+  lastActiveAt: number;
+  /** Epoch ms parsed from metadata.createdAt, or 0 if absent/unparseable. */
+  createdAt: number;
+}
+
+export interface PruneCandidate {
+  name: string;
+  path: string;
+  repoDirNames: string[];
+  /** The timestamp staleness is measured from (lastActive, else createdAt). */
+  referenceAt: number;
+  /** Whether the reference came from a real session (vs. createdAt fallback). */
+  fromSession: boolean;
+  /** Whole days since referenceAt (floored). */
+  ageDays: number;
+  /** True when we have no date at all to judge age. */
+  undatable: boolean;
+}
+
+export interface ProtectedWorkspace {
+  candidate: PruneCandidate;
+  reason: string;
+}
+
+export interface PrunePlan {
+  /** Stale + safe to delete. */
+  prunable: PruneCandidate[];
+  /** Stale but held back (uncommitted/unpushed work), unless includeDirty. */
+  protected: ProtectedWorkspace[];
+}
+
+/** Build a dated candidate for a workspace. `now` is injected for testability. */
+export function toCandidate(ws: WorkspaceForPrune, now: number): PruneCandidate {
+  const referenceAt = ws.lastActiveAt > 0 ? ws.lastActiveAt : ws.createdAt;
+  const undatable = !(referenceAt > 0);
+  const ageDays = undatable ? 0 : Math.floor((now - referenceAt) / MS_PER_DAY);
+  return {
+    name: ws.name,
+    path: ws.path,
+    repoDirNames: ws.repoDirNames,
+    referenceAt,
+    fromSession: ws.lastActiveAt > 0,
+    ageDays,
+    undatable,
+  };
+}
+
+/**
+ * A workspace is a prune candidate when it is datable and its age meets the
+ * threshold. Undatable workspaces are never auto-selected — we won't delete
+ * something we can't put a date on. A future `referenceAt` (clock skew) yields
+ * a negative age and is therefore not stale.
+ */
+export function isStale(c: PruneCandidate, days: number): boolean {
+  return !c.undatable && c.ageDays >= days;
+}
+
+/**
+ * Why a stale workspace should be held back from deletion, or null if it's safe.
+ * Unsafe = any repo has uncommitted changes (`!clean`) or unpushed commits
+ * (`ahead > 0`). With `includeDirty`, nothing is held back. An empty workspace
+ * (no repos) is always safe.
+ */
+export function protectionReason(statuses: GitStatus[], includeDirty: boolean): string | null {
+  if (includeDirty) return null;
+  const dirty = statuses.filter((s) => !s.clean).length;
+  const unpushed = statuses.filter((s) => s.ahead > 0).length;
+  if (dirty === 0 && unpushed === 0) return null;
+  const parts: string[] = [];
+  if (dirty > 0) parts.push(`${dirty} repo${dirty === 1 ? '' : 's'} with uncommitted changes`);
+  if (unpushed > 0) parts.push(`${unpushed} repo${unpushed === 1 ? '' : 's'} with unpushed commits`);
+  return parts.join(', ');
+}
+
+/**
+ * Partition stale candidates into prunable vs. protected, given a resolver that
+ * returns each workspace's per-repo git status. The resolver is only invoked
+ * for workspaces that actually have repos, so empty stale workspaces cost no git
+ * calls. Injecting the resolver keeps this function pure and unit-testable.
+ */
+export async function planPrune(
+  staleCandidates: PruneCandidate[],
+  getStatuses: (c: PruneCandidate) => Promise<GitStatus[]>,
+  includeDirty: boolean,
+): Promise<PrunePlan> {
+  const prunable: PruneCandidate[] = [];
+  const protectedList: ProtectedWorkspace[] = [];
+  for (const c of staleCandidates) {
+    const statuses = c.repoDirNames.length > 0 ? await getStatuses(c) : [];
+    const reason = protectionReason(statuses, includeDirty);
+    if (reason) protectedList.push({ candidate: c, reason });
+    else prunable.push(c);
+  }
+  return { prunable, protected: protectedList };
+}