devflow-kit 3.12.1 → 3.13.0

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

@@ -1,25 +1,26 @@
 /**
- * Prompt-variant installer for the Claude Code target: the curation and compliance switches.
+ * Prompt-variant installer for the Claude Code target: the curation, compliance and tdd switches.
  *
- * D-LEARNING-VARIANT-INSTALL: the install follows the machine's two switches
- * (`features.curation` and `features.compliance` in ~/.devflow/manifest.json) and
- * nothing else. Each command and agent that has an arm for a switch that is off is
+ * D-LEARNING-VARIANT-INSTALL: the install follows the machine's switches
+ * (`features.curation`, `features.compliance` and `features.tdd` in ~/.devflow/manifest.json)
+ * and nothing else. Each command and agent that has an arm for a switch that is off is
  * installed from the build tree of the machine's exact switch combination
- * (dist/{curation-off,compliance-off,curation-compliance-off}/{commands,agents}, built by
- * D-LEARNING-VARIANTS), and the apply-decisions skill is not installed when curation is
- * off, so the decisions text reaches no prompt and the skill has no reader. With a switch on,
+ * (the trees of OFF_OUTPUT_DIRS, such as dist/{curation-off,compliance-off,tdd-off}/{commands,agents},
+ * built by D-LEARNING-VARIANTS), and a skill that an off switch gates is not installed (the
+ * apply-decisions skill with curation off, the test-driven-development skill with tdd off), so
+ * the text reaches no prompt and the skill has no reader. With a switch on,
  * its on files are installed. A compliance-off machine carries no posting step in any prompt
  * that has a compliance arm. Three pieces carry it:
  *
  *   - the source order (src/core/assets.ts commandSourceDirs / agentSourceDirs):
  *     an off combination takes its own tree, and only the all-on combination takes the
  *     normal order, so a host with no arm installs its one file as before;
- *   - the skill condition (CURATION_GATED_SKILLS in src/core/plugins.ts):
- *     installViaFileCopy leaves the skill out when curation is off;
+ *   - the skill condition (AXIS_GATED_SKILLS in src/core/plugins.ts):
+ *     installViaFileCopy leaves out the skills an off switch gates;
  *   - {@link convergeVariantAxes}, below: the one converge that makes an
- *     ALREADY-installed tree match both switches, run by `devflow init` after the
- *     file copy and by `devflow curation` and `devflow compliance` after the switch is
- *     written ({@link applyVariantToggle}).
+ *     ALREADY-installed tree match every switch, run by `devflow init` after the
+ *     file copy and by `devflow curation`, `devflow compliance` and `devflow tdd` after
+ *     the switch is written ({@link applyVariantToggle}).
  *
  * The converge, decided in turn:
  *   - Its roster is the files that exist under the off trees, joined with the hosts the build
@@ -78,18 +79,18 @@
  */
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { agentSourceDirs, bothOffDir, commandSourceDirs, complianceOffDir, curationOffDir, } from '../../core/assets.js';
+import { agentSourceDirs, commandSourceDirs, curationOffDir, variantOffDir, } 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 { ALL_SWITCHES_ON, VARIANT_MANIFEST_REL_PATH, describeVariantManifestParseError, machineVariantKey, parseVariantManifest, variantOffRelPath, } from '../../core/curation-variants.js';
+import { ALL_SWITCHES_ON, OFF_VARIANT_KEYS, VARIANT_AXES, VARIANT_MANIFEST_REL_PATH, describeVariantManifestParseError, machineSwitches, machineVariantKey, offAxesOf, parseVariantManifest, perAxis, sameSwitches, variantOffRelPath, } from '../../core/curation-variants.js';
 import { readInstalledVariants } from '../../core/installed-variants.js';
 import { readManifest, writeManifest } from '../../core/manifest.js';
 import { withManifestLock } from '../../core/manifest-lock.js';
 import { getPackageRoot } from '../../core/paths.js';
 import { isProxyEnabled } from '../../core/proxy-state.js';
 import { WORKFLOW_FOLDERS } from '../../core/mds-variants.js';
-import { DEVFLOW_PLUGINS, CURATION_GATED_SKILLS, installedLanguageFocuses, prefixSkillName, selectedWorkflowFolders, skillsOf, workflowFolderNames, } from '../../core/plugins.js';
+import { DEVFLOW_PLUGINS, AXIS_GATED_SKILLS, installedLanguageFocuses, prefixSkillName, selectedWorkflowFolders, skillsOf, workflowFolderNames, } from '../../core/plugins.js';
 import { convergeFromManifest } from './compliance-install.js';
 import { swapFolderIn } from './folder-swap.js';
 import { copyDirectory, resolveSkillSource } from './installer.js';
