devflow-kit 3.12.1 → 3.13.0

package/dist/core/assets.js

@@ -1,7 +1,7 @@
 import { join } from 'path';
 import { getPackageRoot } from './paths.js';
 import { COMPLIANCE_OFF_SKILL_REFS_OUTPUT_DIR, SKILL_REFS_OUTPUT_DIR, workflowFolderKey, workflowFoldersRootRelPath, } from './mds-variants.js';
-import { ALL_SWITCHES_ON, BOTH_OFF_OUTPUT_DIR, COMPLIANCE_OFF_OUTPUT_DIR, CURATION_OFF_OUTPUT_DIR, } from './curation-variants.js';
+import { ALL_SWITCHES_ON, OFF_OUTPUT_DIRS, consultedOffKeys, } from './curation-variants.js';
 /**
  * Flat skills source directory: src/assets/skills/{name}/
  * All plugins' skills live here directly (no per-plugin subdirectory).
@@ -47,6 +47,20 @@ export function scriptsDir() {
 export function commandsDir() {
     return join(getPackageRoot(), 'dist', 'commands');
 }
+/**
+ * The variant directory of one off key: <the key's tree>/{commands,agents}/
+ *
+ * The spelling comes from OFF_OUTPUT_DIRS in curation-variants.ts, the build's own
+ * destinations, rather than being retyped here. Absent until the build has run, so every
+ * reader tolerates its absence.
+ *
+ * @param key - The off variant key.
+ * @param kind - Which prompt kind's variants.
+ * @param root - Package root to resolve against (see agentsDir).
+ */
+export function variantOffDir(key, kind, root = getPackageRoot()) {
+    return join(root, ...OFF_OUTPUT_DIRS[key].split('/'), kind);
+}
 /**
  * Curation-off variant directory: dist/curation-off/{commands,agents}/
  *
@@ -54,14 +68,11 @@ export function commandsDir() {
  * (D-LEARNING-VARIANTS), and only those. Absent until the build has run, so every
  * reader tolerates its absence.
  *
- * The spelling comes from CURATION_OFF_OUTPUT_DIR in curation-variants.ts, the
- * build's own destination, rather than being retyped here.
- *
  * @param kind - Which prompt kind's variants.
  * @param root - Package root to resolve against (see agentsDir).
  */
 export function curationOffDir(kind, root = getPackageRoot()) {
-    return join(root, ...CURATION_OFF_OUTPUT_DIR.split('/'), kind);
+    return variantOffDir('curation-off', kind, root);
 }
 /**
  * Compliance-off variant directory: dist/compliance-off/{commands,agents}/
@@ -75,7 +86,7 @@ export function curationOffDir(kind, root = getPackageRoot()) {
  * @param root - Package root to resolve against (see agentsDir).
  */
 export function complianceOffDir(kind, root = getPackageRoot()) {
-    return join(root, ...COMPLIANCE_OFF_OUTPUT_DIR.split('/'), kind);
+    return variantOffDir('compliance-off', kind, root);
 }
 /**
  * Both-off variant directory: dist/curation-compliance-off/{commands,agents}/
@@ -87,28 +98,23 @@ export function complianceOffDir(kind, root = getPackageRoot()) {
  * @param root - Package root to resolve against (see agentsDir).
  */
 export function bothOffDir(kind, root = getPackageRoot()) {
-    return join(root, ...BOTH_OFF_OUTPUT_DIR.split('/'), kind);
+    return variantOffDir('both-off', kind, root);
 }
 /**
  * The off-variant directories of one kind that a machine with these switches consults,
- * MOST-PREFERRED FIRST. Empty when both switches are on.
- *
- * The one place the two-axis order is spelled; commandSourceDirs and agentSourceDirs
- * both take it from here. A both-off machine consults the both-off tree first, then the
- * two single-axis trees. This order does not decide which file a compliance-armed host
- * must have. The installer requires the file built for the machine's exact switches, so
- * on a both-off machine a host with both arms needs its both-off file and never its
- * curation-off file.
- */
-function offVariantDirs(kind, { curation, compliance }, root) {
-    if (!curation && !compliance) {
-        return [bothOffDir(kind, root), curationOffDir(kind, root), complianceOffDir(kind, root)];
-    }
-    if (!compliance)
-        return [complianceOffDir(kind, root)];
-    if (!curation)
-        return [curationOffDir(kind, root)];
-    return [];
+ * MOST-PREFERRED FIRST. Empty when every switch is on.
+ *
+ * The one place the order is spelled; commandSourceDirs and agentSourceDirs both take it
+ * from here. It is generated from the variant table (consultedOffKeys): every off tree
+ * whose axes are all off on the machine, the tree with the most axes off first. The first
+ * tree that holds a host's file is therefore the file for the machine's off axes that the
+ * host carries an arm on. A machine with one switch off consults one tree. This order does
+ * not decide which file a compliance-armed host must have. The installer requires the
+ * file built for the machine's exact switches, so on a both-off machine a host with both
+ * arms needs its both-off file and never its curation-off file.
+ */
+function offVariantDirs(kind, switches, root) {
+    return consultedOffKeys(switches).map(key => variantOffDir(key, kind, root));
 }
 /**
  * Prepend the off-variant directories to the normal lookup, keeping the list non-empty
@@ -122,10 +128,10 @@ function preferOff(off, normal) {
  *
  * D-LEARNING-VARIANT-INSTALL: with an axis off, the off-variant directories come
  * first, so a host with an arm installs its off variant and a host with none falls
- * through to the one compiled file. With both axes on the order is the normal
+ * through to the one compiled file. With every axis on the order is the normal
  * single-directory lookup.
  *
- * @param switches - The machine's settled curation and compliance switches.
+ * @param switches - The machine's settled switches (one per axis).
  * @param root - Package root to resolve against (see agentsDir).
  */
 export function commandSourceDirs(switches, root = getPackageRoot()) {
@@ -203,14 +209,15 @@ export function compiledWorkflowFoldersDir(key, root = getPackageRoot()) {
 /**
  * The workflow folders source root for a machine's switches: the tree built for exactly
  * those switches. One function, so the install, the converge and the status read cannot
- * pick different roots for one pair of switches.
+ * pick different roots for one set of switches.
  *
  * D-WORKFLOW-FOLDER-BUILD: a SINGLE root, never a preference list. A folder is complete
- * under every key, so no reader merges two trees, and a both-off machine never falls
- * through to a tree that still carries the text of an axis it switched off (the failure
- * commandSourceDirs' consumers guard against with an exact-key check).
+ * under every key it is built under (FOLDER_VARIANT_KEYS), so no reader merges two trees,
+ * and a both-off machine never falls through to a tree that still carries the text of an
+ * axis it switched off (the failure commandSourceDirs' consumers guard against with an
+ * exact-key check). A folder has no tdd arm, so the tdd switch does not pick a root.
  *
- * @param switches - The machine's settled curation and compliance switches.
+ * @param switches - The machine's settled switches (one per axis).
  * @param root - Package root to resolve against (see agentsDir).
  */
 export function workflowFoldersSourceDir(switches, root = getPackageRoot()) {
@@ -241,7 +248,7 @@ export function workflowFoldersSourceDir(switches, root = getPackageRoot()) {
  * reading the both-on tree.
  *
  * @param root - Package root to resolve against (see agentsDir).
- * @param switches - The machine's settled curation and compliance switches; every switch on by default.
+ * @param switches - The machine's settled switches (one per axis); every switch on by default.
  */
 export function agentSourceDirs(root = getPackageRoot(), switches = ALL_SWITCHES_ON) {
     return preferOff(offVariantDirs('agents', switches, root), [compiledAgentsDir(root), agentsDir(root)]);

package/dist/core/curation-variants.js

@@ -1,6 +1,6 @@
 /**
- * Variant splitter: one compiled prompt body in, its variants out, on two marker
- * axes: curation and compliance.
+ * Variant splitter: one compiled prompt body in, its variants out, on the marker
+ * axes: curation, compliance and tdd.
  *
  * Pure module, zero I/O. Every refusal is a Result; the exiting shells are
  * scripts/build-mds.ts, which renders the split errors into the build's single exit,
@@ -12,11 +12,15 @@
  * the curation-on variant at today's path (dist/commands/x.md, dist/agents/x.md)
  * and the curation-off variant at dist/curation-off/{commands,agents}/x.md, only
  * for a host that has an arm. A prompt with no arm has one variant and no
- * curation-off file. The compliance axis works the same way: a body is split on
- * both axes into four variants, keyed `on`, `curation-off`, `compliance-off` and
- * `both-off`, and the build writes a variant only for a host that has an arm on
- * each axis that variant turns off. The off variants go to dist/curation-off/,
- * dist/compliance-off/ and dist/curation-compliance-off/, and the manifest
+ * curation-off file. The other axes work the same way: a body is split on every
+ * axis into one variant per combination of axes turned off (VARIANT_KEYS: `on`,
+ * `curation-off`, `compliance-off` and `both-off` for curation and compliance, and
+ * `tdd-off`, `curation-tdd-off`, `compliance-tdd-off` and `curation-compliance-tdd-off`
+ * for the same four with tdd off), and the build writes a variant only for a host
+ * that has an arm on each axis that variant turns off. The off variants go to the
+ * trees of OFF_OUTPUT_DIRS (dist/curation-off/, dist/compliance-off/,
+ * dist/curation-compliance-off/, dist/tdd-off/, dist/curation-tdd-off/,
+ * dist/compliance-tdd-off/ and dist/curation-compliance-tdd-off/), and the manifest
  * dist/variant-axes.json records which axes each host carries an arm on. The install
  * order of the trees per machine is owned by src/core/assets.ts, and the install refusal
  * for a compliance-off machine by src/targets/claude-code/installer.ts.
@@ -30,7 +34,8 @@
  *   <!-- curation:end -->    closes the arm
  *
  * and `<!-- compliance:on -->`, `<!-- compliance:off -->` and
- * `<!-- compliance:end -->` do the same for the compliance variants.
+ * `<!-- compliance:end -->` do the same for the compliance variants, and
+ * `<!-- tdd:on -->`, `<!-- tdd:off -->` and `<!-- tdd:end -->` for the tdd variants.
  *
  * A marker line matches VARIANT_MARKER_RE. It may be indented and may sit inside
  * a fenced block, a list, a define body or an agent's second frontmatter block,
@@ -43,9 +48,10 @@
  * A line goes into a variant only when every arm open at that line matches the
  * variant, so a body with no compliance marker splits on the curation axis to the
  * same bytes it always did, and the compliance state of the variant changes nothing.
+ * The same holds for a body with no tdd marker.
  *
- * One axis may nest fully inside an arm of the other. Two arms of one axis never
- * nest, and arms of two axes never overlap: at most one arm per axis is open, and
+ * One axis may nest fully inside an arm of another. Two arms of one axis never
+ * nest, and arms of different axes never overlap: at most one arm per axis is open, and
  * the arm opened last is the one that closes first.
  *
  * The markers are INTERIM. MDS 0.4.4 emits an `@if` inside a code fence or on an
@@ -56,31 +62,33 @@
  * @mdscript/mds upgrade it rides on proven byte-identical in dist/ and this module
  * deleted, is dean0x/devflow#439; the compliance axis rides the same swap
  * (dean0x/devflow#648). The mapping is one to one, per axis: `<!-- curation:on -->`
- * becomes `@if curation:` and `<!-- compliance:on -->` becomes `@if compliance:`,
+ * becomes `@if curation:`, `<!-- compliance:on -->` becomes `@if compliance:` and
+ * `<!-- tdd:on -->` becomes `@if tdd:`,
  * `off` becomes `@else:` and `end` becomes `@end`. A standalone `off` arm, with no
  * on arm before it, becomes an `@if <axis>:` with an empty body followed by
- * `@else:`. One axis nested inside the other becomes one `@if` inside the other,
+ * `@else:`. One axis nested inside another becomes one `@if` inside the other,
  * and an interleaving, which no `@if` nesting expresses, is a refusal here.
  *
  * What the splitter refuses, each as a VariantSplitError with the source line:
  *   - nesting: an `on` marker while an arm of its axis is open, or a second `off`
  *     in one arm;
- *   - an interleaving: an `off` or `end` marker for an arm while an arm of the other
+ *   - an interleaving: an `off` or `end` marker for an arm while an arm of another
  *     axis, opened after it, is still open;
  *   - an `end` with no open arm of its axis;
  *   - an arm still open at the end of the body;
  *   - an empty arm (no line with content between its marker and the next);
  *   - a retired marker: a line that names the pre-rename spelling of the marker, in
  *     any spacing or case, which would otherwise ship as prompt text;
- *   - a stray marker: a line that names `<!-- curation:` or `<!-- compliance:` but
- *     is not a whole-line marker, which would otherwise ship as prompt text.
+ *   - a stray marker: a line that names `<!-- curation:`, `<!-- compliance:` or
+ *     `<!-- tdd:` but is not a whole-line marker, which would otherwise ship as
+ *     prompt text.
  *
  * The retired spelling is never accepted as an alias: the build fails on it, so a
  * host that still carries it cannot ship a prompt with both variants silently equal.
  *
  * Scope guarantee: this module answers one question (what are the variants of this
  * body, and where do they land?) and a cheap one per axis for the build to ask of a
- * body that must carry no arms (containsCurationMarker, containsComplianceMarker). It
+ * body that must carry no arms (containsAxisMarker). It
  * also renders the variant manifest the build writes beside the trees
  * (renderVariantManifest) and parses it for the installer (parseVariantManifest), so the
  * build and the installer share one layout. It decides
@@ -115,6 +123,19 @@ export const COMPLIANCE_OFF_OUTPUT_DIR = 'dist/compliance-off';
  * tree cannot reach the files of another.
  */
 export const BOTH_OFF_OUTPUT_DIR = 'dist/curation-compliance-off';
+/**
+ * Repo-relative root of the tdd-off variants: tdd off, curation and compliance on.
+ *
+ * The three trees below are the same three off combinations of curation and compliance
+ * with tdd off as well. All are siblings under dist/, none inside another.
+ */
+export const TDD_OFF_OUTPUT_DIR = 'dist/tdd-off';
+/** Repo-relative root of the variants with curation and tdd off, compliance on. */
+export const CURATION_TDD_OFF_OUTPUT_DIR = 'dist/curation-tdd-off';
+/** Repo-relative root of the variants with compliance and tdd off, curation on. */
+export const COMPLIANCE_TDD_OFF_OUTPUT_DIR = 'dist/compliance-tdd-off';
+/** Repo-relative root of the variants with every axis off: curation, compliance and tdd. */
+export const ALL_OFF_OUTPUT_DIR = 'dist/curation-compliance-tdd-off';
 /**
  * Repo-relative root of the retired off tree, from before the rename.
  *
@@ -132,6 +153,10 @@ export const OFF_OUTPUT_DIRS = {
     'curation-off': CURATION_OFF_OUTPUT_DIR,
     'compliance-off': COMPLIANCE_OFF_OUTPUT_DIR,
     'both-off': BOTH_OFF_OUTPUT_DIR,
+    'tdd-off': TDD_OFF_OUTPUT_DIR,
+    'curation-tdd-off': CURATION_TDD_OFF_OUTPUT_DIR,
+    'compliance-tdd-off': COMPLIANCE_TDD_OFF_OUTPUT_DIR,
+    'curation-compliance-tdd-off': ALL_OFF_OUTPUT_DIR,
 };
 /**
  * POSIX repo-relative path of an off variant of an output file: the kind's folder
@@ -146,44 +171,85 @@ export function variantOffRelPath(key, kind, fileName) {
 // ---------------------------------------------------------------------------
 // Markers
 // ---------------------------------------------------------------------------
-/** The two marker axes. Curation is listed first: it is the older axis and the first one a stray line is tested against. */
-export const VARIANT_AXES = ['curation', 'compliance'];
+/**
+ * The marker axes. Curation is listed first: it is the older axis and the first one a stray line is tested against.
+ *
+ * The per-axis records below are built from this list. A new axis also needs its own entries in
+ * VARIANT_KEYS and VARIANT_STATES (every combination), the off-tree constants and OFF_OUTPUT_DIRS,
+ * PRUNE_REASONS, MachineSwitchFeatures with machineSwitches, and FOLDER_ARMS. The type checker
+ * flags a missing per-axis record. A missing VARIANT_KEYS combination it does not flag: the table
+ * test over `2 ** VARIANT_AXES.length` rows pins that VARIANT_KEYS covers every combination.
+ */
+export const VARIANT_AXES = ['curation', 'compliance', 'tdd'];
+/** A record with one entry per member of `keys`, built by `valueOf`. The one place a total record is cast from a loop. */
+export function recordOf(keys, valueOf) {
+    const record = {};
+    for (const key of keys)
+        record[key] = valueOf(key);
+    return record;
+}
+/** A record with one entry per axis, built by `valueOf`. */
+export function perAxis(valueOf) {
+    return recordOf(VARIANT_AXES, valueOf);
+}
 /** Every switch on: the machine whose prompts come from the normal compiled files. */
-export const ALL_SWITCHES_ON = Object.freeze({ curation: true, compliance: true });
+export const ALL_SWITCHES_ON = Object.freeze(perAxis(() => true));
+/** True when two switch records agree on every axis. */
+export function sameSwitches(a, b) {
+    return VARIANT_AXES.every(axis => a[axis] === b[axis]);
+}
 /**
- * A whole-line marker of either axis. Group 1 captures the axis; group 2 captures
+ * The machine's settled switch on each axis, from its features.
+ *
+ * The ONE place the switches are built from the machine state. Every consumer takes the
+ * returned value whole (the installer, the converge, the folders, the install record) and
+ * never spells a switch per axis, so a new axis changes this function and the
+ * VariantSwitches type and no call site.
+ */
+export function machineSwitches(features) {
+    return { curation: features.curation, compliance: features.compliance.enabled, tdd: features.tdd };
+}
+/**
+ * A whole-line marker of any axis. Group 1 captures the axis; group 2 captures
  * `on`, `off` or `end`.
  *
  * Anchored at both ends with no nested quantifier, so a match is linear in the
  * line length. Leading and trailing space or tab is allowed; anything else on the
- * line is not a marker.
+ * line is not a marker. The axis names are fixed words, never input.
  */
-export const VARIANT_MARKER_RE = /^[ \t]*<!-- (curation|compliance):(on|off|end) -->[ \t]*$/;
+export const VARIANT_MARKER_RE = new RegExp(`^[ \\t]*<!-- (${VARIANT_AXES.join('|')}):(on|off|end) -->[ \\t]*$`);
 /**
  * The fragment that makes a line a marker ATTEMPT on one axis: loose on spacing and
  * case so a malformed marker is caught rather than shipped. Every valid marker of
  * the axis contains it. None is global, so `test` keeps no state between lines.
  */
-const MARKER_FRAGMENT_RES = {
-    curation: /<!--\s*curation\s*:/i,
-    compliance: /<!--\s*compliance\s*:/i,
-};
+const MARKER_FRAGMENT_RES = perAxis(axis => new RegExp(`<!--\\s*${axis}\\s*:`, 'i'));
 /**
  * The same attempt test for the retired spelling of the marker. No spelling of it is
  * valid, so a line that matches is always refused.
  */
 const LEGACY_MARKER_FRAGMENT_RE = /<!--\s*learning\s*:/i;
+/** The axis the retired spelling belonged to. */
+const LEGACY_MARKER_AXIS = 'curation';
+/** True when the text names a marker of the axis anywhere, valid or not; for curation also the retired spelling. */
+export function containsAxisMarker(axis, text) {
+    return MARKER_FRAGMENT_RES[axis].test(text) || (axis === LEGACY_MARKER_AXIS && LEGACY_MARKER_FRAGMENT_RE.test(text));
+}
 /** True when the text names a curation marker anywhere, in the current or the retired spelling, valid or not. */
 export function containsCurationMarker(text) {
-    return MARKER_FRAGMENT_RES.curation.test(text) || LEGACY_MARKER_FRAGMENT_RE.test(text);
+    return containsAxisMarker('curation', text);
 }
 /** True when the text names a compliance marker anywhere, valid or not. */
 export function containsComplianceMarker(text) {
-    return MARKER_FRAGMENT_RES.compliance.test(text);
+    return containsAxisMarker('compliance', text);
 }
-/** True when the text names a marker of either axis, or the retired spelling, valid or not. */
+/** True when the text names a tdd marker anywhere, valid or not. */
+export function containsTddMarker(text) {
+    return containsAxisMarker('tdd', text);
+}
+/** True when the text names a marker of any axis, or the retired spelling, valid or not. */
 export function containsVariantMarker(text) {
-    return containsCurationMarker(text) || containsComplianceMarker(text);
+    return VARIANT_AXES.some(axis => containsAxisMarker(axis, text));
 }
 function markerOf(line) {
     // A CRLF body carries the carriage return on the line; it is not part of the marker.
@@ -199,34 +265,65 @@ function attemptedAxisOf(line) {
     }
     return null;
 }
-/** The four variants of a body, named by the axes they turn off. */
-export const VARIANT_KEYS = ['on', 'curation-off', 'compliance-off', 'both-off'];
+/**
+ * The variants of a body, one per combination of axes turned off, named by the axes
+ * they turn off. The four that keep tdd on come first and keep the names and trees
+ * they had before the tdd axis; the four that turn tdd off follow.
+ */
+export const VARIANT_KEYS = [
+    'on',
+    'curation-off',
+    'compliance-off',
+    'both-off',
+    'tdd-off',
+    'curation-tdd-off',
+    'compliance-tdd-off',
+    'curation-compliance-tdd-off',
+];
 /** Every variant that turns an axis off, in VARIANT_KEYS order. */
 export const OFF_VARIANT_KEYS = VARIANT_KEYS.filter((key) => key !== 'on');
-/** The arm each axis keeps in each variant. */
+/** The arm each axis keeps in each variant. Total over VARIANT_KEYS, with one row per combination of axes. */
 const VARIANT_STATES = {
-    on: { curation: 'on', compliance: 'on' },
-    'curation-off': { curation: 'off', compliance: 'on' },
-    'compliance-off': { curation: 'on', compliance: 'off' },
-    'both-off': { curation: 'off', compliance: 'off' },
+    on: { curation: 'on', compliance: 'on', tdd: 'on' },
+    'curation-off': { curation: 'off', compliance: 'on', tdd: 'on' },
+    'compliance-off': { curation: 'on', compliance: 'off', tdd: 'on' },
+    'both-off': { curation: 'off', compliance: 'off', tdd: 'on' },
+    'tdd-off': { curation: 'on', compliance: 'on', tdd: 'off' },
+    'curation-tdd-off': { curation: 'off', compliance: 'on', tdd: 'off' },
+    'compliance-tdd-off': { curation: 'on', compliance: 'off', tdd: 'off' },
+    'curation-compliance-tdd-off': { curation: 'off', compliance: 'off', tdd: 'off' },
 };
+/** The arm an axis keeps in a variant. */
+export function variantArm(key, axis) {
+    return VARIANT_STATES[key][axis];
+}
+/** The axes a variant turns off, in VARIANT_AXES order. Empty for `on`. */
+export function offAxesOf(key) {
+    return VARIANT_AXES.filter(axis => VARIANT_STATES[key][axis] === 'off');
+}
 /**
- * The variants the build writes for a body, `on` first.
+ * The off variants a machine with these switches can read, MOST-PREFERRED FIRST: every
+ * off key whose off axes are all off on the machine, the key with the most axes off
+ * first, and keys with as many in VARIANT_KEYS order. The first key a host has a file
+ * for is the file for the machine's off axes that the host carries an arm on. Empty
+ * when every switch is on.
+ */
+export function consultedOffKeys(machine) {
+    return OFF_VARIANT_KEYS
+        .filter(key => offAxesOf(key).every(axis => !machine[axis]))
+        .sort((a, b) => offAxesOf(b).length - offAxesOf(a).length);
+}
+/**
+ * The variants the build writes for a body, in VARIANT_KEYS order, `on` first.
  *
  * A variant is written only for a host that has an arm on each axis the variant turns
  * off: `curation-off` when the body carries a curation arm, `compliance-off` when it
- * carries a compliance arm, and `both-off` when it carries both. A body with no arm
- * has the one variant, because every key would give the same bytes.
+ * carries a compliance arm, `both-off` when it carries both, and the same for the
+ * variants that also turn tdd off. A body with no arm has the one variant, because
+ * every key would give the same bytes.
  */
 export function emittedVariantKeys(hasArms) {
-    const keys = ['on'];
-    if (hasArms.curation)
-        keys.push('curation-off');
-    if (hasArms.compliance)
-        keys.push('compliance-off');
-    if (hasArms.curation && hasArms.compliance)
-        keys.push('both-off');
-    return keys;
+    return VARIANT_KEYS.filter(key => VARIANT_AXES.every(axis => VARIANT_STATES[key][axis] === 'on' || hasArms[axis]));
 }
 /** The longest stretch of a stray line a refusal quotes. */
 const STRAY_QUOTE_MAX = 80;
@@ -325,7 +422,7 @@ function applyMarker(marker, lineNo, open) {
     }
 }
 /**
- * Split a compiled body into its four variants.
+ * Split a compiled body into its variants (VARIANT_KEYS).
  *
  * Total and pure: the same input gives the same output, and a refusal is a
  * Result. The loop is one pass over the body's lines, so its bound is the body's
@@ -340,8 +437,8 @@ function applyMarker(marker, lineNo, open) {
  */
 export function splitVariants(body) {
     const lines = body.split('\n');
-    const kept = { on: [], 'curation-off': [], 'compliance-off': [], 'both-off': [] };
-    const seen = { curation: false, compliance: false };
+    const kept = recordOf(VARIANT_KEYS, () => []);
+    const seen = perAxis(() => false);
     const open = [];
     for (let index = 0; index < lines.length; index++) {
         const line = lines[index];
@@ -359,12 +456,7 @@ export function splitVariants(body) {
         return Err({ kind: 'unclosed-arm', axis: unclosed.axis, arm: unclosed.arm, openedAt: unclosed.openedAt });
     }
     return Ok({
-        bodies: {
-            on: kept.on.join('\n'),
-            'curation-off': kept['curation-off'].join('\n'),
-            'compliance-off': kept['compliance-off'].join('\n'),
-            'both-off': kept['both-off'].join('\n'),
-        },
+        bodies: recordOf(VARIANT_KEYS, key => kept[key].join('\n')),
         hasArms: seen,
     });
 }
@@ -383,7 +475,7 @@ export function describeVariantSplitError(error) {
         case 'interleaved-arm':
             return (`line ${error.line}: a ${error.axis}:${error.marker} marker ends the ${error.axis} arm opened at line ` +
                 `${error.openedAt} while the ${error.innerAxis} arm opened at line ${error.innerOpenedAt} is still ` +
-                `open — arms of two axes may nest but not overlap; close the ${error.innerAxis} arm with ` +
+                `open — arms of different axes may nest but not overlap; close the ${error.innerAxis} arm with ` +
                 `${error.innerAxis}:end first`);
         case 'repeated-off':
             return (`line ${error.line}: a second ${error.axis}:off marker inside the off arm opened at line ` +
@@ -413,8 +505,8 @@ export function describeVariantSplitError(error) {
 /**
  * Repo-relative path of the variant manifest, written beside the variant trees.
  *
- * The installer reads it to learn which compiled prompts carry a curation arm and
- * which carry a compliance arm, so it never has to guess from the files it finds.
+ * The installer reads it to learn which axes each compiled prompt carries an arm on
+ * (curation, compliance, tdd), so it never has to guess from the files it finds.
  */
 export const VARIANT_MANIFEST_REL_PATH = 'dist/variant-axes.json';
 /** The manifest format version. A change to the shape of the file raises it. */
@@ -444,7 +536,7 @@ export function renderVariantManifest(hosts) {
         const key = manifestKeyOf(host);
         if (entries.has(key))
             return Err({ kind: 'duplicate-host', host: key });
-        entries.set(key, { curation: host.axes.curation, compliance: host.axes.compliance });
+        entries.set(key, perAxis(axis => host.axes[axis]));
     }
     const sorted = {};
     for (const key of [...entries.keys()].sort(byCodeUnit)) {
@@ -505,17 +597,38 @@ export function parseVariantManifest(text) {
         const match = MANIFEST_HOST_KEY_RE.exec(key);
         if (match === null)
             return Err({ kind: 'bad-host-key', key });
-        if (!isPlainRecord(value) || typeof value.curation !== 'boolean' || typeof value.compliance !== 'boolean') {
+        if (!isPlainRecord(value))
             return Err({ kind: 'bad-host-axes', host: key });
-        }
-        hosts.push({
-            kind: match[1],
-            name: match[2],
-            axes: { curation: value.curation, compliance: value.compliance },
-        });
+        const axes = parseManifestAxes(value);
+        if (axes === null)
+            return Err({ kind: 'bad-host-axes', host: key });
+        hosts.push({ kind: match[1], name: match[2], axes });
     }
     return Ok(hosts);
 }
+/**
+ * The axes that existed before any later axis was added. A variant manifest or an install
+ * record written before a later axis existed has no entry for it; these axes stay required
+ * in both. An absent later axis reads as no arm in the manifest and as on in the record.
+ */
+export const ORIGINAL_AXES = ['curation', 'compliance'];
+/**
+ * The axes of one host entry, or null when an axis is not a boolean. An axis that is not
+ * in ORIGINAL_AXES may be absent, and then it is false.
+ */
+function parseManifestAxes(entry) {
+    const read = {};
+    for (const axis of VARIANT_AXES) {
+        const value = entry[axis];
+        if (typeof value === 'boolean')
+            read[axis] = value;
+        else if (value === undefined && !ORIGINAL_AXES.includes(axis))
+            read[axis] = false;
+        else
+            return null;
+    }
+    return perAxis(axis => read[axis] === true);
+}
 /** Render a manifest parse refusal as one line a person can act on. */
 export function describeVariantManifestParseError(error) {
     switch (error.kind) {
@@ -532,7 +645,7 @@ export function describeVariantManifestParseError(error) {
         case 'bad-host-key':
             return `the host key "${error.key}" is not <commands|agents>/<name>`;
         case 'bad-host-axes':
-            return `the host ${error.host} does not carry a boolean "curation" and a boolean "compliance"`;
+            return `the host ${error.host} does not carry a boolean "curation" and a boolean "compliance" (and, when present, a boolean "tdd")`;
         default: {
             const unhandled = error;
             return `unhandled variant manifest parse error ${JSON.stringify(unhandled)}`;
@@ -550,13 +663,15 @@ export function describeVariantManifestParseError(error) {
  * have and never the on file.
  */
 export function machineVariantKey(machine, hasArms) {
-    const curationOff = !machine.curation && hasArms.curation;
-    const complianceOff = !machine.compliance && hasArms.compliance;
-    if (curationOff && complianceOff)
-        return 'both-off';
-    if (curationOff)
-        return 'curation-off';
-    return complianceOff ? 'compliance-off' : 'on';
+    const off = VARIANT_AXES.filter(axis => !machine[axis] && hasArms[axis]);
+    // VARIANT_STATES has one row per combination of axes, so exactly one off key matches a
+    // non-empty set (the table test pins that for every machine state and arm set), and
+    // `on` is the answer when nothing is off.
+    const found = OFF_VARIANT_KEYS.find(key => {
+        const turnedOff = offAxesOf(key);
+        return turnedOff.length === off.length && turnedOff.every(axis => off.includes(axis));
+    });
+    return found ?? 'on';
 }
 /**
  * The repo-relative off files a machine must find for the hosts that carry a compliance

package/dist/core/feature-switch.js

@@ -18,6 +18,7 @@ const CURRENT_KEYS = {
     memory: ['memory'],
     curation: ['curation', 'learning'],
     knowledge: ['knowledge'],
+    tdd: ['tdd'],
 };
 /**
  * The pre-rename key each machine feature was stored under, where one exists:
@@ -179,8 +180,8 @@ export async function readOptInFeature(devflowDir, feature) {
  * D-NOOP-TOGGLE: a toggle to the value the manifest already records writes
  * nothing. The only bytes such a write could change are `updatedAt`, and that
  * field means "the manifest's content last changed", so a no-op must not move
- * it. This is the one write point of `devflow memory|curation|knowledge|behavior
- * --enable/--disable`, so the rule holds for all four at once.
+ * it. This is the one write point of `devflow memory|curation|knowledge|behavior|tdd
+ * --enable/--disable`, so the rule holds for all five at once.
  *
  * The read and the write run under the manifest lock (manifest-lock.ts), so the
  * heal in readManifest cannot write an older snapshot over this write. The wait is