devflow-kit 3.7.0 → 3.9.0

package/dist/cli/commands/memory.js

@@ -8,8 +8,11 @@ import { writeSettingsFileAtomic } from '../../core/fs-atomic.js';
 import { discoverProjectGitRoots } from '../../targets/claude-code/post-install.js';
 import { getGitRoot } from '../../core/git.js';
 import { firstSymbolicLink } from '../../core/linked-path.js';
+import { pooled } from '../../core/pool.js';
 import { getMemoryDir, getPendingTurnsPath, getPendingTurnsProcessingPath, } from '../../core/project-paths.js';
 import { drainQueueFiles, formatRefusedDrain } from '../../core/queue-drain.js';
+import { AREA_PAUSE_NOTICE } from '../../core/area-pause-notice.js';
+import { probeTrackedArea } from '../../core/tracked-areas.js';
 import { HOOKS_DIR_SUFFIX, devflowHookOwner, endsWithAny, ensureHook, hasHook, removeHooks, runHookCommand, runHookSuffix, } from '../../targets/claude-code/hooks.js';
 import { readMachineFeature, writeMachineFeature } from '../../core/feature-switch.js';
 import { loadSettingsModule, narrowedSwitchLabel, personalConfigTrackedWarning } from '../../core/evidence-policy.js';
