devflow-kit 3.6.0 → 3.8.0

package/dist/cli/commands/{learning.js → curation.js}

@@ -1,26 +1,31 @@
 import { Command } from 'commander';
 import { promises as fs } from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import * as p from '@clack/prompts';
 import color from 'picocolors';
-import { getLearningDir, getCurateTuningConfigPath, } from '../../core/project-paths.js';
+import { CURATION_TUNING_FILE_NAME, LEGACY_NAMES, getCurationDir, getGlobalCurateTuningConfigPath, } from '../../core/project-paths.js';
 import { loadShippedAgentDefaults } from '../../core/agent-models.js';
 import { readMachineFeature, writeMachineFeature } from '../../core/feature-switch.js';
 import { loadSettingsModule, narrowedSwitchLabel, personalConfigTrackedWarning } from '../../core/evidence-policy.js';
 import { getClaudeDirectory, getDevFlowDirectory } from '../../targets/claude-code/claude-paths.js';
-import { applyLearningToggle, describeLearningConverge, readRunningVersion, } from '../../targets/claude-code/learning-install.js';
+import { applyCurationToggle, describeCurationConverge, installedScriptsSkew, readRunningVersion, } from '../../targets/claude-code/curation-install.js';
 import { getLedgerRoot } from '../../core/ledger-root.js';
-import { drainLearningQueue } from '../../core/learning-queue-cleanup.js';
+import { drainCurationQueue, drainDisabledCurationQueue, formatCurationNotDrained } from '../../core/curation-queue-cleanup.js';
 import { firstSymbolicLink } from '../../core/linked-path.js';
-import { formatRefusedDrain } from '../../core/queue-drain.js';
-import { formatLearningStoreUnavailable, loadLearningStore, } from '../../core/learning-store.js';
+import { describeMoveText, describeOutcome } from './curation-move-step.js';
+import { describeMoveNotice, gatherMoveNotice } from '../../core/curation-move-notice.js';
+import { isMoveSkipReason } from '../../core/curation-move-skip.js';
+import { runSharedMove } from './curation-move-io.js';
+import { formatCurationStoreUnavailable, loadCurationStore, } from '../../core/curation-store.js';
+import { loadCurationMove } from '../../core/curation-move.js';
 // ---------------------------------------------------------------------------
 // Shared helpers
 // ---------------------------------------------------------------------------
-/** What the read and restore commands say about a project with no `.devflow/learning/`. */
-const NO_LEARNING_DATA = 'No learning data in this project yet.';
+/** What the read and restore commands say about a project with no `.devflow/curation/`. */
+const NO_CURATION_DATA = 'No curation data in this project yet.';
 /**
- * How long a writer here (--restore, --clear, --reset) waits for the learning lock
+ * How long a writer here (--restore, --clear, --reset) waits for the curation lock
  * before it refuses as busy. An op holds the lock for milliseconds, so a longer
  * wait means a stuck holder, and the store's own 30 s wait would leave the command
  * looking hung.
@@ -58,22 +63,22 @@ function counted(count, noun) {
     return `${count} ${noun}${count === 1 ? '' : 's'}`;
 }
 /**
- * The learning store (D-LEARNING-STORE-SEAM), or null after reporting why it
+ * The curation store (D-LEARNING-STORE-SEAM), or null after reporting why it
  * cannot be used and setting exit code 1.
  */
 function requireStore() {
-    const loaded = loadLearningStore();
+    const loaded = loadCurationStore();
     if (loaded.ok)
         return loaded.value;
-    p.log.error(`Learning: ${formatLearningStoreUnavailable(loaded.error)}`);
+    p.log.error(`Curation: ${formatCurationStoreUnavailable(loaded.error)}`);
     process.exitCode = 1;
     return null;
 }
 /** What a writer says when the store refused; `undone` completes "Nothing was …". */
 function storeRefusal(error, undone) {
     switch (error.kind) {
-        case 'no-learning-dir': return NO_LEARNING_DATA;
-        case 'busy': return `The learning store is busy: another run holds its lock. Nothing was ${undone}; try again in a moment.`;
+        case 'no-curation-dir': return NO_CURATION_DATA;
+        case 'busy': return `The curation store is busy: another run holds its lock. Nothing was ${undone}; try again in a moment.`;
         default: return error.message;
     }
 }
@@ -104,20 +109,91 @@ async function isDirectory(dir) {
         throw err;
     }
 }
