devflow-kit 3.6.0 → 3.8.0

package/dist/targets/claude-code/{learning-install.js → curation-install.js}

@@ -1,26 +1,26 @@
 /**
- * Learning-variant installer for the Claude Code target.
+ * Curation-variant installer for the Claude Code target.
  *
- * D-LEARNING-VARIANT-INSTALL: the install follows the machine's learning switch
- * (`features.learning` in ~/.devflow/manifest.json) and nothing else. When the
- * switch is off, every command and agent that has a learning-off variant
- * (dist/learning-off/{commands,agents}, built by D-LEARNING-VARIANTS) is installed
+ * D-LEARNING-VARIANT-INSTALL: the install follows the machine's curation switch
+ * (`features.curation` in ~/.devflow/manifest.json) and nothing else. When the
+ * switch is off, every command and agent that has a curation-off variant
+ * (dist/curation-off/{commands,agents}, built by D-LEARNING-VARIANTS) is installed
  * from it, and the apply-decisions skill is not installed, so the decisions text
  * reaches no prompt and the skill has no reader. When the switch is on, the
- * learning-on files and the skill are installed. Three pieces carry it:
+ * curation-on files and the skill are installed. Three pieces carry it:
  *
  *   - the source order (src/core/assets.ts commandSourceDirs / agentSourceDirs):
- *     with learning off the learning-off directory is consulted first, then the
+ *     with curation off the curation-off directory is consulted first, then the
  *     normal order, so a host with no arm installs its one file as before;
- *   - the skill condition (LEARNING_GATED_SKILLS in src/core/plugins.ts):
- *     installViaFileCopy leaves the skill out when learning is off;
- *   - {@link convergeLearningVariants}, below: the converge that makes an
+ *   - the skill condition (CURATION_GATED_SKILLS in src/core/plugins.ts):
+ *     installViaFileCopy leaves the skill out when curation is off;
+ *   - {@link convergeCurationVariants}, below: the converge that makes an
  *     ALREADY-installed tree match the switch, run by `devflow init` after the
- *     file copy and by `devflow learning --enable/--disable` after the switch is
- *     written ({@link applyLearningToggle}).
+ *     file copy and by `devflow curation --enable/--disable` after the switch is
+ *     written ({@link applyCurationToggle}).
  *
  * The converge, decided in turn:
- *   - Its roster is the files that exist under dist/learning-off, not a list typed
+ *   - Its roster is the files that exist under dist/curation-off, not a list typed
  *     here: the build owns which hosts have an arm, so a new arm is converged with
  *     no edit to this file.
  *   - It rewrites only files that are ALREADY installed. A `--plugin` install
@@ -42,41 +42,42 @@
  *     the skill is resolved through the installer's own resolveSkillSource. Only
  *     skills and rules have shadows; commands and agents have none, so there is
  *     nothing for an off variant to collide with. A shadow of apply-decisions
- *     under learning off is DORMANT in the same sense as one for a deselected
+ *     under curation off is DORMANT in the same sense as one for a deselected
  *     skill: kept in ~/.devflow/skills, never installed, never deleted, and
- *     applied again the moment learning comes back on.
+ *     applied again the moment curation comes back on.
  *   - Version skew: the variants in this package were built with this version.
  *     When the manifest records another version, the installed files are not the
- *     ones this package would rewrite, so {@link applyLearningToggle} skips the
+ *     ones this package would rewrite, so {@link applyCurationToggle} skips the
  *     converge and says to run `devflow init`.
  *   - An agent's installed `model:` and `effort:` are carried into the variant before
  *     the byte comparison (D-AGENT-OVERRIDE-CARRY, see {@link withInstalledState}),
  *     so the overrides `devflow agents` and the proxy put there are never written
  *     back to the shipped values and a no-op converge writes no agent.
- *     {@link applyLearningToggle} still runs reapplyAgentMapping straight after a
+ *     {@link applyCurationToggle} still runs reapplyAgentMapping straight after a
  *     converge that rewrote an agent: it reads agent-models.json and is the authority.
  *
  * D-LEARNING-PRELOAD-MACHINE-ONLY (amended): the apply-decisions preload follows
  * the machine switch only, never a repository's narrowing, because a repository
- * can narrow learning off on a machine where it is on and the installed agents are
- * machine-wide. Met by the variant: the learning-off agent files do not preload
- * the skill (no install-time frontmatter rewrite exists), and the learning-on files
+ * can narrow curation off on a machine where it is on and the installed agents are
+ * machine-wide. Met by the variant: the curation-off agent files do not preload
+ * the skill (no install-time frontmatter rewrite exists), and the curation-on files
  * keep the preload and their run-time gate for a narrowed repository. A repo
- * `project.json` with `learning: false` on a learning-on machine therefore changes
+ * `project.json` with `curation: false` on a curation-on machine therefore changes
  * nothing installed.
  *
  * I/O orchestration in src/targets/; the pure selection rules stay in src/core/.
  */
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { agentSourceDirs, commandSourceDirs, learningOffDir, } from '../../core/assets.js';
+import { agentSourceDirs, commandSourceDirs, curationOffDir, } from '../../core/assets.js';
 import { carryStampedTools } from '../../core/agent-frontmatter.js';
 import { carryAgentOverrides, reapplyAgentMapping } from '../../core/agent-models.js';