@@ -159,11 +160,11 @@ async function readVariantHosts(root) {
 /**
  * The roster of one kind: the prompts that differ on an axis, sorted by file name.
  *
- * The files under the three off trees name them (the build owns which hosts have an arm), and a host the
+ * The files under the off trees name them (the build owns which hosts have an arm), and a host the
  * build manifest lists is added, so a tree removed from the package still leaves its hosts in the roster.
- * An arm comes from the manifest entry, or from the trees the file is in when the manifest does not list it
- * (a curation arm has a file under curation-off or both-off, a compliance arm under compliance-off or
- * both-off).
+ * An arm comes from the manifest entry, or from the trees the file is in when the manifest does not list it:
+ * a file in a tree has an arm on each axis its tree turns off (offAxesOf), so a curation arm has a file under
+ * curation-off or both-off, a compliance arm under compliance-off or both-off, and so on for the other trees.
  *
  * `present` is false when no tree holds this kind and the manifest lists none (the build has not run, or
  * only `build:cli` did), so the caller can say so instead of reporting a converge that had nothing to do.
@@ -173,32 +174,26 @@ async function readVariantHosts(root) {
  * build accepts a wider name), already warned: they are left out of `hosts` and the caller fails closed.
  */
 async function readRoster(kind, root, manifestHosts, warn) {
-    const listings = {
-        curation: await listVariantDir(curationOffDir(kind, root), kind, warn),
-        compliance: await listVariantDir(complianceOffDir(kind, root), kind, warn),
-        both: await listVariantDir(bothOffDir(kind, root), kind, warn),
-    };
+    const listings = new Map();
+    for (const key of OFF_VARIANT_KEYS) {
+        listings.set(key, await listVariantDir(variantOffDir(key, kind, root), kind, warn));
+    }
     const inferred = new Map();
-    const note = (names, axes) => {
+    for (const [key, names] of listings) {
         if (typeof names === 'string')
-            return;
+            continue;
+        const turnedOff = offAxesOf(key);
         for (const name of names) {
-            const arms = inferred.get(name) ?? { curation: false, compliance: false };
-            inferred.set(name, {
-                curation: arms.curation || axes.includes('curation'),
-                compliance: arms.compliance || axes.includes('compliance'),
-            });
+            const arms = inferred.get(name) ?? perAxis(() => false);
+            inferred.set(name, perAxis(axis => arms[axis] || turnedOff.includes(axis)));
         }
-    };
-    note(listings.curation, ['curation']);
-    note(listings.compliance, ['compliance']);
-    note(listings.both, ['curation', 'compliance']);
+    }
     const files = new Map();
     const refused = [];
     for (const [file, axes] of inferred)
         files.set(file, { file, axes });
     for (const [key, host] of manifestHosts ?? []) {
-        if (!key.startsWith(`${kind}/`) || !(host.axes.curation || host.axes.compliance))
+        if (!key.startsWith(`${kind}/`) || !VARIANT_AXES.some(axis => host.axes[axis]))
             continue;
         if (ROSTER_NAME_RE.test(host.file)) {
             files.set(host.file, host);
@@ -209,12 +204,13 @@ async function readRoster(kind, root, manifestHosts, warn) {
         }
     }
     const hosts = [...files.values()].sort((a, b) => (a.file < b.file ? -1 : a.file > b.file ? 1 : 0));
-    const present = hosts.length > 0 || Object.values(listings).some(listing => typeof listing !== 'string');
+    const listed = [...listings.values()];
+    const present = hosts.length > 0 || listed.some(listing => typeof listing !== 'string');
     if (hosts.length > MAX_CURATION_ROSTER) {
         warn(`prompt variants: ${hosts.length} ${kind} variants exceed the bound of ${MAX_CURATION_ROSTER}; converging the first ${MAX_CURATION_ROSTER}`);
         return { hosts: hosts.slice(0, MAX_CURATION_ROSTER), present: true, incomplete: 'truncated', refused };
     }
-    const unreadable = Object.values(listings).some(listing => listing === 'unreadable');
+    const unreadable = listed.some(listing => listing === 'unreadable');
     return { hosts, present, incomplete: unreadable ? 'unreadable' : null, refused };
 }
 async function readIfPresent(file) {
@@ -450,48 +446,54 @@ async function removeSkillFolder(target, backups) {
         }
     }
 }
-/** Converge the curation-gated skill directories. A skill folder that was a link and was swapped is recorded in `links`. Never throws. */
+/**
+ * Converge the gated skill directories of every axis (AXIS_GATED_SKILLS): the state each axis'
+ * skills were left in. An axis that gates no skill is `unchanged`. A skill folder that was a link
+ * and was swapped is recorded in `links`. Never throws.
+ */
 async function convergeSkills(opts, links) {
-    const { claudeDir, devflowDir, curation, plugins, warn } = opts;
+    const { claudeDir, devflowDir, switches, plugins, warn } = opts;
     const selected = skillsOf(plugins);
-    let state = 'unchanged';
+    const states = perAxis(() => 'unchanged');
     // A skills folder that is a link or not a folder is refused once. The removal and the swap below
     // would reach the folder the link points to: `directoryState` of a skill folder follows the link
     // above it. The refusal is recorded in `links`, and the converge is not clean.
     if (await refuseUnrealFolder(links, path.join(claudeDir, 'skills')))
-        return 'failed';
-    // Every gated skill is converged: a failure on one must not skip the next.
-    for (const skill of CURATION_GATED_SKILLS) {
-        const target = path.join(claudeDir, 'skills', prefixSkillName(skill));
-        try {
-            if (!curation) {
-                const removal = await removeSkillFolder(target, opts.backups);
-                if (removal === 'removed') {
-                    state = 'removed';
+        return perAxis(() => 'failed');
+    // Every gated skill of every axis is converged: a failure on one must not skip the next.
+    for (const axis of VARIANT_AXES) {
+        for (const skill of AXIS_GATED_SKILLS[axis]) {
+            const target = path.join(claudeDir, 'skills', prefixSkillName(skill));
+            try {
+                if (!switches[axis]) {
+                    const removal = await removeSkillFolder(target, opts.backups);
+                    if (removal === 'removed') {
+                        states[axis] = 'removed';
+                    }
+                    else if (removal === 'kept') {
+                        warn(`${axis} variants: the ${prefixSkillName(skill)} skill folder (${target}) still holds a file that could not be moved aside, so it was not removed`);
+                        states[axis] = 'failed';
+                    }
+                    continue;
                 }
-                else if (removal === 'kept') {
-                    warn(`curation variants: the ${prefixSkillName(skill)} skill folder (${target}) still holds a file that could not be moved aside, so it was not removed`);
-                    state = 'failed';
+                if (!selected.has(skill)) {
+                    if (states[axis] === 'unchanged')
+                        states[axis] = 'not-selected';
+                    continue;
                 }
-                continue;
+                const resolved = await resolveSkillSource(skill, devflowDir, opts.packageRoot);
+                if ((await pathExists(target)) && (await treesIdentical(resolved.dir, target)))
+                    continue;
+                await swapInSkillDirectory(claudeDir, resolved.dir, target, links, opts.backups);
+                states[axis] = 'installed';
             }
-            if (!selected.has(skill)) {
-                if (state === 'unchanged')
-                    state = 'not-selected';
-                continue;
+            catch (err) {
+                warn(`${axis} variants: could not converge the ${prefixSkillName(skill)} skill (${target}) — ${String(err)}`);
+                states[axis] = 'failed';
             }
-            const resolved = await resolveSkillSource(skill, devflowDir, opts.packageRoot);
-            if ((await pathExists(target)) && (await treesIdentical(resolved.dir, target)))
-                continue;
-            await swapInSkillDirectory(claudeDir, resolved.dir, target, links, opts.backups);
-            state = 'installed';
-        }
-        catch (err) {
-            warn(`curation variants: could not converge the ${prefixSkillName(skill)} skill (${target}) — ${String(err)}`);
-            state = 'failed';
         }
     }
-    return state;
+    return states;
 }
 /** The result of a converge that did not run: nothing changed and, with compliance off, nothing is proven. */
 function notRun(switches, reason) {
@@ -507,7 +509,7 @@ function notRun(switches, reason) {
     };
 }
 /**
- * Make the installed commands and agents match the machine's two switches: the per-kind
+ * Make the installed commands and agents match the machine's switches: the per-kind
  * converge of the prompts.
  *
  * Each roster host is rewritten to the file built for the machine's exact switches (see
@@ -692,17 +694,20 @@ export function workflowFoldersPosting(folders, compliance) {
     return POSTING_CLEAR;
 }
 /**
- * The one converge for both switches: it makes the installed tree match the machine's curation
- * and compliance switches. `devflow init`, `devflow curation` and `devflow compliance` all call it.
+ * The one converge for every switch: it makes the installed tree match the machine's curation,
+ * compliance and tdd switches. `devflow init`, `devflow curation`, `devflow compliance` and
+ * `devflow tdd` all call it.
  *
  * It composes five per-kind converges, each a result and never a throw:
- *   - {@link convergePromptVariants}: the commands and agents, for both axes;
- *   - the apply-decisions skill, which follows the curation switch;
+ *   - {@link convergePromptVariants}: the commands and agents, for every axis;
+ *   - the gated skills: apply-decisions follows the curation switch and test-driven-development
+ *     the tdd switch;
  *   - {@link convergeFromManifest}: the compliance skill and rule, the one place the manifest
  *     becomes compliance options;
  *   - {@link convergeReferences}: the `devflow:git` references, which follow the compliance switch
  *     (the overlay from the one source root of the switch, then the removal list or the restore);
- *   - the workflow skill folders, which follow both switches (the folder of the exact key).
+ *   - the workflow skill folders, which follow the curation and compliance switches (the folder of
+ *     the exact key; a folder has no tdd arm).
  * A failed kind is a warning and `converged: false`, and the next kind still runs. A compliance-off
  * machine that still has a prompt or a reference file that posts, or cannot name one, is `posting`
  * and never `clear`: the caller decides what that costs (the compliance command exits non-zero,
@@ -711,8 +716,7 @@ export function workflowFoldersPosting(folders, compliance) {
  * Never throws.
  */
 export async function convergeVariantAxes(opts) {
-    const { claudeDir, devflowDir, manifest, plugins, warn, packageRoot, backups } = opts;
-    const switches = { curation: manifest.features.curation, compliance: manifest.features.compliance.enabled };
+    const { claudeDir, devflowDir, switches, frameworks, rulesEnabled, plugins, warn, packageRoot, backups } = opts;
     // Precondition, asserted in production code: a relative claudeDir would resolve
     // every install target somewhere unexpected, the skill removal included.
     if (!path.isAbsolute(claudeDir)) {
@@ -720,6 +724,7 @@ export async function convergeVariantAxes(opts) {
         return {
             ...notRun(switches, 'the Claude directory is not an absolute path'),
             skill: 'unchanged',
+            tddSkill: 'unchanged',
             compliance: { removedPreexisting: false, converged: false, replacedLinks: [], refusedFolders: [] },
             references: {
                 converged: false,
@@ -735,9 +740,16 @@ export async function convergeVariantAxes(opts) {
     }
     const prompts = await attempt('prompt variants', warn, notRun(switches, 'the prompt converge failed'), () => convergePromptVariants({ claudeDir, switches, plugins, warn, packageRoot }));
     const skillLinks = newLinkReport();
-    const skill = await attempt('curation variants', warn, 'failed', () => convergeSkills({ claudeDir, devflowDir, curation: switches.curation, plugins, warn, packageRoot, backups }, skillLinks));
+    const skills = await attempt('gated skills', warn, perAxis(() => 'failed'), () => convergeSkills({ claudeDir, devflowDir, switches, plugins, warn, packageRoot, backups }, skillLinks));
+    const { curation: skill, tdd: tddSkill } = skills;
     warnLinkReport(skillLinks, warn);
-    const compliance = await attempt('compliance artifacts', warn, { removedPreexisting: false, converged: false, replacedLinks: [], refusedFolders: [] }, () => convergeFromManifest({ claudeDir, devflowDir, manifest, warn, backups }));
+    const compliance = await attempt('compliance artifacts', warn, { removedPreexisting: false, converged: false, replacedLinks: [], refusedFolders: [] }, () => convergeFromManifest({
+        claudeDir,
+        devflowDir,
+        manifest: { features: { compliance: { enabled: switches.compliance, frameworks }, rules: rulesEnabled } },
+        warn,
+        backups,
+    }));
     const references = await attempt('reference converge', warn, {
         converged: false,
         rewritten: [],
@@ -757,12 +769,17 @@ export async function convergeVariantAxes(opts) {
         backups,
     }));
     return {
-        converged: prompts.converged && skill !== 'failed' && compliance.converged && references.converged && workflowFolders.converged,
+        converged: prompts.converged &&
+            VARIANT_AXES.every(axis => skills[axis] !== 'failed') &&
+            compliance.converged &&
+            references.converged &&
+            workflowFolders.converged,
         commandsRewritten: prompts.commandsRewritten,
         agentsRewritten: prompts.agentsRewritten,
         unchanged: prompts.unchanged,
         notInstalled: prompts.notInstalled,
         skill,
+        tddSkill,
         compliance,
         references,
         workflowFolders,
@@ -819,7 +836,8 @@ export function describeCurationConverge(result, curation) {
 }
 /**
  * One line for what a converge changed on an axis, or null when it changed nothing: the prompts
- * rewritten for the variant the axis now holds and, for curation, the skill it installed or removed.
+ * rewritten for the variant the axis now holds and the gated skills it installed or removed
+ * (apply-decisions with curation, test-driven-development with tdd).
  */
 export function describeVariantConverge(result, axis, enabled) {
     const parts = [];
@@ -828,10 +846,16 @@ export function describeVariantConverge(result, axis, enabled) {
         parts.push(`${result.commandsRewritten.length} command(s) and ${result.agentsRewritten.length} agent(s) ` +
             `rewritten for the ${axis}-${enabled ? 'on' : 'off'} variant`);
     }
-    if (result.skill === 'installed')
-        parts.push('the apply-decisions skill installed');
-    if (result.skill === 'removed')
-        parts.push('the apply-decisions skill removed');
+    const skillStates = [
+        [AXIS_GATED_SKILLS.curation[0], result.skill],
+        [AXIS_GATED_SKILLS.tdd[0], result.tddSkill],
+    ];
+    for (const [skill, state] of skillStates) {
+        if (state === 'installed')
+            parts.push(`the ${skill} skill installed`);
+        if (state === 'removed')
+            parts.push(`the ${skill} skill removed`);
+    }
     const references = result.references;
     if (references !== undefined) {
         const changed = references.rewritten.length + references.restored.length;
@@ -943,7 +967,7 @@ async function recordInstalledVariants(devflowDir, switches, warn) {
             const manifest = await readManifest(devflowDir);
             if (manifest === null)
                 return 'no-manifest';
-            if (manifest.features.curation !== switches.curation || manifest.features.compliance.enabled !== switches.compliance) {
+            if (!sameSwitches(machineSwitches(manifest.features), switches)) {
                 // The record names switches that no longer hold: remove it, so the status reads unknown.
                 if (!Object.hasOwn(manifest, 'installedVariants'))
                     return 'switches-changed';
@@ -954,11 +978,11 @@ async function recordInstalledVariants(devflowDir, switches, warn) {
                 return 'switches-changed';
             }
             const recorded = readInstalledVariants(manifest.installedVariants);
-            if (recorded !== null && recorded.curation === switches.curation && recorded.compliance === switches.compliance)
+            if (recorded !== null && sameSwitches(recorded, switches))
                 return 'current';
             if (!(await lock.stillHeld()))
                 return 'lock-lost';
-            await writeManifest(devflowDir, { ...manifest, installedVariants: { curation: switches.curation, compliance: switches.compliance } });
+            await writeManifest(devflowDir, { ...manifest, installedVariants: perAxis(axis => switches[axis]) });
             return 'written';
         });
         if (!locked.ok || locked.value === 'lock-lost') {
@@ -976,11 +1000,11 @@ async function recordInstalledVariants(devflowDir, switches, warn) {
     }
 }
 /**
- * What `devflow curation --enable/--disable` and `devflow compliance` do after the switch is
- * written: converge the installed tree onto both switches with the one converge, record the
+ * What `devflow curation`, `devflow compliance` and `devflow tdd` do after the switch is
+ * written: converge the installed tree onto every switch with the one converge, record the
  * installed variants when it finished clean, then reapply the saved agent model and effort mapping.
  *
- * The switch of the toggled axis is the value the caller just set. The other axis and the
+ * The switch of the toggled axis is the value the caller just set. The other axes and the
  * compliance frameworks come from the manifest, which the caller has already written.
  *
  * A version skew keeps the check this toggle has always had: the installed prompts are not the
@@ -1005,24 +1029,21 @@ export async function applyVariantToggle(opts) {
     if (skew !== null)
         return { kind: 'skipped', reason: 'version-skew', message: skew };
     const selection = new Set(manifest.plugins);
-    const state = {
-        features: {
-            curation: axis === 'curation' ? enabled : manifest.features.curation,
-            compliance: axis === 'compliance' ? { ...manifest.features.compliance, enabled } : manifest.features.compliance,
-            rules: manifest.features.rules,
-        },
-    };
+    // The toggled axis takes the value the caller just set; every other axis is the manifest's.
+    const switches = { ...machineSwitches(manifest.features), [axis]: enabled };
     const result = await convergeVariantAxes({
         claudeDir,
         devflowDir,
-        manifest: state,
+        switches,
+        frameworks: manifest.features.compliance.frameworks,
+        rulesEnabled: manifest.features.rules,
         plugins: DEVFLOW_PLUGINS.filter(plugin => selection.has(plugin.name)),
         warn,
         packageRoot: opts.packageRoot,
         backups: opts.backups,
     });
     if (result.converged) {
-        await recordInstalledVariants(devflowDir, { curation: state.features.curation, compliance: state.features.compliance.enabled }, warn);
+        await recordInstalledVariants(devflowDir, switches, warn);
     }
     let agentMappingReapplied = false;
     if (result.agentsRewritten.length > 0) {

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

@@ -1,10 +1,10 @@
 import { promises as fs } from 'fs';
 import { existsSync } from 'fs';
 import * as path from 'path';
-import { SKILL_NAMESPACE, WORKFLOW_FOLDER_NAMES, buildAssetMaps, prefixSkillName, unprefixSkillName, getAllSkillNames, getAllAgentNames, getAllCommandNames, FEATURE_OWNED_SKILLS, resolveSkillInstallPlan, omitCurationGatedSkills, selectedWorkflowFolders, workflowFolderNames } from '../../core/plugins.js';
+import { SKILL_NAMESPACE, WORKFLOW_FOLDER_NAMES, buildAssetMaps, prefixSkillName, unprefixSkillName, getAllSkillNames, getAllAgentNames, getAllCommandNames, FEATURE_OWNED_SKILLS, resolveSkillInstallPlan, omitGatedSkills, selectedWorkflowFolders, workflowFolderNames } from '../../core/plugins.js';
 import { skillsDir, agentSourceDirs, rulesDir, commandSourceDirs, scriptsDir, compiledSkillRefsDir, skillRefsSourceDir } from '../../core/assets.js';
 import { getPackageRoot, isContainedIn } from '../../core/paths.js';
-import { ALL_SWITCHES_ON, VARIANT_MANIFEST_REL_PATH, describeVariantManifestParseError, parseVariantManifest, requiredComplianceVariantFiles, } from '../../core/curation-variants.js';
+import { ALL_SWITCHES_ON, VARIANT_AXES, VARIANT_MANIFEST_REL_PATH, describeVariantManifestParseError, parseVariantManifest, requiredComplianceVariantFiles, } from '../../core/curation-variants.js';
 import { sweepOrphanedAssets, mdFileName, mdEntryName } from '../../core/orphan-sweep.js';
 import { generatedReferenceManifest, installedReferenceManifest, PR_HOST_DESTINATION_ROOT, SKILL_REFS_SKILL_NAME, TRACKER_DESTINATION_ROOT, WORKFLOW_FOLDERS } from '../../core/mds-variants.js';
 import { sweepOrphanedReferences, MAX_REFERENCE_SWEEP_DEPTH } from '../../core/reference-sweep.js';
@@ -1404,7 +1404,7 @@ async function writeStampedAgent(srcFile, target, servers, warn) {
 }
 /**
  * D-EXPLORE-NO-CLOBBER, install half: true when `agentName` takes over a built-in
- * agent type (Explore) and the user already owns an agent of that type under
+ * agent type (Explore, Plan) and the user already owns an agent of that type under
  * `{claudeDir}/agents`, so devflow's copy must not be installed.
  *
  * The user's file is only ever read. A copy of devflow's own left by an earlier install
@@ -1708,10 +1708,10 @@ function namedVariantFiles(items) {
  * An injected agent list wins as given.
  */
 function copySourceDirs(opts) {
-    const { curation, compliance, packageRoot } = opts;
+    const { switches, packageRoot } = opts;
     return {
-        commands: commandSourceDirs({ curation, compliance }, packageRoot),
-        agents: opts.agentSourceDirs ?? agentSourceDirs(packageRoot, { curation, compliance }),
+        commands: commandSourceDirs(switches, packageRoot),
+        agents: opts.agentSourceDirs ?? agentSourceDirs(packageRoot, switches),
     };
 }
 /**
@@ -1737,8 +1737,8 @@ function copySourceDirs(opts) {
  * naming the build step. Only the file reads, so it leaves no partial install behind.
  */
 async function requireComplianceVariantFiles(opts) {
-    const { curation, compliance, packageRoot } = opts;
-    if (compliance)
+    const { switches, packageRoot } = opts;
+    if (switches.compliance)
         return;
     const manifestFile = path.join(packageRoot, ...VARIANT_MANIFEST_REL_PATH.split('/'));
     const remedy = `Run \`npm run build:mds\` to regenerate ${VARIANT_MANIFEST_REL_PATH} and the variant trees before install ` +
@@ -1757,12 +1757,12 @@ async function requireComplianceVariantFiles(opts) {
         throw new Error(`Variant manifest is not valid: ${manifestFile} (${describeVariantManifestParseError(parsed.error)}). ` +
             `No file was written. ${remedy}`);
     }
-    const sourceDirs = copySourceDirs({ curation, compliance, packageRoot, agentSourceDirs: opts.agentSourceDirs });
-    const machine = `curation ${curation ? 'on' : 'off'} and compliance off`;
+    const sourceDirs = copySourceDirs({ switches, packageRoot, agentSourceDirs: opts.agentSourceDirs });
+    const machine = VARIANT_AXES.map(axis => `${axis} ${switches[axis] ? 'on' : 'off'}`).join(', ');
     const missing = [];
     const shadowed = [];
     for (const host of parsed.value) {
-        const [rel] = requiredComplianceVariantFiles({ curation, compliance }, [host]);
+        const [rel] = requiredComplianceVariantFiles(switches, [host]);
         if (rel === undefined)
             continue;
         const required = path.join(packageRoot, ...rel.split('/'));
@@ -1821,15 +1821,14 @@ async function requireComplianceVariantFiles(opts) {
  * known and leaves it alone.
  */
 export async function installCommandsAndAgents(opts) {
-    const { plugins, agentsMap, claudeDir, curation, compliance, trackerServers, warn } = opts;
+    const { plugins, agentsMap, claudeDir, switches, trackerServers, warn } = opts;
     const skip = opts.skip ?? {};
     const packageRoot = opts.packageRoot ?? getPackageRoot();
     // Before the first write. installViaFileCopy checks earlier still, ahead of its pre-clean;
     // this call covers the caller that reaches the copy alone (the selective uninstall).
-    await requireComplianceVariantFiles({ curation, compliance, packageRoot, agentSourceDirs: opts.agentSourceDirs });
+    await requireComplianceVariantFiles({ switches, packageRoot, agentSourceDirs: opts.agentSourceDirs });
     const { commands: commandDirs, agents: agentDirs } = copySourceDirs({
-        curation,
-        compliance,
+        switches,
         packageRoot,
         agentSourceDirs: opts.agentSourceDirs,
     });
@@ -1902,20 +1901,19 @@ 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, curation, compliance, trackerServers = TRACKER_MCP_SERVERS_DEFAULT, warn = () => { }, backups, } = options;
+    const { plugins, claudeDir, devflowDir, skillsMap, agentsMap, rulesMap = new Map(), isPartialInstall, spinner, switches, trackerServers = TRACKER_MCP_SERVERS_DEFAULT, warn = () => { }, backups, } = options;
     const packageRoot = options.packageRoot ?? getPackageRoot();
     // D-WORKFLOW-FOLDER-INSTALL: the workflows that ship as skill folders. The default registry is
     // empty, and with it every folder step below is a no-op over an empty set.
     const folderRegistry = options.workflowFolders ?? WORKFLOW_FOLDERS;
     const folderWorkflows = workflowFolderNames(folderRegistry);
-    const folderSwitches = { curation, compliance };
     const folderFiles = new Map();
     /** The files of one registered folder, read once. A failed read is a reason and never a throw. */
     const readFolder = async (folder) => {
         const cached = folderFiles.get(folder.name);
         if (cached !== undefined)
             return { ok: true, files: cached };
-        const read = await readWorkflowFolder(folder, folderSwitches, options.workflowFoldersRoot ?? packageRoot);
+        const read = await readWorkflowFolder(folder, switches, options.workflowFoldersRoot ?? packageRoot);
         if (read.ok)
             folderFiles.set(folder.name, read.files);
         return read;
@@ -1931,7 +1929,7 @@ export async function installViaFileCopy(options) {
     };
     // The compliance-off refusal comes first, ahead of the pre-clean below: a refused install
     // must leave the installed tree as it found it.
-    await requireComplianceVariantFiles({ curation, compliance, packageRoot, agentSourceDirs: options.agentSourceDirs });
+    await requireComplianceVariantFiles({ switches, packageRoot, agentSourceDirs: options.agentSourceDirs });
     // The folders this run installs are read from the exact-key tree before the pre-clean for the
     // same reason, so a build that lacks one refuses the install and leaves the installed tree alone.
     await readFolders(selectedWorkflowFolders(plugins, folderWorkflows));
@@ -1939,9 +1937,9 @@ export async function installViaFileCopy(options) {
     // root they are overlaid from. With compliance off the root is the compliance-off tree, and its
     // absence refuses the install here, before the pre-clean, so a refused install leaves the
     // installed tree as it found it and never falls through to the compliance-on references (AC-50).
-    const refsManifest = installedReferenceManifest({ compliance });
-    const refsSourceRoot = skillRefsSourceDir(compliance, packageRoot);
-    if (omitCurationGatedSkills(skillsMap, curation).has(SKILL_REFS_SKILL_NAME)) {
+    const refsManifest = installedReferenceManifest({ compliance: switches.compliance });
+    const refsSourceRoot = skillRefsSourceDir(switches.compliance, packageRoot);
+    if (omitGatedSkills(skillsMap, switches).has(SKILL_REFS_SKILL_NAME)) {
         await requireGeneratedTree(refsSourceRoot, refsManifest);
     }
     const report = {
@@ -2203,8 +2201,7 @@ export async function installViaFileCopy(options) {
         plugins: commandAgentPlugins,
         agentsMap: commandAgentMap,
         claudeDir,
-        curation,
-        compliance,
+        switches,
         packageRoot,
         trackerServers,
         agentSourceDirs: options.agentSourceDirs,
@@ -2240,15 +2237,15 @@ 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 curation-off machine skips the curation-gated
-    // skills here. The pre-clean above walked the UNFILTERED map, so on a full
+    // D-LEARNING-VARIANT-INSTALL: a machine with an axis off skips the skills that axis
+    // gates here (omitGatedSkills). 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
     // convergeVariantAxes, which init runs straight after this call.
     //
     // A refused skills root (a link or not a folder) gets no skill: every copy, and the overlay
     // below it, would write into the folder the link points to.
     spinner.message('Installing skills...');
-    const skillsToInstall = skillsRefused ? [] : [...omitCurationGatedSkills(skillsMap, curation).keys()];
+    const skillsToInstall = skillsRefused ? [] : [...omitGatedSkills(skillsMap, switches).keys()];
     for (const skillName of skillsToInstall) {
         const skillTarget = path.join(claudeDir, 'skills', prefixSkillName(skillName));
         // A full install's pre-clean replaced a link at the skill or its references entry. A partial
@@ -2272,7 +2269,7 @@ export async function installViaFileCopy(options) {
         // on the machine, even when the install stops or a removal is refused later. With compliance on
         // nothing is excluded.
         const resolved = await resolveSkillSource(skillName, devflowDir);
-        await copyDirectory(resolved.dir, skillTarget, compliance ? undefined : complianceOffCopyExclusions(skillName, resolved.dir), report);
+        await copyDirectory(resolved.dir, skillTarget, switches.compliance ? undefined : complianceOffCopyExclusions(skillName, resolved.dir), report);
         if (resolved.shadow === 'valid') {
             report.shadowedSkills.push(skillName);
         }
@@ -2309,7 +2306,7 @@ export async function installViaFileCopy(options) {
     // install copies over without clearing. A removal that was refused is a reported failure and
     // never an abort; the compliance converge that init runs next fails closed on the same files.
     // A refused skills root is not entered: the removal would reach files in the folder a link points to.
-    if (!compliance && !skillsRefused) {
+    if (!switches.compliance && !skillsRefused) {
         const removal = await removeComplianceOffFiles(path.join(claudeDir, 'skills'));
         for (const refusal of removal.refused) {
             report.sweepFailures.push({ kind: 'reference', name: refusal.entry, error: refusal.reason });

package/dist/targets/claude-code/shipped-set.js

@@ -24,8 +24,7 @@ import * as path from 'path';
 import { skillsDir } from '../../core/assets.js';
 import { complianceSkillFiles } from '../../core/compliance.js';
 import { COMPLIANCE_OFF_REMOVED_SKILL_FILES } from '../../core/compliance-off-files.js';
-import { VARIANT_KEYS } from '../../core/curation-variants.js';
-import { SKILL_REFS_SKILL_NAME, installedReferenceManifest, workflowFolderFiles, } from '../../core/mds-variants.js';
+import { FOLDER_VARIANT_KEYS, SKILL_REFS_SKILL_NAME, installedReferenceManifest, workflowFolderFiles, } from '../../core/mds-variants.js';
 import { createPathSet } from '../../core/path-set.js';
 import { FEATURE_OWNED_RULES, getAllAgentNames, getAllCommandNames, getAllRuleNames, getAllSkillNames, prefixSkillName, } from '../../core/plugins.js';
 import { validateSkillShadow } from './installer.js';
@@ -69,7 +68,7 @@ export function shippedPaths(inputs) {
     for (const file of complianceSkillFiles())
         paths.add(skillPath('compliance', file));
     for (const folder of inputs.workflowFolders) {
-        for (const key of VARIANT_KEYS) {
+        for (const key of FOLDER_VARIANT_KEYS) {
             for (const file of workflowFolderFiles(folder, key))
                 paths.add(skillPath(folder.name, file));
         }