+/**
+ * Whether the old ledger folder name is present under `root`'s `.devflow`: a folder, a
+ * file or a link, dangling or not. The cheap state check that keeps the store unloaded
+ * where there is nothing to move. A probe that fails for another reason reads as
+ * present, so the move itself reports the problem.
+ */
+async function oldLedgerFolderPresent(root) {
+    try {
+        await fs.lstat(path.join(root, '.devflow', LEGACY_NAMES.folder));
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        return code !== 'ENOENT' && code !== 'ENOTDIR';
+    }
+}
+/** The lines a move that did not complete says: its own, or the store's reason when it could not load. */
+function moveProblemLines(outcome) {
+    return outcome.kind === 'unavailable'
+        ? [`The curation data was not moved: ${describeMoveText(outcome.message)}.`]
+        : describeOutcome(outcome);
+}
+/** The move notice of a read-only command, or null when there is none. The old ledger is never opened. */
+async function moveReadNotice(ledgerRoot) {
+    const newFolderPresent = await isDirectory(getCurationDir(ledgerRoot)).catch(() => false);
+    const notice = gatherMoveNotice(ledgerRoot, os.homedir());
+    if (notice === null)
+        return null;
+    if (!newFolderPresent)
+        return { kind: 'instead', line: describeMoveNotice(notice) };
+    return isMoveSkipReason(notice) ? { kind: 'beside', line: describeMoveNotice(notice) } : null;
+}
+/**
+ * The gate every writing subcommand passes first (--restore, --clear, --reset and the
+ * project scope of --configure). Installed scripts of another version read and create
+ * another ledger folder, so they refuse with the skew line. Then, where the old folder
+ * is present, the shared move runs with no wait: a busy lock prints a retry message,
+ * a queue claim that holds the move prints its own message, a refused or failed move
+ * prints its reason, and a skipped move (git tracks files in a data folder, or git did
+ * not answer) prints the fixed notice; in each case nothing is written.
+ * `undone` completes "Nothing was …". Answers true when the caller may write.
+ */
+async function prepareToWrite(ledgerRoot, undone) {
+    const skew = await installedScriptsSkew(getDevFlowDirectory());
+    if (skew !== null) {
+        p.log.error(skew);
+        process.exitCode = 1;
+        return false;
+    }
+    if (!(await oldLedgerFolderPresent(ledgerRoot)))
+        return true;
+    const moved = await runSharedMove(ledgerRoot);
+    if (moved.kind === 'moved' || moved.kind === 'unchanged')
+        return true;
+    p.log.error(moved.kind === 'busy'
+        ? (moved.reason === 'claim' ? claimHoldsMoveLine(undone) : movingLine(undone))
+        : describeMoveText(`${moveProblemLines(moved).join(' ')} Nothing was ${undone}.`));
+    process.exitCode = 1;
+    return false;
+}
+/** The line a writer prints when a lock holds the move of the old folder. `undone` completes "Nothing was …". */
+function movingLine(undone) {
+    return `Another run is moving this project's curation data. Nothing was ${undone}; try again in a moment.`;
+}
+/**
+ * The line a writer prints when a Curate run holds the queue claim, which holds the move:
+ * no other run moves anything, and the claim lasts up to 15 minutes. `undone` completes "Nothing was …".
+ */
+function claimHoldsMoveLine(undone) {
+    return `A Curate run holds this project's curation queue, and the move waits for it. Nothing was ${undone}; try again after the run finishes (up to 15 minutes).`;
+}
 // ---------------------------------------------------------------------------
 // Sub-command handlers
 // ---------------------------------------------------------------------------
 function printUsage() {
-    p.intro(color.bgCyan(color.black(' Learning ')));
-    p.note(`${color.cyan('devflow learning --enable')}        Enable learning in every project (a repository can opt out)\n` +
-        `${color.cyan('devflow learning --disable')}       Disable learning in every project (drains this project's queue)\n` +
-        `${color.cyan('devflow learning --status')}        Show learning status and entry counts\n` +
-        `${color.cyan('devflow learning --list')}          List entries, inactive entries and observations\n` +
-        `${color.cyan('devflow learning --show <id>')}     Print one entry or observation as JSON\n` +
-        `${color.cyan('devflow learning --restore <id>')}  Make an inactive entry active again\n` +
-        `${color.cyan('devflow learning --configure')}     Configuration wizard\n` +
-        `${color.cyan('devflow learning --clear')}         Drop the observations no entry uses, and drain the queue\n` +
-        `${color.cyan('devflow learning --reset')}         Remove all learning state files`, 'Usage');
+    p.intro(color.bgCyan(color.black(' Curation ')));
+    p.note(`${color.cyan('devflow curation --enable')}        Enable curation in every project (a repository can opt out)\n` +
+        `${color.cyan('devflow curation --disable')}       Disable curation in every project (drains this project's queue)\n` +
+        `${color.cyan('devflow curation --status')}        Show curation status and entry counts\n` +
+        `${color.cyan('devflow curation --list')}          List entries, inactive entries and observations\n` +
+        `${color.cyan('devflow curation --show <id>')}     Print one entry or observation as JSON\n` +
+        `${color.cyan('devflow curation --restore <id>')}  Make an inactive entry active again\n` +
+        `${color.cyan('devflow curation --configure')}     Configuration wizard\n` +
+        `${color.cyan('devflow curation --clear')}         Drop the observations no entry uses, and drain the queue\n` +
+        `${color.cyan('devflow curation --reset')}         Remove all curation state files`, 'Usage');
     p.outro(color.dim('Detects architectural decisions and known pitfalls from your sessions'));
 }
 /**
@@ -157,18 +233,50 @@ function entryCountLines(listing, logRowCount, inactiveStatuses) {
         `Observations: ${logRowCount} in the log, ${listing.observations.length} not yet promoted`,
     ];
 }
+/**
+ * The `--status` backup lines: one per backup folder a move left under `.devflow`, with
+ * the rows its unswept queue files still hold, one more line for the folders past
+ * the listing limit (up to the 500th, which are read), and one for those past the 500th
+ * (not read, so their rows are not counted). A backup is inert, so the count tells the
+ * user when deleting it loses nothing. A count that fails is a warning, not an error.
+ */
+function backupLines(ledgerRoot) {
+    const mover = loadCurationMove();
+    if (!mover.ok)
+        return { lines: [], warning: `Backup rows were not counted: ${formatCurationStoreUnavailable(mover.error)}` };
+    const rows = mover.value.backupPendingRows(ledgerRoot);
+    if (!rows.ok)
+        return { lines: [], warning: `Backup rows were not counted: ${describeMoveText(rows.error.message)}` };
+    const lines = rows.value.backups.map(({ name, pendingRows }) => `Backup: ${describeMoveText(path.join(ledgerRoot, '.devflow', name))}: ${counted(pendingRows, 'pending row')} in the backup`);
+    const beyond = rows.value.beyondLimit;
+    if (beyond.backups > 0) {
+        const one = beyond.backups === 1;
+        lines.push(`Backup: ${counted(beyond.backups, 'more backup folder')} ${one ? 'is' : 'are'} not listed above: `
+            + `${counted(beyond.pendingRows, 'pending row')} in ${one ? 'it' : 'them'}`);
+    }
+    if (beyond.unread > 0) {
+        const one = beyond.unread === 1;
+        lines.push(`Backup: ${counted(beyond.unread, 'more backup folder')} past the first 500 ${one ? 'is' : 'are'} not read: `
+            + `${one ? 'its' : 'their'} pending rows are not counted`);
+    }
+    return { lines, warning: null };
+}
 /**
  * `--status`: the machine switch, then the counts the store reads. Reads only:
- * malformed lines are counted, never quarantined, and no scope is checked.
+ * malformed lines are counted, never quarantined, and no scope is checked. A project
+ * whose ledger still sits in the old folder gets the HUD's pointer (or refused line, or
+ * the notice of a skipped move) in place of the counts; a project with both folders and
+ * a skipped move gets the notice with the counts; a project with backup folders gets one
+ * line for each.
  */
 async function handleStatus() {
     // D-FEATURES-NARROW-ONLY: the machine switch is the manifest's and reads the
     // same from every directory; a repository layer can only narrow it, and adds a
     // line only when it does. The entry counts are per-project.
-    const enabled = await readMachineFeature(getDevFlowDirectory(), 'learning');
+    const enabled = await readMachineFeature(getDevFlowDirectory(), 'curation');
     const settingsModule = loadSettingsModule();
-    const narrowed = enabled ? narrowedSwitchLabel(settingsModule, { dir: process.cwd() }, 'learning') : null;
-    const stateLine = `Learning: ${enabled ? 'enabled' : 'disabled'}`
+    const narrowed = enabled ? narrowedSwitchLabel(settingsModule, { dir: process.cwd() }, 'curation') : null;
+    const stateLine = `Curation: ${enabled ? 'enabled' : 'disabled'}`
         + (narrowed === null ? '' : `\nEffective here: ${narrowed}`);
     const trackedWarning = personalConfigTrackedWarning(settingsModule, { dir: process.cwd() });
     if (trackedWarning !== null)
@@ -178,15 +286,24 @@ async function handleStatus() {
         p.log.info(`${stateLine}\nEntries: not in a git project`);
         return;
     }
-    const loaded = loadLearningStore();
+    const notice = await moveReadNotice(ledgerRoot);
+    if (notice?.kind === 'instead') {
+        p.log.info(`${stateLine}\n${notice.line}`);
+        return;
+    }
+    const head = notice === null ? stateLine : `${stateLine}\n${notice.line}`;
+    const loaded = loadCurationStore();
     if (!loaded.ok) {
-        p.log.info(`${stateLine}\nEntries: unavailable (${formatLearningStoreUnavailable(loaded.error)})`);
+        p.log.info(`${head}\nEntries: unavailable (${formatCurationStoreUnavailable(loaded.error)})`);
         return;
     }
     const store = loaded.value;
-    const { ledgerRows, logRows, rejected } = store.readLearningState(ledgerRoot);
+    const { ledgerRows, logRows, rejected } = store.readCurationState(ledgerRoot);
     const listing = store.buildListing(ledgerRows, logRows, { rejected });
-    p.log.info([stateLine, ...entryCountLines(listing, logRows.length, store.INACTIVE_STATUSES)].join('\n'));
+    const backups = backupLines(ledgerRoot);
+    p.log.info([head, ...entryCountLines(listing, logRows.length, store.INACTIVE_STATUSES), ...backups.lines].join('\n'));
+    if (backups.warning !== null)
+        p.log.warn(backups.warning);
     const { ledger, log } = listing.malformed;
     if (ledger + log > 0) {
         p.log.warn(`Malformed lines skipped: ${ledger} in the ledger, ${log} in the log. ` +
@@ -195,17 +312,25 @@ async function handleStatus() {
 }
 /**
  * `--list`: the store's listing — the same text json-helper's `list` op prints —
- * on stdout. Read-only. Outside a git project it reads the current directory.
+ * on stdout. Read-only. Outside a git project it reads the current directory. Where
+ * the ledger still sits in the old folder it prints the pointer, the refused line or the
+ * notice of a skipped move in place of the listing; with both folders and a skipped move
+ * it prints the notice before the listing.
  */
 async function handleList() {
     const root = (await getLedgerRoot()) ?? process.cwd();
+    const notice = await moveReadNotice(root);
+    if (notice !== null)
+        p.log.info(notice.line);
+    if (notice?.kind === 'instead')
+        return;
     const store = requireStore();
     if (!store)
         return;
     const listed = store.readListing(root);
     if (!listed.ok) {
-        if (listed.error.kind === 'no-learning-dir') {
-            p.log.info(NO_LEARNING_DATA);
+        if (listed.error.kind === 'no-curation-dir') {
+            p.log.info(NO_CURATION_DATA);
             return;
         }
         p.log.error(listed.error.message);
@@ -217,16 +342,27 @@ async function handleList() {
 /**
  * `--show <id>`: one entry, by its anchor or its observation id, as the JSON
  * json-helper's `show` op prints, made terminal-safe. Read-only. Outside a git
- * project it reads the current directory.
+ * project it reads the current directory. Where the ledger still sits in the old
+ * folder it prints the pointer, the refused line or the notice of a skipped move as the
+ * refusal; with both folders and a skipped move it prints the notice on stderr and goes on.
  */
 async function handleShow(key) {
     const root = (await getLedgerRoot()) ?? process.cwd();
+    const notice = await moveReadNotice(root);
+    if (notice?.kind === 'instead') {
+        p.log.error(notice.line);
+        process.exitCode = 1;
+        return;
+    }
+    // The JSON goes to stdout, so the notice of a skip goes to stderr.
+    if (notice !== null)
+        process.stderr.write(`${notice.line}\n`);
     const store = requireStore();
     if (!store)
         return;
     const shown = store.showByKey(root, key);
     if (!shown.ok) {
-        p.log.error(shown.error.kind === 'no-learning-dir' ? NO_LEARNING_DATA : shown.error.message);
+        p.log.error(shown.error.kind === 'no-curation-dir' ? NO_CURATION_DATA : shown.error.message);
         process.exitCode = 1;
         return;
     }
@@ -235,7 +371,8 @@ async function handleShow(key) {
 /**
  * `--restore <id>`: make an inactive entry active again through the store's
  * restoreAnchor, which clears its notes and its verification so maintenance
- * reviews it again, and re-renders the files. A refusal writes nothing.
+ * reviews it again, and re-renders the files. It writes through the store lock, so
+ * it moves the old folder first (prepareToWrite). A refusal writes nothing.
  */
 async function handleRestore(anchor) {
     const ledgerRoot = await requireLedgerRoot('restore not performed');
@@ -251,6 +388,8 @@ async function handleRestore(anchor) {
         process.exitCode = 1;
         return;
     }
+    if (!(await prepareToWrite(ledgerRoot, 'restored')))
+        return;
     const restored = store.restoreAnchor(ledgerRoot, anchor, { timeoutMs: LOCK_WAIT_MS });
     if (!restored.ok) {
         p.log.error(storeRefusal(restored.error, 'restored'));
@@ -260,7 +399,7 @@ async function handleRestore(anchor) {
     p.log.success(`Restored ${restored.value.anchor_id} (${restored.value.status}); it is due for review again.`);
 }
 /**
- * The scope choices of `devflow learning --configure`.
+ * The scope choices of `devflow curation --configure`.
  *
  * D-LEARNING-MODEL-PRECEDENCE: the session-start hook takes the first layer that
  * supplies a model — the project file, then a `devflow agents` Curate mapping,
@@ -268,14 +407,14 @@ async function handleRestore(anchor) {
  * such a mapping, and its hint says so.
  */
 export const CONFIGURE_SCOPE_OPTIONS = [
-    { value: 'project', label: 'Project', hint: 'This project only (.devflow/learning/learning.json)' },
+    { value: 'project', label: 'Project', hint: 'This project only (.devflow/curation/curation.json)' },
     {
         value: 'global',
         label: 'Global',
-        hint: 'All projects (~/.devflow/learning.json); a devflow agents Curate mapping takes precedence over it',
+        hint: 'All projects (~/.devflow/curation.json); a devflow agents Curate mapping takes precedence over it',
     },
 ];
-/** The models `devflow learning --configure` offers, each with what it is good for. */
+/** The models `devflow curation --configure` offers, each with what it is good for. */
 const CURATE_MODEL_CHOICES = [
     { value: 'opus', label: 'Opus', note: 'highest quality for detection + curation judgment' },
     { value: 'sonnet', label: 'Sonnet', note: 'good balance of quality and speed' },
@@ -298,7 +437,7 @@ export function curateModelOptions(shippedModel) {
     }));
 }
 async function handleConfigure() {
-    p.intro(color.bgCyan(color.black(' Learning Configuration ')));
+    p.intro(color.bgCyan(color.black(' Curation Configuration ')));
     const shippedModel = (await loadShippedAgentDefaults()).curate?.model;
     const model = await p.select({
         message: 'Model for decision detection',
@@ -332,36 +471,52 @@ async function handleConfigure() {
     if (scope === 'global') {
         const globalDir = getDevFlowDirectory();
         await fs.mkdir(globalDir, { recursive: true });
-        await fs.writeFile(path.join(globalDir, 'learning.json'), configJson, 'utf-8');
-        p.log.success(`Global config written to ${color.dim(path.join(globalDir, 'learning.json'))}`);
+        const globalConfigPath = getGlobalCurateTuningConfigPath(globalDir);
+        await fs.writeFile(globalConfigPath, configJson, 'utf-8');
+        p.log.success(`Global config written to ${color.dim(globalConfigPath)}`);
     }
     else {
         // D-LEDGER-MAIN-WORKTREE: session-start-context reads the project tuning config
-        // from the ledger ($LEDGER_ROOT/.devflow/learning/), so write it there — the
+        // from the ledger ($LEDGER_ROOT/.devflow/curation/), so write it there — the
         // main checkout in a linked worktree; the current directory outside git.
         const projectRoot = (await getLedgerRoot()) ?? process.cwd();
-        const learningDir = getLearningDir(projectRoot);
-        const projectConfigPath = getCurateTuningConfigPath(projectRoot);
+        // Skew or a move that cannot run (busy, refused, failed) writes nothing, so the
+        // config never lands in a folder the readers do not use.
+        if (!(await prepareToWrite(projectRoot, 'written')))
+            return;
+        // The creator rule: this writer makes the new folder only when the old name is
+        // absent, so it looks once more. A folder of the old name can stand again after the
+        // move, and the new folder made beside it would hide its ledger from every reader.
+        if (await oldLedgerFolderPresent(projectRoot)) {
+            p.log.error(movingLine('written'));
+            process.exitCode = 1;
+            return;
+        }
+        // The folder that is checked is the folder that is written.
+        const curationDir = getCurationDir(projectRoot);
+        const projectConfigPath = path.join(curationDir, CURATION_TUNING_FILE_NAME);
         // D-CLI-NO-SYMLINK (core/linked-path.ts): nothing is written through a .devflow,
-        // a learning folder or a learning.json that is a symbolic link.
-        const linked = await firstSymbolicLink([path.dirname(learningDir), learningDir, projectConfigPath]);
+        // a curation folder or a curation.json that is a symbolic link.
+        const linked = await firstSymbolicLink([path.dirname(curationDir), curationDir, projectConfigPath]);
         if (linked !== null) {
             p.log.error(`Project config not written: ${linked} is a symbolic link, and devflow writes nothing through one`);
             process.exitCode = 1;
             return;
         }
-        await fs.mkdir(learningDir, { recursive: true });
+        await fs.mkdir(curationDir, { recursive: true });
         await fs.writeFile(projectConfigPath, configJson, 'utf-8');
         p.log.success(`Project config written to ${color.dim(projectConfigPath)}`);
     }
     p.outro(color.green('Configuration saved.'));
 }
 /**
- * `--reset`: remove all learning state — entries, observations, rendered files,
+ * `--reset`: remove all curation state — entries, observations, rendered files,
  * the tuning config, and the queue with its claim — through the store's
- * resetLearning, under the learning lock every learning writer takes
- * (D-ONE-LEARNING-LOCK, D-RESET-UNDER-LOCK). A project with no learning directory
- * has nothing to reset, and nothing is created there (D-NO-STRAY-TREE).
+ * resetCuration, under the curation lock every curation writer takes
+ * (D-ONE-LEARNING-LOCK, D-RESET-UNDER-LOCK). The old folder moves first
+ * (prepareToWrite), so the reset reaches the data the hooks use; a backup folder a
+ * move left stays in place. A project with no curation directory has nothing to
+ * reset, and nothing is created there (D-NO-STRAY-TREE).
  */
 async function handleReset() {
     const ledgerRoot = await requireLedgerRoot('reset not performed');
@@ -370,30 +525,36 @@ async function handleReset() {
     const store = requireStore();
     if (!store)
         return;
-    if (!(await isDirectory(getLearningDir(ledgerRoot)))) {
-        p.log.info('No learning data to reset.');
+    if (!(await prepareToWrite(ledgerRoot, 'reset')))
+        return;
+    if (!(await isDirectory(getCurationDir(ledgerRoot)))) {
+        p.log.info('No curation data to reset.');
         return;
     }
-    const proceed = await confirmOnTerminal('Remove all learning state files? This cannot be undone.', 'Reset cancelled.');
+    const proceed = await confirmOnTerminal('Remove all curation state files? This cannot be undone.', 'Reset cancelled.');
     if (!proceed)
         return;
-    const reset = store.resetLearning(ledgerRoot, { timeoutMs: LOCK_WAIT_MS });
+    const reset = store.resetCuration(ledgerRoot, { timeoutMs: LOCK_WAIT_MS });
     if (!reset.ok) {
-        if (reset.error.kind === 'no-learning-dir') {
-            p.log.info('No learning data to reset.');
+        if (reset.error.kind === 'no-curation-dir') {
+            p.log.info('No curation data to reset.');
             return;
         }
         p.log.error(storeRefusal(reset.error, 'reset'));
         process.exitCode = 1;
         return;
     }
-    p.log.success('Reset complete — removed .devflow/learning/ state.');
+    p.log.success('Reset complete — removed .devflow/curation/ state.');
 }
 /**
  * `--clear`: drop the observations no entry uses (D-CLEAR-UNREFERENCED), then
- * drain the learning queue. The queue is drained only once the clear succeeded:
+ * drain the curation queue. The queue is drained only once the clear succeeded:
  * a busy lock or a refusal leaves both the log and the queue as they were, so a
- * failed clear changes nothing.
+ * failed clear changes nothing. The old folder moves first (prepareToWrite), so the
+ * clear and the drain reach the data the hooks use; a backup folder a move left
+ * stays in place. When git tracks any entry under a data folder or a backup folder, or
+ * does not answer, the drain deletes no queue file and a warning carries the fixed
+ * notice.
  */
 async function handleClear() {
     const ledgerRoot = await requireLedgerRoot('clear not performed');
@@ -402,8 +563,10 @@ async function handleClear() {
     const store = requireStore();
     if (!store)
         return;
-    if (!(await isDirectory(getLearningDir(ledgerRoot)))) {
-        p.log.info('No learning data to clear.');
+    if (!(await prepareToWrite(ledgerRoot, 'cleared')))
+        return;
+    if (!(await isDirectory(getCurationDir(ledgerRoot)))) {
+        p.log.info('No curation data to clear.');
         return;
     }
     const proceed = await confirmOnTerminal('Drop every observation no entry uses? Entries and the observations they use are kept. This cannot be undone.', 'Clear cancelled.');
@@ -411,8 +574,8 @@ async function handleClear() {
         return;
     const cleared = store.clearUnreferenced(ledgerRoot, { timeoutMs: LOCK_WAIT_MS });
     if (!cleared.ok) {
-        if (cleared.error.kind === 'no-learning-dir') {
-            p.log.info('No learning data to clear.');
+        if (cleared.error.kind === 'no-curation-dir') {
+            p.log.info('No curation data to clear.');
             return;
         }
         p.log.error(storeRefusal(cleared.error, 'cleared'));
@@ -421,15 +584,15 @@ async function handleClear() {
     }
     // A mid-run Curate agent whose claimed batch vanishes stops without further
     // writes — the desired outcome of clearing.
-    const drain = await drainLearningQueue(ledgerRoot);
+    const drain = await drainCurationQueue(ledgerRoot);
     p.log.success(`Cleared ${counted(cleared.value.cleared, 'observation')} no entry uses and kept ${cleared.value.kept} ` +
-        `that entries use${drain.drained ? '; drained the learning queue.' : '.'}`);
+        `that entries use${drain.drained ? '; drained the curation queue.' : '.'}`);
     if (!drain.drained)
-        p.log.warn(formatRefusedDrain('learning', drain.linkedFolder));
+        p.log.warn(formatCurationNotDrained(drain));
 }
 /**
  * Make the installed prompts match the switch just written
- * (D-LEARNING-VARIANT-INSTALL): the learning-on or learning-off commands and
+ * (D-LEARNING-VARIANT-INSTALL): the curation-on or curation-off commands and
  * agents, and the apply-decisions skill. The same convergence `devflow init` runs,
  * followed by reapplying the saved agent model mapping so `devflow agents`
  * overrides survive.
@@ -437,70 +600,110 @@ async function handleClear() {
  * Warn-not-fail: the switch itself is already recorded, and either mismatch is
  * safe (an on variant is still gated at run time, an off variant loads no
  * decisions), so a problem here never changes the exit code.
+ *
+ * Answers whether the converge ran, which means the installed files are the ones
+ * this CLI writes. The toggle moves the ledger folder only then: under version skew
+ * (or when that could not be told) it moves nothing.
  */
 async function convergeInstalledVariants(enabled) {
     try {
-        const outcome = await applyLearningToggle({
+        const outcome = await applyCurationToggle({
             claudeDir: getClaudeDirectory(),
             devflowDir: getDevFlowDirectory(),
-            learning: enabled,
+            curation: enabled,
             runningVersion: await readRunningVersion(),
             warn: (msg) => p.log.warn(msg),
         });
         if (outcome.kind === 'skipped') {
             p.log.warn(outcome.message);
-            return;
+            return 'not-converged';
         }
-        const changed = describeLearningConverge(outcome.result, enabled);
+        const changed = describeCurationConverge(outcome.result, enabled);
         if (changed !== null)
             p.log.info(color.dim(`Installed prompts: ${changed}`));
+        return 'converged';
     }
     catch (err) {
-        p.log.warn(`Could not update the installed prompts for the new learning setting — run ${color.cyan('devflow init')}: ${String(err)}`);
+        p.log.warn(`Could not update the installed prompts for the new curation setting — run ${color.cyan('devflow init')}: ${String(err)}`);
+        return 'not-converged';
     }
 }
+/**
+ * The toggle's move of the current project's ledger folder: tried once with no wait,
+ * and only where the old folder is present. A busy move is not an error — the project
+ * moves at its next event — and a refusal, a failure or a skip (git tracks files in a
+ * data folder, or git did not answer) is a warning: the switch is already recorded, so
+ * none of them changes the exit code. Answers the skip reason whose fixed notice it
+ * printed, or null when it printed none.
+ */
+async function tryMoveForToggle(ledgerRoot) {
+    if (!(await oldLedgerFolderPresent(ledgerRoot)))
+        return null;
+    const outcome = await runSharedMove(ledgerRoot);
+    if (outcome.kind === 'moved' || outcome.kind === 'unchanged')
+        return null;
+    for (const line of moveProblemLines(outcome)) {
+        if (outcome.kind === 'busy')
+            p.log.info(color.dim(describeMoveText(line)));
+        else
+            p.log.warn(describeMoveText(line));
+    }
+    return outcome.kind === 'left-alone' ? outcome.reason : null;
+}
 /**
  * `--enable` / `--disable`: the machine-wide switch (D-FEATURES-NARROW-ONLY),
- * converged exactly as `devflow init --learning / --no-learning` converges it —
- * the manifest value, the installed prompt variants and skill
- * (D-LEARNING-VARIANT-INSTALL), and on disable a drained queue in the current
- * project. Never requires a git root: the switch is not a per-project setting.
+ * converged exactly as `devflow init --curation / --no-curation` converges it —
+ * the manifest value (both machine keys, written first), the installed prompt
+ * variants and skill (D-LEARNING-VARIANT-INSTALL), the current project's ledger
+ * folder move, and on disable a drained queue in every ledger folder that exists and
+ * in the backups a move left. The drain deletes no queue file, and prints the fixed
+ * notice of a skipped move once, when git tracks any entry under a data folder or a
+ * backup folder, or does not answer.
+ * Never requires a git root: the switch is not a per-project setting.
+ *
+ * Under version skew the toggle records the switch and moves nothing; otherwise it
+ * tries the shared move with no wait. Only `--disable` drains, skew included.
  */
 async function handleToggle(enabled) {
-    const recorded = await writeMachineFeature(getDevFlowDirectory(), 'learning', enabled);
+    const recorded = await writeMachineFeature(getDevFlowDirectory(), 'curation', enabled);
     if (!recorded.ok) {
         p.log.error(`Devflow is not installed on this machine — run ${color.cyan('devflow init')} first`);
         process.exitCode = 1;
         return;
     }
-    await convergeInstalledVariants(enabled);
+    const converged = await convergeInstalledVariants(enabled);
+    const ledgerRoot = await getLedgerRoot();
+    const shownSkip = converged === 'converged' && ledgerRoot ? await tryMoveForToggle(ledgerRoot) : null;
     if (enabled) {
-        p.log.success('Learning enabled in every project (a repository can opt out)');
+        p.log.success('Curation enabled in every project (a repository can opt out)');
         p.log.info(color.dim('Architectural decisions and pitfalls will be detected from your sessions'));
         return;
     }
-    // Drain the current project's learning (decisions-detection) queue so stale
-    // turns don't process on re-enable. A mid-run Curate agent whose claimed
-    // batch vanishes aborts without changes — the desired outcome of disabling.
-    const ledgerRoot = await getLedgerRoot();
+    // Drain the current project's curation (decisions-detection) queue, in each ledger
+    // folder that exists and in the backups a move left, so stale turns don't process on
+    // re-enable. A mid-run Curate agent whose claimed batch vanishes aborts without
+    // changes — the desired outcome of disabling. A project whose data folders git tracks
+    // keeps every file: the switch is recorded, and the drain warns instead.
     if (ledgerRoot) {
-        const drain = await drainLearningQueue(ledgerRoot);
+        const drain = await drainDisabledCurationQueue(ledgerRoot);
         if (!drain.drained)
-            p.log.warn(formatRefusedDrain('learning', drain.linkedFolder));
+            p.log.warn(formatCurationNotDrained(drain, shownSkip));
+        else if (drain.warning !== undefined)
+            p.log.warn(drain.warning);
     }
-    p.log.success('Learning disabled in every project');
+    p.log.success('Curation disabled in every project');
 }
-export const learningCommand = new Command('learning')
-    .description('Enable or disable learning (decision/pitfall detection) in every project')
-    .option('--enable', 'Enable learning in every project (a repository can opt out)')
-    .option('--disable', 'Disable learning in every project')
-    .option('--status', 'Show learning status and entry counts')
+export const curationCommand = new Command('curation')
+    .description('Enable or disable curation (decision/pitfall detection) in every project')
+    .option('--enable', 'Enable curation in every project (a repository can opt out)')
+    .option('--disable', 'Disable curation in every project')
+    .option('--status', 'Show curation status and entry counts')
     .option('--list', 'List entries, inactive entries with their notes, and observations')
     .option('--show <id>', 'Print one entry (ADR-NNN or PF-NNN) or observation (obs_...) as JSON')
     .option('--restore <id>', 'Make an inactive entry active again')
-    .option('--configure', 'Interactive configuration wizard for learning.json')
-    .option('--clear', 'Drop the observations no entry uses, and drain the learning queue')
-    .option('--reset', 'Remove all learning state files and artifacts')
+    .option('--configure', 'Interactive configuration wizard for curation.json')
+    .option('--clear', 'Drop the observations no entry uses, and drain the curation queue')
+    .option('--reset', 'Remove all curation state files and artifacts')
     .action(async (options) => {
     const knownFlags = [
         'enable', 'disable', 'status', 'list', 'show', 'restore', 'configure',
@@ -551,4 +754,4 @@ export const learningCommand = new Command('learning')
         return;
     }
 });
-//# sourceMappingURL=learning.js.map
+//# sourceMappingURL=curation.js.map