@@ -40,7 +43,7 @@ const MEMORY_HOOK_CONFIG = {
  *
  * D-EXACT-HOOK-OWNER (hooks.ts): matched as command ENDINGS under any directory —
  * the v1 (≤ v1.2) direct `.sh` scripts, then the retired `run-hook` markers of the
- * prompt-capture, learning, decisions, knowledge-refresh, sidecar and dream
+ * prompt-capture, curation, decisions, knowledge-refresh, sidecar and dream
  * pipelines — never as substrings, so a user's hook that mentions one is theirs.
  */
 const LEGACY_HOOK_SUFFIXES = {
@@ -159,21 +162,42 @@ export function convergeMemoryHooks(settingsJson, enabled, devflowDir) {
     const cleaned = removeMemoryHooks(settingsJson);
     return enabled ? addMemoryHooks(cleaned, devflowDir) : cleaned;
 }
+/**
+ * Why the memory area at `projectRoot` is paused, or null when git tracks nothing in the
+ * memory folder there. The area is paused when git tracks files in the memory folder, or
+ * a `.git` entry stands and git did not answer (`unknown`); a root with no `.git` entry
+ * makes no git call. The root is the checkout's toplevel, where the memory hooks work.
+ */
+async function memoryPauseReason(projectRoot) {
+    const { answer } = await probeTrackedArea(projectRoot, 'memory');
+    return answer === 'untracked' ? null : answer;
+}
 /**
  * Drain a project's pending memory queue (and a claimed batch) so stale turns
  * are not processed when memory is next switched on. Shared by `devflow init
- * --no-memory` and `devflow memory --disable`. Refused, deleting nothing, when
- * `.devflow` or `.devflow/memory` under `projectRoot` is a symbolic link
- * (D-CLI-NO-SYMLINK). ENOENT-tolerant; any other error propagates to the command
- * boundary, like drainLearningQueue.
+ * --no-memory` and `devflow memory --disable`. Deletes nothing, and answers
+ * `skipped`, when git tracks files in the memory folder or a `.git` entry stands and
+ * git does not answer: a folder that git tracks is the repository's content. Refused,
+ * deleting nothing, when `.devflow` or `.devflow/memory` under `projectRoot` is a
+ * symbolic link (D-CLI-NO-SYMLINK). ENOENT-tolerant; any other error propagates to the
+ * command boundary, like drainCurationQueue.
  */
 export async function drainMemoryQueue(projectRoot) {
+    const skipped = await memoryPauseReason(projectRoot);
+    if (skipped !== null)
+        return { drained: false, skipped };
     const memoryDir = getMemoryDir(projectRoot);
     return drainQueueFiles([path.dirname(memoryDir), memoryDir], [
         getPendingTurnsPath(projectRoot),
         getPendingTurnsProcessingPath(projectRoot),
     ]);
 }
+/** The line a caller prints for a memory drain that deleted nothing: the fixed notice of a paused area, or the refusal at a link. */
+export function formatMemoryNotDrained(drain) {
+    if (!('skipped' in drain))
+        return formatRefusedDrain('memory', drain.linkedFolder);
+    return `The memory queue was not drained. ${AREA_PAUSE_NOTICE.memory[drain.skipped]}`;
+}
 /**
  * Returns true if the given project root contains a `.devflow/memory/` directory.
  * Treats unexpected errors (e.g. EACCES) as absent to avoid false positives.
@@ -200,15 +224,23 @@ export async function filterProjectsWithMemory(gitRoots) {
     const checks = await Promise.all(gitRoots.map(async (root) => ({ root, has: await hasMemoryDir(root) })));
     return checks.filter((c) => c.has).map((c) => c.root);
 }
+/** At most this many projects are checked and cleaned at once, so `memory --clear` starts few git processes. */
+export const CLEAN_QUEUE_POOL_LIMIT = 8;
 /**
  * Clean up memory queue files from the given project paths.
  * Skips projects where the background updater lock is held to avoid data loss,
- * and refuses, deleting nothing there, a project whose `.devflow` or
- * `.devflow/memory` is a symbolic link (D-CLI-NO-SYMLINK); `refused` names each
- * such link. Returns the count of projects from which at least one file was removed.
+ * leaves a project whose memory area is paused alone (git tracks files in the memory
+ * folder, or a `.git` entry stands and git did not answer; `paused` names each such
+ * project with the reason), and refuses, deleting nothing there, a project whose
+ * `.devflow` or `.devflow/memory` is a symbolic link (D-CLI-NO-SYMLINK); `refused` names
+ * each such link. At most {@link CLEAN_QUEUE_POOL_LIMIT} projects are handled at once.
+ * Returns the count of projects from which at least one file was removed.
  */
 export async function cleanQueueFiles(projectPaths) {
-    const results = await Promise.all(projectPaths.map(async (project) => {
+    const settled = await pooled(projectPaths, CLEAN_QUEUE_POOL_LIMIT, async (project) => {
+        const reason = await memoryPauseReason(project);
+        if (reason !== null)
+            return { paused: reason, project };
         const memDir = getMemoryDir(project);
         let linkedFolder;
         try {
@@ -234,10 +266,16 @@ export async function cleanQueueFiles(projectPaths) {
             fs.unlink(getPendingTurnsProcessingPath(project)).then(() => true).catch(() => false),
         ]);
         return (q || pr) ? { cleaned: project } : null;
-    }));
+    });
+    const results = settled.map((entry) => {
+        if (entry.status === 'rejected')
+            throw entry.reason;
+        return entry.value;
+    });
     const cleanedProjects = results.flatMap((r) => (r !== null && 'cleaned' in r ? [r.cleaned] : []));
     const refused = results.flatMap((r) => (r !== null && 'refused' in r ? [r.refused] : []));
-    return { cleaned: cleanedProjects.length, projects: cleanedProjects, refused };
+    const paused = results.flatMap((r) => (r !== null && 'paused' in r ? [{ project: r.project, reason: r.paused }] : []));
+    return { cleaned: cleanedProjects.length, projects: cleanedProjects, refused, paused };
 }
 export const memoryCommand = new Command('memory')
     .description('Enable, disable, or clean up working memory (session context preservation)')
@@ -297,10 +335,13 @@ export const memoryCommand = new Command('memory')
             }
             targets = scope === 'local' && currentProject ? [currentProject] : allProjects;
         }