+import { describeEchoedValue } from '../../core/echo-value.js';
 import { writeFileAtomicExclusive } from '../../core/fs-atomic.js';
 import { readManifest } from '../../core/manifest.js';
 import { getPackageRoot } from '../../core/paths.js';
 import { isProxyEnabled } from '../../core/proxy-state.js';
-import { DEVFLOW_PLUGINS, LEARNING_GATED_SKILLS, installedLanguageFocuses, prefixSkillName, skillsOf, } from '../../core/plugins.js';
+import { DEVFLOW_PLUGINS, CURATION_GATED_SKILLS, installedLanguageFocuses, prefixSkillName, skillsOf, } from '../../core/plugins.js';
 import { copyDirectory, resolveSkillSource } from './installer.js';
 import { LANGUAGE_STAMPED_COMMANDS, stampForConverge } from './language-stamp.js';
 // ── Bounds ─────────────────────────────────────────────────────────────────
@@ -85,7 +86,7 @@ import { LANGUAGE_STAMPED_COMMANDS, stampForConverge } from './language-stamp.js
  * 9 agents; the bound exists so a directory that grew without limit cannot turn the
  * converge into an unbounded loop (every loop has an explicit bound).
  */
-export const MAX_LEARNING_ROSTER = 256;
+export const MAX_CURATION_ROSTER = 256;
 /** Deepest skill-directory descent the tree comparison takes. */
 const MAX_SKILL_TREE_DEPTH = 4;
 /** A roster entry is a flat, lowercase, hyphenated markdown basename. */
@@ -95,12 +96,12 @@ const KINDS = ['commands', 'agents'];
 function installedFile(claudeDir, kind, fileName) {
     return path.join(claudeDir, kind, 'devflow', fileName);
 }
