devflow-kit 3.12.0 → 3.13.0

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

package/dist/core/installed-variants.js

@@ -2,22 +2,36 @@
  * The install record of the prompt variants (#648, AC-29 and AC-31).
  *
  * After a converge that finished clean, the manifest records which variant of each axis the
- * installed prompts hold: `installedVariants: { curation, compliance }`. The record is the only
+ * installed prompts hold: `installedVariants`, one boolean per axis. The record is the only
  * way to tell what is installed without reading every prompt, and it answers one question the
  * switches alone cannot: does this machine still carry posting steps from before the switch moved?
  *
  * The manifest reader carries the field raw, so a hand-edited or newer-version value reaches this
- * module unchecked. {@link readInstalledVariants} is the one parse: anything but two booleans is
- * unknown, and an absent field is unknown. Nothing heals an unknown record. Pure, with no I/O.
+ * module unchecked. {@link readInstalledVariants} is the one parse: a value that is not a boolean
+ * on an axis is unknown, and an absent field is unknown. A record written before the tdd axis
+ * existed has no `tdd`; it reads as on, because the installed prompts of that time carried the
+ * tdd text. Nothing heals an unknown record. Pure, with no I/O.
+ */
+import { ORIGINAL_AXES, VARIANT_AXES, perAxis } from './curation-variants.js';
+/**
+ * The record as the manifest carries it, or null when it is absent or an axis is not a boolean (unknown).
+ * An axis added after the first record (not in ORIGINAL_AXES) may be absent, and then it is on.
  */
-/** The record as the manifest carries it, or null when it is absent or is not two booleans (unknown). */
 export function readInstalledVariants(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
         return null;
-    const { curation, compliance } = raw;
-    if (typeof curation !== 'boolean' || typeof compliance !== 'boolean')
-        return null;
-    return { curation, compliance };
+    const record = raw;
+    const read = {};
+    for (const axis of VARIANT_AXES) {
+        const value = record[axis];
+        if (typeof value === 'boolean')
+            read[axis] = value;
+        else if (value === undefined && !ORIGINAL_AXES.includes(axis))
+            read[axis] = true;
+        else
+            return null;
+    }
+    return perAxis(axis => read[axis] === true);
 }
 /**
  * The record to write for a converge, or null when none is owed (AC-29). Only a converge that
@@ -26,7 +40,14 @@ export function readInstalledVariants(raw) {
  * notice stays due. Pure; the result is a fresh object.
  */
 export function installRecordFor(converged, switches) {
-    return converged ? { curation: switches.curation, compliance: switches.compliance } : null;
+    return converged ? perAxis(axis => switches[axis]) : null;
+}
+export function variantRecordStatus(installed, axis, enabled) {
+    if (installed === null)
+        return 'unknown';
+    if (installed[axis] !== enabled)
+        return 'mismatch';
+    return enabled ? 'on' : 'off';
 }
 /**
  * Whether the posting steps are installed, from the record and the machine's compliance switch.
@@ -37,11 +58,21 @@ export function installRecordFor(converged, switches) {
  * both name the remedy.
  */
 export function postingStatus(installed, complianceEnabled) {
-    if (installed === null)
-        return 'unknown (run devflow init)';
-    if (installed.compliance !== complianceEnabled)
-        return 'mismatch (run devflow init)';
-    return complianceEnabled ? 'installed' : 'not installed';
+    const status = variantRecordStatus(installed, 'compliance', complianceEnabled);
+    switch (status) {
+        case 'on':
+            return 'installed';
+        case 'off':
+            return 'not installed';
+        case 'mismatch':
+            return 'mismatch (run devflow init)';
+        case 'unknown':
+            return 'unknown (run devflow init)';
+        default: {
+            const unhandled = status;
+            return unhandled;
+        }
+    }
 }
 /** What `devflow init` prints, once, when the installed prompts move from posting steps to none. */
 export const POSTING_OFF_NOTICE = 'Compliance is off on this machine, so devflow installed no step that posts test-plan evidence, ' +

package/dist/core/manifest.js

@@ -90,6 +90,7 @@ export function hasRequiredManifestFields(data) {
  * - features.proxy absent → false
  * - features.compliance absent/malformed → {enabled:false, frameworks:[]}
  * - features.behavior absent → false; malformed → false, healed on disk (D-BEHAVIOR-OPT-IN)
+ * - features.tdd absent or malformed → true; nothing is healed on disk
  * - features.tracker absent/malformed → {provider:'github'}
  * - features.tracker.servers absent → the default list; invalid → the default list, reported
  *   through `opts.onWarning` when the caller supplies one (this reader has no output channel)
@@ -198,6 +199,8 @@ export async function readManifest(devflowDir, opts) {
                 compliance: normalizeComplianceFeature(features.compliance),
                 // D-BEHAVIOR-OPT-IN: absent/malformed → false (opt-in; the inverse of knowledge/curation).
                 behavior: features.behavior === true,
+                // D-FEATURES-ABSENT-ON: absent/malformed → true. Not in needsHeal: no write is owed.
+                tdd: isMachineFeatureOn(data, 'tdd'),
                 // Self-heal: absent/malformed/unknown tracker → {provider:'github'} (AC-3.21).
                 // Deliberately NOT in the hard-null set above — see the field's doc comment.
                 // Healing here is silent and emits no DEGRADED: that is the correct

package/dist/core/mds-variants.js

@@ -40,7 +40,7 @@
 import { createHash } from 'crypto';
 import * as path from 'path';
 import { isContainedIn } from './paths.js';
-import { COMPLIANCE_OFF_OUTPUT_DIR, OFF_OUTPUT_DIRS, machineVariantKey, splitVariants, } from './curation-variants.js';
+import { COMPLIANCE_OFF_OUTPUT_DIR, OFF_OUTPUT_DIRS, VARIANT_KEYS, emittedVariantKeys, machineVariantKey, splitVariants, variantArm, } from './curation-variants.js';
 function Ok(value) {
     return { ok: true, value };
 }
@@ -1311,21 +1311,28 @@ export function describeWorkflowFolderError(error) {
         }
     }
 }
-/** A folder is complete for every key, so the key a machine reads is the one for its switches alone. */
-const FOLDER_ARMS = { curation: true, compliance: true };
+/**
+ * A folder is complete for every key it is built under, so the key a machine reads is the
+ * one for its switches alone. A folder is built under the tdd-on keys only: the tdd axis
+ * is outside the folders (no tdd arm), so a machine with tdd off reads the tdd-on folder.
+ * A total record, so a new axis cannot go without an answer here.
+ */
+export const FOLDER_ARMS = { curation: true, compliance: true, tdd: false };
+/** The variant keys a workflow folder is built, planned, pruned and shipped under: the keys FOLDER_ARMS emits. */
+export const FOLDER_VARIANT_KEYS = emittedVariantKeys(FOLDER_ARMS);
 /**
  * The variant key of the folder a machine with these switches reads.
  *
  * Unlike a prompt, a folder is complete under every key (a byte copy of the on text
  * where no arm applies), so the key follows the switches alone and never depends on
- * which arms a file carries. The mapping is machineVariantKey's, with every arm assumed
- * present, so the key table has one owner.
+ * which arms a file carries. The mapping is machineVariantKey's, with the arms of
+ * FOLDER_ARMS (every axis except tdd, which no folder carries), so the key table has one owner.
  */
 export function workflowFolderKey(switches) {
     return machineVariantKey(switches, FOLDER_ARMS);
 }
 /** The keys whose folder omits the compliance-gated files: the ones that turn compliance off. */
-const COMPLIANCE_OFF_KEYS = new Set([true, false].map(curation => workflowFolderKey({ curation, compliance: false })));
+const COMPLIANCE_OFF_KEYS = new Set(VARIANT_KEYS.filter(key => variantArm(key, 'compliance') === 'off'));
 /**
  * The files one variant key's folder holds, in registry order, the core first.
  *