-        const { cleaned, projects: cleanedProjects, refused } = await cleanQueueFiles(targets);
+        const { cleaned, projects: cleanedProjects, refused, paused } = await cleanQueueFiles(targets);
         for (const project of cleanedProjects) {
             p.log.info(color.dim(`Cleaned: ${project}`));
         }
+        for (const { project, reason } of paused) {
+            p.log.warn(`The memory queue of ${project} was not cleaned. ${AREA_PAUSE_NOTICE.memory[reason]}`);
+        }
         for (const linkedFolder of refused) {
             p.log.warn(formatRefusedDrain('memory', linkedFolder));
         }
@@ -340,6 +381,12 @@ export const memoryCommand = new Command('memory')
         const narrowed = enabled ? narrowedSwitchLabel(settingsModule, { dir: process.cwd() }, 'memory') : null;
         if (narrowed !== null)
             p.log.info(`Effective here: ${color.yellow(narrowed)}`);
+        // A paused memory area (git tracks files in the memory folder, or did not answer):
+        // the fixed notice, from the checkout's toplevel, where the memory hooks work. The
+        // current directory stands in outside a git work tree, as it does for the settings line.
+        const paused = await memoryPauseReason((await getGitRoot()) ?? process.cwd());
+        if (paused !== null)
+            p.log.info(AREA_PAUSE_NOTICE.memory[paused]);
         const trackedWarning = personalConfigTrackedWarning(settingsModule, { dir: process.cwd() });
         if (trackedWarning !== null)
             p.log.warn(trackedWarning);
@@ -380,7 +427,7 @@ export const memoryCommand = new Command('memory')
     if (gitRoot) {
         const drain = await drainMemoryQueue(gitRoot);
         if (!drain.drained)
-            p.log.warn(formatRefusedDrain('memory', drain.linkedFolder));
+            p.log.warn(formatMemoryNotDrained(drain));
     }
     p.log.success('Working memory disabled in every project');
 });

package/dist/cli/commands/prompt-io.js

@@ -9,8 +9,45 @@
  * D-PROMPT-IO: WizardPromptIO is the base DI seam for all two-action wizard
  * steps (note + boolean select). Modules that add a third prompt extend this
  * interface with an intersection type (e.g. CompliancePromptIO).
+ *
+ * The shared wizard gate predicate (shouldRunPromptedWizardStep) lives here too,
+ * beside the seam every prompted step already imports.
  */
 import * as p from '@clack/prompts';