-/** The learning-ON source directories for a kind, most-preferred first. */
+/** The curation-ON source directories for a kind, most-preferred first. */
 function onSourceDirs(kind, root) {
     return kind === 'commands' ? commandSourceDirs(true, root) : agentSourceDirs(root, true);
 }
 /**
- * The roster of one kind: the `.md` files under dist/learning-off/<kind>, sorted.
+ * The roster of one kind: the `.md` files under dist/curation-off/<kind>, sorted.
  *
  * `present` is false when the directory does not exist (the build has not run, or
  * only `build:cli` did), so the caller can say so instead of reporting a converge
@@ -109,18 +110,18 @@ function onSourceDirs(kind, root) {
 async function readRoster(kind, root, warn) {
     let entries;
     try {
-        entries = await fs.readdir(learningOffDir(kind, root));
+        entries = await fs.readdir(curationOffDir(kind, root));
     }
     catch (err) {
         if (err.code === 'ENOENT')
             return { names: [], present: false };
-        warn(`learning variants: cannot read the ${kind} variants — ${String(err)}`);
+        warn(`curation variants: cannot read the ${kind} variants — ${String(err)}`);
         return { names: [], present: false };
     }
     const names = entries.filter(entry => ROSTER_NAME_RE.test(entry)).sort();
-    if (names.length > MAX_LEARNING_ROSTER) {
-        warn(`learning variants: ${names.length} ${kind} variants exceed the bound of ${MAX_LEARNING_ROSTER}; converging the first ${MAX_LEARNING_ROSTER}`);
-        return { names: names.slice(0, MAX_LEARNING_ROSTER), present: true };
+    if (names.length > MAX_CURATION_ROSTER) {
+        warn(`curation variants: ${names.length} ${kind} variants exceed the bound of ${MAX_CURATION_ROSTER}; converging the first ${MAX_CURATION_ROSTER}`);
+        return { names: names.slice(0, MAX_CURATION_ROSTER), present: true };
     }
     return { names, present: true };
 }
@@ -188,23 +189,23 @@ function withInstalledState(kind, fileName, source, installed, focuses) {
  * file is still tried.
  */
 async function convergeFile(kind, fileName, opts) {
-    const { claudeDir, learning, warn, root, focuses } = opts;
+    const { claudeDir, curation, warn, root, focuses } = opts;
     const target = installedFile(claudeDir, kind, fileName);
     const installed = await readIfPresent(target);
     if (installed === 'absent')
         return 'not-installed';
     if (installed === 'unreadable') {
-        warn(`learning variants: cannot read the installed ${kind}/${fileName} (${target}) — left as it is`);
+        warn(`curation variants: cannot read the installed ${kind}/${fileName} (${target}) — left as it is`);
         return 'failed';
     }
-    // Learning off: the variant is the roster file itself. Learning on: the normal
-    // source order, which is where the learning-on file of that host lives.
-    const candidates = learning
+    // Curation off: the variant is the roster file itself. Curation on: the normal
+    // source order, which is where the curation-on file of that host lives.
+    const candidates = curation
         ? onSourceDirs(kind, root).map(dir => path.join(dir, fileName))
-        : [path.join(learningOffDir(kind, root), fileName)];
+        : [path.join(curationOffDir(kind, root), fileName)];
     const source = await firstReadable(candidates);
     if (source === undefined) {
-        warn(`learning variants: no source for ${kind}/${fileName} (searched: ${candidates.join(', ')}) — left as it is`);
+        warn(`curation variants: no source for ${kind}/${fileName} (searched: ${candidates.join(', ')}) — left as it is`);
         return 'failed';
     }
     const wanted = withInstalledState(kind, fileName, source.bytes, installed, focuses);
@@ -218,7 +219,7 @@ async function convergeFile(kind, fileName, opts) {
         await writeFileAtomicExclusive(target, wanted.toString('utf-8'));
     }
     catch (err) {
-        warn(`learning variants: could not rewrite ${kind}/${fileName} (${target}) — ${String(err)}`);
+        warn(`curation variants: could not rewrite ${kind}/${fileName} (${target}) — ${String(err)}`);
         return 'failed';
     }
     return 'rewritten';
@@ -287,7 +288,7 @@ async function pathExists(p) {
  * crash leaves behind must not look like a second skill to Claude Code.
  */
 async function swapInSkillDirectory(claudeDir, sourceDir, target) {
-    const staging = path.join(claudeDir, `.devflow-learning-${process.pid}-${Date.now().toString(36)}.tmp`);
+    const staging = path.join(claudeDir, `.devflow-curation-${process.pid}-${Date.now().toString(36)}.tmp`);
     const backup = `${staging}.old`;
     try {
         await copyDirectory(sourceDir, staging);
@@ -309,16 +310,16 @@ async function swapInSkillDirectory(claudeDir, sourceDir, target) {
         await fs.rm(backup, { recursive: true, force: true }).catch(() => undefined);
     }
 }
-/** Converge the learning-gated skill directories. Never throws. */
+/** Converge the curation-gated skill directories. Never throws. */
 async function convergeSkills(opts) {
-    const { claudeDir, devflowDir, learning, plugins, warn } = opts;
+    const { claudeDir, devflowDir, curation, plugins, warn } = opts;
     const selected = skillsOf(plugins);
     let state = 'unchanged';
     // Every gated skill is converged: a failure on one must not skip the next.
-    for (const skill of LEARNING_GATED_SKILLS) {
+    for (const skill of CURATION_GATED_SKILLS) {
         const target = path.join(claudeDir, 'skills', prefixSkillName(skill));
         try {
-            if (!learning) {
+            if (!curation) {
                 if (!(await pathExists(target)))
                     continue;
                 await fs.rm(target, { recursive: true });
@@ -337,7 +338,7 @@ async function convergeSkills(opts) {
             state = 'installed';
         }
         catch (err) {
-            warn(`learning variants: could not converge the ${prefixSkillName(skill)} skill (${target}) — ${String(err)}`);
+            warn(`curation variants: could not converge the ${prefixSkillName(skill)} skill (${target}) — ${String(err)}`);
             state = 'failed';
         }
     }
@@ -346,21 +347,21 @@ async function convergeSkills(opts) {
 // ── Convergence ────────────────────────────────────────────────────────────
 /**
  * Make the installed commands, agents and apply-decisions skill match the
- * machine's learning switch.
+ * machine's curation switch.
  *
  * Never throws. A caller reads `converged`; it does not catch. A claudeDir that is
  * not absolute is reported the same way rather than thrown, because an install
  * must not die on it.
  */
-export async function convergeLearningVariants(opts) {
-    const { claudeDir, learning, warn } = opts;
+export async function convergeCurationVariants(opts) {
+    const { claudeDir, curation, warn } = opts;
     const empty = {
         converged: false, commandsRewritten: [], agentsRewritten: [], unchanged: 0, notInstalled: 0, skill: 'unchanged',
     };
     // Precondition, asserted in production code: a relative claudeDir would resolve
     // the install targets somewhere unexpected.
     if (!path.isAbsolute(claudeDir)) {
-        warn(`learning variants: claudeDir is not an absolute path ("${claudeDir}") — skipping convergence`);
+        warn(`curation variants: claudeDir is not an absolute path ("${claudeDir}") — skipping convergence`);
         return empty;
     }
     const root = opts.packageRoot ?? getPackageRoot();
@@ -372,12 +373,12 @@ export async function convergeLearningVariants(opts) {
     for (const kind of KINDS) {
         const roster = await readRoster(kind, root, warn);
         if (!roster.present) {
-            warn(`learning variants: no ${kind} variants under ${learningOffDir(kind, root)} — run \`npm run build:mds\`; installed ${kind} left as they are`);
+            warn(`curation variants: no ${kind} variants under ${curationOffDir(kind, root)} — run \`npm run build:mds\`; installed ${kind} left as they are`);
             failed = true;
             continue;
         }
         for (const fileName of roster.names) {
-            const outcome = await convergeFile(kind, fileName, { claudeDir, learning, warn, root, focuses });
+            const outcome = await convergeFile(kind, fileName, { claudeDir, curation, warn, root, focuses });
             if (outcome === 'rewritten')
                 rewritten[kind].push(fileName);
             else if (outcome === 'unchanged')
@@ -418,12 +419,12 @@ export async function readRunningVersion(packageRoot = getPackageRoot()) {
  *
  * The caller prints it only on a toggle: a run that moved nothing says nothing.
  */
-export function describeLearningConverge(result, learning) {
+export function describeCurationConverge(result, curation) {
     const parts = [];
     const prompts = result.commandsRewritten.length + result.agentsRewritten.length;
     if (prompts > 0) {
         parts.push(`${result.commandsRewritten.length} command(s) and ${result.agentsRewritten.length} agent(s) ` +
-            `rewritten for the learning-${learning ? 'on' : 'off'} variant`);
+            `rewritten for the curation-${curation ? 'on' : 'off'} variant`);
     }
     if (result.skill === 'installed')
         parts.push('the apply-decisions skill installed');
@@ -431,18 +432,49 @@ export function describeLearningConverge(result, learning) {
         parts.push('the apply-decisions skill removed');
     return parts.length === 0 ? null : parts.join('; ');
 }
+/**
+ * Whether the version the manifest records is the version of the running package.
+ * Pure. An unknown running version (null) never matches: the installed files are then
+ * not known to be the ones this package would write. Both callers, the curation
+ * toggle and `init --hud-only`, ask this one question.
+ */
+export function installedVersionMatches(installedVersion, runningVersion) {
+    return runningVersion !== null && installedVersion === runningVersion;
+}
 /**
  * The version-skew check, apart from the I/O so it is provable by itself: null when
- * the installed prompts and this package agree, else the message to print.
+ * the installed prompts and this package agree, else the message to print. The
+ * installed version is hand-editable file content, so it prints through
+ * `describeEchoedValue`.
+ */
+export function curationToggleSkew(installedVersion, runningVersion, curation) {
+    if (installedVersionMatches(installedVersion, runningVersion))
+        return null;
+    return (`The installed prompts come from devflow ${describeEchoedValue(installedVersion)} and this CLI is ${runningVersion ?? 'of unknown version'}, ` +
+        `so the curation-${curation ? 'on' : 'off'} variants were not applied. Run \`devflow init\` to apply them.`);
+}
+/**
+ * The version-skew line for a command that writes curation data, or null when the
+ * installed scripts are the ones this CLI would write. A hook of another version
+ * reads and creates a different ledger folder, so such a command writes nothing until
+ * `devflow init` has run. Apart from the toggle's own check (`curationToggleSkew`,
+ * which also names the prompt variants): this line is for configure and the other
+ * mutating subcommands. The installed version is hand-editable file content, so it
+ * prints through `describeEchoedValue`.
  */
-export function learningToggleSkew(installedVersion, runningVersion, learning) {
-    if (runningVersion !== null && installedVersion === runningVersion)
+export async function installedScriptsSkew(devflowDir, packageRoot) {
+    const manifest = await readManifest(devflowDir);
+    if (manifest === null) {
+        return 'No readable install manifest, so the installed scripts are not known. Run `devflow init` first. Nothing was written.';
+    }
+    const running = await readRunningVersion(packageRoot);
+    if (installedVersionMatches(manifest.version, running))
         return null;
-    return (`The installed prompts come from devflow ${installedVersion} and this CLI is ${runningVersion ?? 'of unknown version'}, ` +
-        `so the learning-${learning ? 'on' : 'off'} variants were not applied. Run \`devflow init\` to apply them.`);
+    return (`The installed scripts come from devflow ${describeEchoedValue(manifest.version)} and this CLI is ` +
+        `${running ?? 'of unknown version'}. Run \`devflow init\` first. Nothing was written.`);
 }
 /**
- * What `devflow learning --enable/--disable` does after the switch is written:
+ * What `devflow curation --enable/--disable` does after the switch is written:
  * converge the installed tree onto the new value, then reapply the saved agent
  * model and effort mapping.
  *
@@ -455,24 +487,24 @@ export function learningToggleSkew(installedVersion, runningVersion, learning) {
  *
  * Never throws.
  */
-export async function applyLearningToggle(opts) {
-    const { claudeDir, devflowDir, learning, runningVersion, warn } = opts;
+export async function applyCurationToggle(opts) {
+    const { claudeDir, devflowDir, curation, runningVersion, warn } = opts;
     const manifest = await readManifest(devflowDir);
     if (manifest === null) {
         return {
             kind: 'skipped',
             reason: 'no-manifest',
-            message: 'No readable install manifest, so the learning variants were not applied. Run `devflow init`.',
+            message: 'No readable install manifest, so the curation variants were not applied. Run `devflow init`.',
         };
     }
-    const skew = learningToggleSkew(manifest.version, runningVersion, learning);
+    const skew = curationToggleSkew(manifest.version, runningVersion, curation);
     if (skew !== null)
         return { kind: 'skipped', reason: 'version-skew', message: skew };
     const selection = new Set(manifest.plugins);
-    const result = await convergeLearningVariants({
+    const result = await convergeCurationVariants({
         claudeDir,
         devflowDir,
-        learning,
+        curation,
         plugins: DEVFLOW_PLUGINS.filter(plugin => selection.has(plugin.name)),
         warn,
         packageRoot: opts.packageRoot,
@@ -489,9 +521,9 @@ export async function applyLearningToggle(opts) {
             agentMappingReapplied = true;
         }
         catch (err) {
-            warn(`learning variants: could not reapply the agent model mapping — ${String(err)}`);
+            warn(`curation variants: could not reapply the agent model mapping — ${String(err)}`);
         }
     }
     return { kind: 'converged', result, agentMappingReapplied };
 }
-//# sourceMappingURL=learning-install.js.map
+//# sourceMappingURL=curation-install.js.map

package/dist/targets/claude-code/installer.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
 import { existsSync } from 'fs';
 import * as path from 'path';
-import { SKILL_NAMESPACE, buildAssetMaps, prefixSkillName, unprefixSkillName, getAllSkillNames, getAllAgentNames, getAllCommandNames, FEATURE_OWNED_SKILLS, resolveSkillInstallPlan, omitLearningGatedSkills } from '../../core/plugins.js';
+import { SKILL_NAMESPACE, buildAssetMaps, prefixSkillName, unprefixSkillName, getAllSkillNames, getAllAgentNames, getAllCommandNames, FEATURE_OWNED_SKILLS, resolveSkillInstallPlan, omitCurationGatedSkills } from '../../core/plugins.js';
 import { skillsDir, agentSourceDirs, rulesDir, commandSourceDirs, scriptsDir, compiledSkillRefsDir } from '../../core/assets.js';
 import { getPackageRoot, isContainedIn } from '../../core/paths.js';
 import { sweepOrphanedAssets, mdFileName, mdEntryName } from '../../core/orphan-sweep.js';
@@ -1344,7 +1344,7 @@ async function firstExisting(candidates) {
  * installed in its place).
  *
  * The ONE spelling of that decision: the install loop and
- * convergeLearningVariants both call it, so a skill the learning toggle installs
+ * convergeCurationVariants both call it, so a skill the curation toggle installs
  * later is shadowed exactly as one the install installed.
  *
  * The shipped source is stat-checked FIRST, even under a valid shadow, so an
@@ -1438,8 +1438,8 @@ async function removeDeselectedSkills(skillsDir, names) {
  * the selective uninstall, which rewrites the files of the plugins that stay installed
  * after it removed a retired agent.
  *
- * Commands come from dist/commands/{name}.md, or — with learning off — the learning-off
- * variant dist/learning-off/commands/{name}.md when the host has one
+ * Commands come from dist/commands/{name}.md, or — with curation off — the curation-off
+ * variant dist/curation-off/commands/{name}.md when the host has one
  * (D-LEARNING-VARIANT-INSTALL; commandSourceDirs owns the order). A declared command
  * with no compiled source file is a hard error, not a skip.
  *
@@ -1458,9 +1458,9 @@ async function removeDeselectedSkills(skillsDir, names) {
  * known and leaves it alone.
  */
 export async function installCommandsAndAgents(opts) {
-    const { plugins, agentsMap, claudeDir, learning, trackerServers, warn } = opts;
+    const { plugins, agentsMap, claudeDir, curation, trackerServers, warn } = opts;
     const commandsTarget = path.join(claudeDir, 'commands', 'devflow');
-    const commandDirs = commandSourceDirs(learning);
+    const commandDirs = commandSourceDirs(curation);
     const commandsSourceNames = new Set();
     for (const plugin of plugins) {
         for (const cmd of plugin.commands) {
@@ -1473,8 +1473,8 @@ export async function installCommandsAndAgents(opts) {
         for (const name of commandsSourceNames) {
             const srcFile = await firstExisting(commandDirs.map(dir => path.join(dir, mdFileName(name))));
             if (srcFile === undefined) {
-                // The error names the learning-ON path: that file exists for every declared
-                // command, while a learning-off file exists only for a host with an arm.
+                // The error names the curation-ON path: that file exists for every declared
+                // command, while a curation-off file exists only for a host with an arm.
                 throw new Error(`Command source not found for declared command "${name}": ${path.join(commandSourceDirs(true)[0], mdFileName(name))}. ` +
                     `Ensure build:mds ran successfully before install.`);
             }
@@ -1482,8 +1482,8 @@ export async function installCommandsAndAgents(opts) {
         }
     }
     const agentsTarget = path.join(claudeDir, 'agents', 'devflow');
-    // Learning-aware (D-LEARNING-VARIANT-INSTALL). An injected list wins as given.
-    const agentDirs = opts.agentSourceDirs ?? agentSourceDirs(undefined, learning);
+    // Curation-aware (D-LEARNING-VARIANT-INSTALL). An injected list wins as given.
+    const agentDirs = opts.agentSourceDirs ?? agentSourceDirs(undefined, curation);
     const allAgentNames = new Set();
     for (const plugin of plugins) {
         for (const agent of plugin.agents) {
@@ -1524,7 +1524,7 @@ export async function installCommandsAndAgents(opts) {
  * Returns an InstallReport describing which shadows were applied and which were skipped.
  */
 export async function installViaFileCopy(options) {
-    const { plugins, claudeDir, devflowDir, skillsMap, agentsMap, rulesMap = new Map(), isPartialInstall, spinner, learning, trackerServers = TRACKER_MCP_SERVERS_DEFAULT, warn = () => { }, } = options;
+    const { plugins, claudeDir, devflowDir, skillsMap, agentsMap, rulesMap = new Map(), isPartialInstall, spinner, curation, trackerServers = TRACKER_MCP_SERVERS_DEFAULT, warn = () => { }, } = options;
     const report = {
         shadowedSkills: [],
         shadowedRules: [],
@@ -1687,7 +1687,7 @@ export async function installViaFileCopy(options) {
         plugins: commandAgentPlugins,
         agentsMap: commandAgentMap,
         claudeDir,
-        learning,
+        curation,
         trackerServers,
         agentSourceDirs: options.agentSourceDirs,
         warn,
@@ -1713,12 +1713,12 @@ export async function installViaFileCopy(options) {
     // A declared skill whose source directory is absent is a build/packaging failure
     // and throws rather than silently skipping (matches command pattern).
     //
-    // D-LEARNING-VARIANT-INSTALL: a learning-off machine skips the learning-gated
+    // D-LEARNING-VARIANT-INSTALL: a curation-off machine skips the curation-gated
     // skills here. The pre-clean above walked the UNFILTERED map, so on a full
     // install a leftover copy is already gone; a partial install leaves removal to
-    // convergeLearningVariants, which init runs straight after this call.
+    // convergeCurationVariants, which init runs straight after this call.
     spinner.message('Installing skills...');
-    for (const [skillName] of omitLearningGatedSkills(skillsMap, learning)) {
+    for (const [skillName] of omitCurationGatedSkills(skillsMap, curation)) {
         const resolved = await resolveSkillSource(skillName, devflowDir);
         const skillTarget = path.join(claudeDir, 'skills', prefixSkillName(skillName));
         await copyDirectory(resolved.dir, skillTarget);

package/dist/targets/claude-code/language-stamp.js

@@ -10,7 +10,7 @@
  *   - The carrier is one line, `Installed language focuses: <list>`, shipped as `(none)` in
  *     src/assets/commands/code-review.mds and found again by an anchored match, so a later run can
  *     re-stamp a copy an earlier run stamped. It carries no MDS interpolation braces, and it sits outside
- *     every learning arm, so both variants carry it. A separate stamped file would add a file to the
+ *     every curation arm, so both variants carry it. A separate stamped file would add a file to the
  *     install walk and the install goldens, which an in-place rewrite leaves unchanged.
  *   - Only code-review.md carries it. /dynamic-build spawns every review focus and drops none (plan
  *     decision 1), so it has no stamp, no reduced classes and no DIFF_FILE.
@@ -22,8 +22,8 @@
  *   - `devflow uninstall --plugin` removes a language plugin's skill but no command, so its name would
  *     stay in the stamped copy; the selective phase re-stamps from the plugins that remain, through
  *     {@link restampInstalledCommands} like the install.
- *   - Composition with the learning converge (D-LEARNING-VARIANT-INSTALL), pinned: the converge rewrites
- *     installed command files from dist or dist/learning-off, and those files carry the shipped `(none)`
+ *   - Composition with the curation converge (D-LEARNING-VARIANT-INSTALL), pinned: the converge rewrites
+ *     installed command files from dist or dist/curation-off, and those files carry the shipped `(none)`
  *     line. It therefore applies {@link carryLanguageStamp} inside its own write path, putting the stamp
  *     it finds on the installed copy into the variant it writes ({@link stampForConverge}); a copy with no
  *     list to carry, one installed before the stamp existed, is stamped from the converge's selection
@@ -83,7 +83,7 @@ export function applyLanguageStamp(content, focuses) {
 /**
  * `source` with its stamp line replaced by the one on `installed`.
  *
- * The learning converge's write path (see the header): the variant it installs keeps the list the
+ * The curation converge's write path (see the header): the variant it installs keeps the list the
  * install stamped. Returns `source` unchanged unless both sides hold exactly one stamp line and the
  * installed one is a well-formed list, so a damaged or hostile line is never copied into a fresh file.
  */
@@ -103,7 +103,7 @@ function carriableStampLine(installed) {
     return STAMP_VALUE_RE.test(from[0][0].slice(LANGUAGE_STAMP_PREFIX.length)) ? from[0][0] : null;
 }
 /**
- * The text the learning converge installs for a stamped command: `source` carrying the installed copy's
+ * The text the curation converge installs for a stamped command: `source` carrying the installed copy's
  * list ({@link carryLanguageStamp}) when the copy holds one, else `source` stamped with `focuses`, the
  * effective selection's list, exactly as the install stamps it.
  *

package/dist/targets/claude-code/post-install.js

@@ -56,7 +56,7 @@ const DEVFLOW_POLICY_LINE = '!.devflow/policy.json';
 const DEVFLOW_PROJECT_LINE = '!.devflow/project.json';
 /**
  * The shared .devflow/ gitignore block. Everything under .devflow/ is local
- * (memory, learning, docs, locks) EXCEPT:
+ * (memory, curation, docs, locks) EXCEPT:
  * - Feature knowledge bases: index.md and every {slug}/KNOWLEDGE.md are tracked
  *   + committed (the Knowledge agent commits them at workflow end).
  * - conventions.md: naming-convention authority written by the Git learn-conventions
@@ -78,7 +78,7 @@ const DEVFLOW_PROJECT_LINE = '!.devflow/project.json';
  * so the init-time path and the always-on hook path produce the same file.
  */
 const DEVFLOW_GITIGNORE_BLOCK_LINES = [
-    '# Devflow runtime data — local by default (memory, learning, docs, locks).',
+    '# Devflow runtime data — local by default (memory, curation, docs, locks).',
     '# Shared via git: feature knowledge bases under .devflow/features/ (index.md and',
     '# every {slug}/KNOWLEDGE.md), .devflow/conventions.md (naming authority),',
     '# .devflow/policy.json (retired; presence only) and .devflow/project.json (team settings).',

package/dist/targets/claude-code/tracker-servers.js

@@ -17,7 +17,7 @@
  *          a `--plugin` run that does not install Git leaves the installed, stamped copy alone.
  *       2. `convergeTrackerArtifacts` stamps Tracker as it writes it, and compares the STAMPED text
  *          with the installed file, so a steady-state run reports `unchanged`.
- *       3. `convergeLearningVariants` (init, `devflow learning --enable/--disable`) carries the
+ *       3. `convergeCurationVariants` (init, `devflow curation --enable/--disable`) carries the
  *          installed stamp onto the variant it writes (`carryStampedTools`), the way it carries
  *          `model:` and `effort:`, so a variant switch keeps the list and a repeat run is byte-equal.
  *       4. `devflow tracker --servers` re-stamps the installed copies at once ({@link restampTrackerAgents}).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devflow-kit",
-  "version": "3.6.0",
-  "description": "A meta-harness for Claude Code — turns a single coding agent into an engineering team: orchestration, parallel review, persistent memory, self-learning, and graph workflows",
+  "version": "3.8.0",
+  "description": "A meta-harness for Claude Code — turns a single coding agent into an engineering team: orchestration, parallel review, persistent memory, curated decisions, and graph workflows",
   "type": "module",
   "bin": {
     "devflow": "dist/cli.js"
@@ -12,6 +12,7 @@
     "!dist/**/*.d.ts",
     "src/assets/",
     "src/targets/claude-code/templates/",
+    "templates/lint-pack/",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"

package/src/assets/agents/_partials/_code.mds

@@ -6,8 +6,10 @@ so the build skips it and it reaches an artifact only through the hosts that imp
 D-CODE-VARIANTS: a spawn runs exactly one mode, so one agent for every mode would pay for every
 mode's text and skills on every spawn. Each host carries its own mode sections, its own `OPERATION:`
 line and its own preload (D-CODE-PRELOADS); what every mode needs is written once here. The
-security-scan block lives in `commit_push()`, so every variant keeps it, and the Running
-commands block lives in `tail()`, so the three carry one byte-identical copy.
+Commit and push line lives in `commit_push()`. It ends with one check of the staged diff of every
+committed file for secrets or tokens in debug output, and the security-scan block follows it, so
+every variant keeps both. The Running commands block lives in `tail()`, so the three carry one
+byte-identical copy.
 
 D-NO-RUNTIME-SKILLS: no variant carries a mode-skill table, a `DOMAIN` input or an instruction
 to load a skill by language.
@@ -16,27 +18,27 @@ D-COMPLIANCE-INJECT: no variant names the compliance skill or takes a compliance
 injects the compliance directive into a spawn prompt only when the resolved lens is on, so a
 lens-off spawn pays nothing for it (the directive's home is `commands/_partials/_compliance.mds`).
 
-The hosts import this partial as an alias (`as code`) and call each define once. A learning arm
+The hosts import this partial as an alias (`as code`) and call each define once. A curation arm
 inside a define is split by the build like an arm in a host: the markers sit on lines of their own.
 
 @define input_core():
-- **TASK_ID**: Unique identifier (e.g., "task-2025-01-15_1430")
+- **TASK_ID**: Unique identifier
 - **TASK_DESCRIPTION**: What to do
 - **PUSH** (optional): `true` (default) | `false` — when false, commit only; orchestrator owns push/CI gate
-<!-- learning:on -->
+<!-- curation:on -->
 - **DECISIONS_CONTEXT** (optional): Compact index of active ADR/PF entries.
   When provided, use `devflow:apply-decisions` to Read full bodies on demand.
-<!-- learning:end -->
+<!-- curation:end -->
 @end
 
 @define decisions_orient():
-<!-- learning:on -->
+<!-- curation:on -->
    - If `DECISIONS_CONTEXT` is provided, follow `devflow:apply-decisions` on it. An absent key or `(none)` means no decisions context. State every decision or pitfall you apply in words in code, comments, tests and commit messages, never by its ID.
-<!-- learning:end -->
+<!-- curation:end -->
 @end
 
 @define commit_push():
-**Commit and push**: Create atomic commits with clear messages. Reference TASK_ID. Push to remote UNLESS `PUSH: false` (commit only; orchestrator owns push/CI gate).
+**Commit and push**: Create atomic commits with clear messages. Reference TASK_ID. Push to remote UNLESS `PUSH: false`. Before you commit, check the staged diff of every file you commit: no secrets or tokens in logs or debug output.
    **Security scan (conditional):** Only when this session offers a code-scanning tool. Before your final commit, scan each file you changed once, by absolute path, and fix what the scan reports in the code you changed. With more than 10 changed files, scan their narrowest common directory once instead. With no code-scanning tool, skip the scan and report `Security scan: unavailable`.
 @end
 
@@ -56,15 +58,13 @@ Run builds, typechecks, lints and tests in the foreground, each with an explicit
 
 ## Principles
 
-1. **Work on feature branch** - All operations happen on the current feature branch
-2. **Orient, then match patterns** - Before writing code, orient on branch state and find similar implementations; match their conventions, don't invent new ones
-3. **Be decisive** - Make confident implementation choices. Don't present alternatives or ask permission for tactical decisions
-4. **Small, focused changes** - Don't scope creep beyond the plan
-5. **Fail honestly** - If blocked, report clearly with what was completed
+1. **Read once** - Never re-read an unchanged file. For a file over 400 lines, or a second look, `grep -n` first, then Read only that range (`offset`, `limit`)
+2. **Small, focused changes** - Don't scope creep beyond the plan
+3. **Fail honestly** - If blocked, report clearly with what was completed
 
-## Output
+- Never print a large file whole; page it with offset and limit, and cap any output you print. Before printing search matches, list or count them.
 
-Return structured completion status:
+## Output
 
 ```markdown
 ## Implementation Report: {TASK_ID}
@@ -100,7 +100,6 @@ Report cap: final message at most about 1,500 tokens; longer material goes to a
 - Switch branches during implementation
 - Push to branches other than your feature branch
 - Merge PRs (orchestrator handles this)
-- Trust handoff summaries without reading actual code
 @end
 
 @export input_core