+// ── Shared gate predicate ─────────────────────────────────────────────────────
+/**
+ * Determines whether a wizard step that runs on both wizard paths should run for a
+ * given init invocation.
+ *
+ * Gate table (key on modePromptShown, never on the mode name):
+ *
+ *   --recommended flag / !isTTY fallback             → no (promptless contract preserved)
+ *   Interactive mode-prompt → Recommended            → yes (modePromptShown=true)
+ *   --advanced flag / re-init (banner path)          → yes (mode='advanced', isTTY=true)
+ *   Interactive mode-prompt → Advanced               → yes (modePromptShown=true)
+ *   Any path with the step's CLI flag                → no (hasCliOverride wins)
+ *
+ * A step that wires only the Recommended path is dead on every re-init, because re-init
+ * is Advanced-only by construction, so each step calls this predicate from both paths.
+ * The gate-level step delegates here. The attribution step is Advanced-only by design
+ * and does not use this table.
+ *
+ * Pure predicate — no side effects, fully testable without a TTY.
+ */
+export function shouldRunPromptedWizardStep(input) {
+    if (input.hasCliOverride)
+        return false;
+    if (!input.isTTY)
+        return false;
+    // Advanced path: non-TTY has already exit-1'd, so isTTY=true here → always run.
+    // Covers: --advanced flag, re-init banner path, interactive-prompt → advanced.
+    if (input.mode === 'advanced')
+        return true;
+    // Recommended path: only run when the Setup-mode p.select actually ran
+    // (user made an active choice). --recommended flag and !isTTY fallback never set
+    // modePromptShown=true, preserving their promptless contracts.
+    return input.modePromptShown;
+}
 // ── Shared clack adapters ─────────────────────────────────────────────────────
 /** Real clack adapter for the note prompt. */
 export function clackNote(message, title) {

package/dist/cli/commands/uninstall.js

@@ -31,6 +31,9 @@ import { stripFlags } from '../../core/flags.js';
 import { stripDevflowTeammateModeFromJson } from '../../core/teammate-mode-cleanup.js';
 import { getPackageRoot, isContainedIn } from '../../core/paths.js';
 import { firstSymbolicLink } from '../../core/linked-path.js';
+import { MANIFEST_LOCK_NAME, MANIFEST_LOCK_STALE_MARK } from '../../core/manifest-lock.js';
+import { CURATION_DIR_NAME, CURATION_TUNING_FILE_NAME, LEGACY_NAMES, MOVE_JOURNAL_SUFFIX, MOVE_LOCK_PREFIX, MOVE_LOCK_SUFFIX, getMemoryDir } from '../../core/project-paths.js';
+import { probeTrackedArea } from '../../core/tracked-areas.js';
 import { restampInstalledCommands } from '../../targets/claude-code/language-stamp.js';
 import { installCommandsAndAgents } from '../../targets/claude-code/installer.js';
 /**
@@ -283,20 +286,66 @@ const TRACKED_ENTRIES = DEVFLOW_TRACKED_PATHS.map((tracked) => ({
     name: tracked.replace(/\/$/, ''),
     isDir: tracked.endsWith('/'),
 }));
+/** The memory folder's name under `.devflow/`, by the name the path helper gives it. */
+const MEMORY_FOLDER_NAME = path.basename(getMemoryDir(path.sep));
+/**
+ * The data area an entry under `.devflow/` belongs to, or null. The curation area holds the
+ * curation folder, the old ledger folder and the backup folders; the memory area holds the
+ * memory folder. Decided by name alone, whatever the kind of entry, and without regard to
+ * ASCII letter case, as the tracked-areas check matches them.
+ */
+function projectDataAreaOf(name) {
+    const lower = name.toLowerCase();
+    if (lower === CURATION_DIR_NAME || lower === LEGACY_NAMES.folder || lower.startsWith(LEGACY_NAMES.backupPrefix))
+        return 'curation';
+    if (lower === MEMORY_FOLDER_NAME)
+        return 'memory';
+    return null;
+}
 /**
  * Split the entries under a repository's `.devflow/` into what a confirmed cleanup
  * removes and what it keeps (D-UNINSTALL-CARVE-OUT). An entry is kept only when both
  * its name and its kind match a tracked path, so a stray FILE named `features` is
- * not mistaken for the tracked directory. PURE — both lists sorted by name.
+ * not mistaken for the tracked directory. An entry of a paused data area (`pausedAreas`:
+ * git tracks files in the area's folders, or did not answer) is kept too, in
+ * `keepPaused`. PURE — all three lists sorted by name.
  */
-export function partitionProjectData(entries) {
+export function partitionProjectData(entries, pausedAreas = new Set()) {
     const isTracked = (entry) => TRACKED_ENTRIES.some((t) => t.name === entry.name && t.isDir === entry.isDir);
+    const isPaused = (entry) => {
+        const area = projectDataAreaOf(entry.name);
+        return area !== null && pausedAreas.has(area);
+    };
     const byName = (a, b) => a.name.localeCompare(b.name);
     return {
-        remove: entries.filter((e) => !isTracked(e)).sort(byName),
+        remove: entries.filter((e) => !isTracked(e) && !isPaused(e)).sort(byName),
         keep: entries.filter(isTracked).sort(byName),
+        keepPaused: entries.filter((e) => !isTracked(e) && isPaused(e)).sort(byName),
     };
 }
+/** The check's own answer, from the package's own copy of it. */
+const probeProjectDataArea = async (root, area) => (await probeTrackedArea(root, area)).answer;
+/**
+ * The data areas that hold an entry in `entries` and are paused at `gitRoot`: git tracks
+ * files in the area's folders, or a `.git` entry stands and git did not answer. An area
+ * with no entry is not asked, and a root with no `.git` entry makes no git call. A probe
+ * that fails to answer counts as `unknown`, so the area is kept.
+ */
+async function pausedProjectDataAreas(gitRoot, entries, probe) {
+    const present = new Set(entries.flatMap((entry) => {
+        const area = projectDataAreaOf(entry.name);
+        return area === null ? [] : [area];
+    }));
+    const answers = await Promise.all([...present].map(async (area) => {
+        try {
+            return [area, await probe(gitRoot, area)];
+        }
+        catch {
+            return [area, 'unknown'];
+        }
+    }));
+    return new Set(answers.flatMap(([area, answer]) => (answer === 'untracked' ? [] : [area])));
+}
 /**
  * Resolve the project-data step's target: `<gitRoot>/.devflow`, partitioned.
  *
@@ -310,6 +359,12 @@ export function partitionProjectData(entries) {
  * A `.devflow` that is a symbolic link to anywhere else is skipped too, and never
  * followed: its target is a directory devflow cannot prove it wrote, so a
  * confirmed cleanup must not empty it — nor unlink a link the user made.
+ *
+ * A folder that git tracks is the repository's content, not devflow's data. The
+ * curation area (the curation folder, the old ledger folder and the backup folders)
+ * and the memory area (the memory folder) are each asked of the tracked-areas check at
+ * the git root, when an entry of the area stands. An area that git tracks files in, or
+ * that git did not answer for, moves its entries from the removal list to `keepPaused`.
  */
 export async function resolveProjectDataPlan(opts) {
     if (opts.gitRoot === null)
@@ -333,8 +388,10 @@ export async function resolveProjectDataPlan(opts) {
     catch {
         return { kind: 'skip', reason: 'absent' };
     }
-    const { remove, keep } = partitionProjectData(dirents.map((d) => ({ name: d.name, isDir: d.isDirectory() })));
-    return { kind: 'plan', plan: { dir, remove, keep } };
+    const entries = dirents.map((d) => ({ name: d.name, isDir: d.isDirectory() }));
+    const paused = await pausedProjectDataAreas(opts.gitRoot, entries, opts.probe ?? probeProjectDataArea);
+    const { remove, keep, keepPaused } = partitionProjectData(entries, paused);
+    return { kind: 'plan', plan: { dir, remove, keep, keepPaused } };
 }
 /**
  * The line that tells the user why the project-data step was skipped, or null
@@ -364,15 +421,21 @@ function entryLabel(entry) {
 function entryList(entries) {
     return entries.length === 0 ? '(none)' : entries.map(entryLabel).join(', ');
 }
+/** Why the entries of a data area stay, said beside a list of them. */
+const KEEP_PAUSED_REASON = 'git tracks them, or git did not answer';
+/** Why one entry of a data area stays, said beside it. */
+const KEEP_PAUSED_REASON_ONE = 'git tracks it, or git did not answer';
 /**
  * The lines shown before the project-data confirm: what is removed and what is
- * kept. PURE.
+ * kept, and, only where there are such entries, what is kept because git tracks them
+ * or did not answer. PURE.
  */
 export function formatProjectDataPlan(plan) {
     return [
         `Project data in ${plan.dir}/:`,
         `  Remove: ${entryList(plan.remove)}`,
         `  Keep (shared via git): ${entryList(plan.keep)}`,
+        ...(plan.keepPaused.length === 0 ? [] : [`  Keep (${KEEP_PAUSED_REASON}): ${entryList(plan.keepPaused)}`]),
     ];
 }
 /**
@@ -489,8 +552,10 @@ export function userContentPaths(devflowDir) {
             const name = `${TRACKER_LEGACY_CONVENTIONS_FILE}.${id}.bak`;
             return { relPath: name, label: `${name} (previous issue tracker conventions)` };
         }),
-        // learning.json — global curate agent tuning config
-        { relPath: 'learning.json', label: 'learning.json' },
+        // The global curate agent tuning config, under both its names: the new name on an
+        // upgraded machine, and the old name, which a downgraded machine can still hold.
+        { relPath: CURATION_TUNING_FILE_NAME, label: CURATION_TUNING_FILE_NAME },
+        { relPath: LEGACY_NAMES.tuningFile, label: LEGACY_NAMES.tuningFile },
         // hud.json — user HUD enable/disable preference and display config
         { relPath: 'hud.json', label: 'hud.json (HUD configuration)' },
     ];
@@ -527,6 +592,54 @@ export async function enumerateUserDevFlowContent(devflowDir) {
     }
     return items;
 }
+/** `text` as a regular-expression source, every character literal. */
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** The name of a move lock or journal: the shared prefix, a 16-digit lowercase hex key, then `suffix`. */
+function moveFileShape(suffix) {
+    return new RegExp(`^${escapeRegExp(MOVE_LOCK_PREFIX)}[0-9a-f]{16}${escapeRegExp(suffix)}$`);
+}
+/**
+ * The curation move's lock, one directory per ledger root, taken directly in the machine
+ * directory: `.curation-move-<16 lowercase hex>.lock`. The store builds the name from a
+ * hash of the real ledger root, so the names exist only on disk. The prefix and the
+ * suffix are the ones the path helpers hold (project-paths.ts).
+ */
+const CURATION_MOVE_LOCK_SHAPE = moveFileShape(MOVE_LOCK_SUFFIX);
+/**
+ * The curation move's journal, one regular file per ledger root, beside the lock:
+ * `.curation-move-<16 lowercase hex>.journal`, with the same key as the lock. It exists
+ * only while a set move is unfinished, and a crash leaves it behind. A file named
+ * `.curation-move.journal` inside a project's old ledger folder is no journal of the
+ * move and is not matched here.
+ */
+const CURATION_MOVE_JOURNAL_SHAPE = moveFileShape(MOVE_JOURNAL_SUFFIX);
+/**
+ * The manifest lock, a directory in the machine directory (manifest-lock.ts), and the
+ * directory a stale break moves aside: `manifest.json.lock` and
+ * `manifest.json.lock.stale-<digits>-<12 lowercase hex>`. A holder that dies in its
+ * critical section leaves the first, a break whose removal failed leaves the second.
+ */
+const MANIFEST_LOCK_SHAPE = new RegExp(`^${escapeRegExp(MANIFEST_LOCK_NAME)}(?:${escapeRegExp(MANIFEST_LOCK_STALE_MARK)}[0-9]+-[0-9a-f]{12})?$`);
+/** Whether `child` of `devflowDir` is a real directory (a link is not followed). */
+async function isRealDirectory(devflowDir, child) {
+    try {
+        return (await fs.lstat(path.join(devflowDir, child))).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether `child` of `devflowDir` is a regular file (a link is not followed). */
+async function isRegularFile(devflowDir, child) {
+    try {
+        return (await fs.lstat(path.join(devflowDir, child))).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Expand `installArtifactPaths` against real disk.
  *
@@ -553,8 +666,15 @@ export async function resolveInstallArtifactPaths(devflowDir) {
             }
         }
         for (const child of children) {
-            if (child.startsWith(entry.relPath))
-                resolved.push({ relPath: child, isDir: entry.isDir });
+            if (!child.startsWith(entry.relPath))
+                continue;
+            if (entry.shape !== undefined && !entry.shape.test(child))
+                continue;
+            if (entry.realDirOnly === true && !(await isRealDirectory(devflowDir, child)))
+                continue;
+            if (entry.realFileOnly === true && !(await isRegularFile(devflowDir, child)))
+                continue;
+            resolved.push({ relPath: child, isDir: entry.isDir });
         }
     }
     return resolved;
@@ -621,6 +741,18 @@ export function installArtifactPaths(devflowDir) {
         // A prefix, because the names exist only on disk. Content is a scrubbed copy
         // that was never placed, so it is machine state like the three above.
         { relPath: TRACKER_STAGED_PREFIX, isPrefix: true },
+        // The curation move's per-root lock directory. A crash between taking the lock and
+        // releasing it leaves one behind, and its name carries a hash that exists only on disk.
+        // Only a real directory of exactly that shape goes; the move's skip markers sit under
+        // logs/ and go with it.
+        { relPath: MOVE_LOCK_PREFIX, isPrefix: true, isDir: true, shape: CURATION_MOVE_LOCK_SHAPE, realDirOnly: true },
+        // The move's journal beside it. A crash between two renames of the ledger set leaves
+        // one behind. Only a regular file of exactly that shape goes.
+        { relPath: MOVE_LOCK_PREFIX, isPrefix: true, shape: CURATION_MOVE_JOURNAL_SHAPE, realFileOnly: true },
+        // The manifest lock, and the directory a stale break moved aside. A crash inside the
+        // critical section leaves the first; a failed cleanup leaves the second, whose name
+        // carries a pid and a random suffix. Only a real directory of exactly that shape goes.
+        { relPath: MANIFEST_LOCK_NAME, isPrefix: true, isDir: true, shape: MANIFEST_LOCK_SHAPE, realDirOnly: true },
         // per-project hook logs (logs/{project-slug}/) AND global logs — remove the
         // whole logs/ tree; covers proxy.log, debug logs, and any project-slug dirs.
         { relPath: 'logs', isDir: true },
@@ -644,7 +776,8 @@ export function installArtifactPaths(devflowDir) {
  * so an entry here is deleted even when the user answers "no" to the full wipe.
  * User-authored state (everything in `userContentPaths`: skill/rule shadows,
  * preference-profile.md, the tracker conventions with the legacy tracker.md and
- * its backups, learning.json, hud.json) is removed only by the confirmed full-dir rm.
+ * its backups, the global tuning file under both names, hud.json) is removed only by
+ * the confirmed full-dir rm.
  * agent-models.json is an INSTALL ARTIFACT (stale per-agent overrides silently
  * re-apply to renamed/deleted agents on reinstall — AC-P1-F4) and therefore
  * belongs in this list, not in enumerateUserDevFlowContent.
@@ -874,6 +1007,9 @@ export async function runDryRunPhase(opts) {
             for (const entry of projectData.plan.remove) {
                 extras.push(`${path.join(projectData.plan.dir, entryLabel(entry))} (if confirmed)`);
             }
+            for (const entry of projectData.plan.keepPaused) {
+                extras.push(`${path.join(projectData.plan.dir, entryLabel(entry))} (kept: ${KEEP_PAUSED_REASON_ONE})`);
+            }
         }
         else {
             const skipped = formatProjectDataSkip(projectData.reason, projectRoot);
@@ -953,7 +1089,7 @@ export async function refreshRetainedCommandsAndAgents(opts) {
             plugins: retained,
             agentsMap: buildAssetMaps(retained).agentsMap,
             claudeDir,
-            learning: manifest.features.learning,
+            curation: manifest.features.curation,
             trackerServers: effectiveTrackerServers(manifest.features.tracker),
             warn: (msg) => p.log.warn(msg),
         });
@@ -1073,7 +1209,7 @@ export async function runSelectivePhaseForScope(opts) {
  * FULL PHASE (per scope): revert agent model overrides, remove all Devflow
  * assets from the scope, then perform scope-appropriate devflowDir cleanup.
  *
- * Local scope: remove only install artifacts — project data (memory, learning,
+ * Local scope: remove only install artifacts — project data (memory, curation,
  *   docs, features) is always preserved under the git root.
  * User scope: interactive TTY with user-authored content → confirm before wiping
  *   ~/.devflow/; non-interactive or no user content → artifacts-only.
@@ -1115,11 +1251,11 @@ export async function runFullPhaseForScope(opts) {
     await removeAllDevFlow(claudeDir, devflowScriptsDir, verbose, mayChange);
     if (scope === 'local') {
         // Local scope: devflowDir is gitRoot/.devflow/ which holds project data
-        // (memory, learning, features, docs, config.json). Never remove those —
+        // (memory, curation, features, docs, config.json). Never remove those —
         // only remove install artifacts: scripts/ (done above) + manifest.json and
         // the other Devflow-generated artifacts (see removeDevFlowInstallArtifacts).
         await removeDevFlowInstallArtifacts(devflowDir, verbose, mayChange);
-        p.log.info('Local project data (memory, learning, features, docs) preserved');
+        p.log.info('Local project data (memory, curation, features, docs) preserved');
     }
     else {
         // User scope (devflowDir = ~/.devflow/): offer full cleanup behind a confirm gate
@@ -1179,7 +1315,9 @@ export async function runFullPhaseForScope(opts) {
 async function runProjectDataStep(plan, gates) {
     const shown = `${plan.dir}/`;
     if (plan.remove.length === 0) {
-        p.log.info(`${shown} preserved (holds only files shared via git)`);
+        p.log.info(plan.keepPaused.length === 0
+            ? `${shown} preserved (holds only files shared via git)`
+            : `${shown} preserved (holds only files shared via git, and ${entryList(plan.keepPaused)}, which stay: ${KEEP_PAUSED_REASON})`);
         return;
     }
     if (gates.keepDocs) {
@@ -1215,7 +1353,7 @@ async function runProjectDataStep(plan, gates) {
             failed.push(`${entryLabel(entry)} (${err.code ?? err.message})`);
         }
     }
-    if (plan.keep.length === 0 && failed.length === 0) {
+    if (plan.keep.length === 0 && plan.keepPaused.length === 0 && failed.length === 0) {
         // Nothing tracked was there: drop the now-empty directory. rmdir refuses a
         // directory something wrote into meanwhile, which is then left in place.
         await fs.rmdir(plan.dir).catch(() => undefined);
@@ -1226,6 +1364,8 @@ async function runProjectDataStep(plan, gates) {
         p.log.warn(`Could not remove from ${shown}: ${failed.join(', ')}`);
     if (plan.keep.length > 0)
         p.log.info(`Kept: ${entryList(plan.keep)}`);
+    if (plan.keepPaused.length > 0)
+        p.log.info(`Kept: ${entryList(plan.keepPaused)} (${KEEP_PAUSED_REASON})`);
 }
 /**
  * CLEANUP PHASE: post-loop extras run only on full uninstall.

package/dist/cli.js

@@ -11,7 +11,7 @@ import { skillsCommand } from './cli/commands/skills.js';
 import { hudCommand } from './cli/commands/hud.js';
 import { flagsCommand } from './cli/commands/flags.js';
 import { knowledgeCommand } from './cli/commands/knowledge/index.js';
-import { learningCommand } from './cli/commands/learning.js';
+import { curationCommand } from './cli/commands/curation.js';
 import { rulesCommand } from './cli/commands/rules.js';
 import { debugCommand } from './cli/commands/debug.js';
 import { securityCommand } from './cli/commands/security.js';
@@ -42,7 +42,7 @@ program.addCommand(skillsCommand);
 program.addCommand(hudCommand);
 program.addCommand(flagsCommand);
 program.addCommand(knowledgeCommand);
-program.addCommand(learningCommand);
+program.addCommand(curationCommand);
 program.addCommand(rulesCommand);
 program.addCommand(debugCommand);
 program.addCommand(securityCommand);