harness-everything 0.36.3 → 0.37.0

package/ci/mechanism-325-3b-preparation.test.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+'use strict';
+
+// #325 Phase 3b preparation (H1+H2): fixture inventory, the qualified expected-RED runner, legacy controls,
+// switch sanitation, source/package parity and negative registry checks. This suite asserts no runtime
+// behaviour change and no pilot credit. Desired-contract gaps are qualified by the registry, never
+// asserted as passing behaviour. Full replay runs use the runner; negative checks use one case each.
+
+const assert = require('assert');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const fx = require('./lib/doc-reconciliation-prep-fixtures');
+const runner = require('./prep/doc-reconciliation-red.js');
+
+const ROOT = path.resolve(__dirname, '..');
+const PREP_DIR = path.join(__dirname, 'fixtures', 'doc-obligations', 'reconciliation-prep');
+const RUNNER = path.join(__dirname, 'prep', 'doc-reconciliation-red.js');
+const corpus = fx.readCaseCorpus(path.join(PREP_DIR, 'cases.json'));
+const registry = JSON.parse(fs.readFileSync(path.join(PREP_DIR, 'pending-red.json'), 'utf8'));
+const workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'doc-recon-prep-suite-'));
+
+const ALLOWED_OPS = new Set(['route', 'plan', 'start', 'binding', 'step', 'obligation', 'stop', 'provideEvidence', 'mutateIdentity', 'timestampHints']);
+const ALLOWED_OPERATORS = new Set(['equals', 'notEquals', 'includes', 'absent']);
+const REQUIRED_CASE_FIELDS = ['id', 'family', 'description', 'topology', 'requirements', 'input', 'actions', 'expectations'];
+const SHARED_FILES = [
+  ['hooks/scripts/lib/workflow-obligations.js', 'plugins/harness-everything/hooks/scripts/lib/workflow-obligations.js'],
+  ['hooks/scripts/workflow-disposition.js', 'plugins/harness-everything/hooks/scripts/workflow-disposition.js'],
+  ['hooks/scripts/workflow-stop-gate.js', 'plugins/harness-everything/hooks/scripts/workflow-stop-gate.js'],
+];
+
+let failed = 0;
+function check(condition, message) {
+  if (condition) console.log('  PASS ' + message);
+  else { console.error('  FAIL ' + message); failed++; }
+}
+function checkCase(name, runCase) {
+  try { runCase(); check(true, name); } catch (error) { check(false, `${name}: ${error.message.split('\n')[0]}`); }
+}
+function runRunner(args) {
+  return spawnSync(process.execPath, [RUNNER, ...args], { cwd: ROOT, encoding: 'utf8' });
+}
+function writeRegistry(name, mutate) {
+  const copy = JSON.parse(JSON.stringify(registry));
+  mutate(copy);
+  const file = path.join(workDir, name);
+  fs.writeFileSync(file, `${JSON.stringify(copy, null, 2)}\n`, 'utf8');
+  return file;
+}
+
+console.log('=== #325 3b preparation: corpus, qualified RED runner and controls (H1+H2) ===');
+
+checkCase('inventory: the H2 corpus covers P01-P07 with the L1 field shape', () => {
+  const ids = corpus.cases.map(item => item.id);
+  assert.deepStrictEqual(ids, ['P01', 'P04', 'P06', 'P02a', 'P02b', 'P02c', 'P02g', 'P02d', 'P02e', 'P02f', 'P03', 'P05', 'P07-fable-staged', 'P07-fable-parallel', 'P07-fable-multi-agent-workspace', 'P07u']);
+  assert.strictEqual(new Set(ids).size, ids.length, 'case ids are unique');
+  for (const item of corpus.cases) {
+    for (const field of REQUIRED_CASE_FIELDS) assert.ok(item[field] !== undefined, `${item.id} has ${field}`);
+    assert.deepStrictEqual(Object.keys(item.input).sort(), ['baseFiles', 'candidateFiles', 'config', 'hostEvents', 'task'], `${item.id} input keys`);
+    const actionIds = item.actions.map(action => action.id);
+    assert.strictEqual(new Set(actionIds).size, actionIds.length, `${item.id} action ids are unique`);
+    for (const action of item.actions) assert.ok(ALLOWED_OPS.has(action.op), `${item.id} op ${action.op} is allowed`);
+    for (const mode of ['off', 'on']) {
+      const ids2 = item.expectations[mode].map(assertion => assertion.id);
+      assert.strictEqual(new Set(ids2).size, ids2.length, `${item.id} ${mode} assertion ids are unique`);
+      for (const assertion of item.expectations[mode]) {
+        assert.ok(ALLOWED_OPERATORS.has(assertion.operator), `${item.id} operator ${assertion.operator}`);
+        assert.ok(Array.isArray(assertion.path) && assertion.path.length > 0, `${item.id}.${assertion.id} has a path`);
+      }
+    }
+  }
+});
+
+// The full replay runs once, through the runner's JSON report. Every case must be a control or a qualified gap,
+// with matching parity between the two legs and no pilot credit.
+let report = null;
+checkCase('expected-RED mode: every case is CONTROL_PASS or EXPECTED_RED and exits 0', () => {
+  const run = runRunner(['--expect-red', '--json']);
+  assert.strictEqual(run.status, 0, `exit ${run.status}: ${(run.stderr || run.stdout).slice(0, 400)}`);
+  report = JSON.parse(run.stdout);
+});
+
+checkCase('expected-RED report: legs agree, controls are green, no pilot credit, runtime fingerprint matches', () => {
+  assert.ok(report, 'the report was produced');
+  assert.strictEqual(report.pilotCredit, false, 'preparation reports never grant pilot credit');
+  assert.strictEqual(report.runtimeFingerprintMatches, true, 'registry describes the current shared runtime bytes');
+  for (const item of report.cases) {
+    assert.ok(['CONTROL_PASS', 'EXPECTED_RED'].includes(item.status), `${item.caseId} is ${item.status}`);
+    assert.strictEqual(item.parity, 'match', `${item.caseId} source and packaged legs agree`);
+  }
+  const controls = report.cases.filter(item => item.status === 'CONTROL_PASS').map(item => item.caseId).sort();
+  assert.deepStrictEqual(controls, ['P02d', 'P06', 'P07u']);
+});
+
+checkCase('gap registry: every entry is qualified and the expected-RED mode accounts for all of them', () => {
+  assert.ok(report, 'the report was produced');
+  const qualified = report.cases.flatMap(item => item.assertions.filter(entry => entry.status === 'gap-qualified'));
+  assert.strictEqual(qualified.length, registry.entries.length, 'each registry entry is observed exactly once');
+  assert.ok(!report.cases.some(item => item.assertions.some(entry => entry.status === 'gap-unqualified' || entry.status === 'unexpected-pass')));
+});
+
+checkCase('strict mode fails on the recorded gaps and preserves the RED log', () => {
+  const log = path.join(workDir, 'p01-red.json');
+  const run = runRunner(['--strict', '--case', 'P01', '--log', log]);
+  assert.strictEqual(run.status, 1, `strict mode exits 1 on gaps: ${run.stdout}`);
+  const saved = JSON.parse(fs.readFileSync(log, 'utf8'));
+  assert.ok(saved.cases[0].assertions.some(entry => entry.status === 'gap-qualified'), 'the log keeps the qualified gaps');
+});
+
+checkCase('malformed registry is an infrastructure error, not a RED pass', () => {
+  const file = writeRegistry('missing-reason.json', copy => { delete copy.entries[0].reasonCode; });
+  const run = runRunner(['--expect-red', '--case', 'P01', '--registry', file]);
+  assert.strictEqual(run.status, 2, `registry errors exit 2: ${run.stdout} ${run.stderr}`);
+});
+
+checkCase('a registry that omits a gap fails expected-RED mode', () => {
+  const file = writeRegistry('omit-gap.json', copy => { copy.entries = copy.entries.filter(entry => entry.assertionId !== 'P01.on.stop-unsatisfied' || entry.distribution !== 'source'); });
+  const run = runRunner(['--expect-red', '--case', 'P01', '--registry', file]);
+  assert.strictEqual(run.status, 1, `an unqualified gap fails: ${run.stdout}`);
+});
+
+checkCase('an unexpected PASS on a control fails expected-RED mode', () => {
+  const file = writeRegistry('unexpected-pass.json', copy => {
+    copy.entries.push({
+      caseId: 'P06', assertionId: 'P06.on.stop-satisfied', distribution: 'source', baselineSha: copy.baselineSha,
+      actual: 'satisfied', desired: 'running', blocker: '#341 E0', reasonCode: 'pretend-gap'
+    });
+  });
+  const run = runRunner(['--expect-red', '--case', 'P06', '--registry', file]);
+  assert.strictEqual(run.status, 1, `a passing assertion with a registry entry fails: ${run.stdout}`);
+});
+
+// Infrastructure rule: an abnormal action result is never a qualified gap. The controls start from one healthy replay
+// set of P01 and change only the ON route result, so every other fault and assertion is the unmodified replay's.
+const p01 = corpus.cases.find(item => item.id === 'P01');
+const p01Entries = registry.entries.filter(entry => entry.caseId === 'P01');
+const healthyP01 = runner.replayAll(p01);
+const injectIntoRoute = (patch, legs = ['source', 'packaged']) => {
+  const injected = JSON.parse(JSON.stringify(healthyP01));
+  for (const leg of legs) Object.assign(injected.on[leg].actions.route, patch);
+  return injected;
+};
+
+checkCase('negative control: an abnormal route in P01 is infrastructure, and --expect-red exits nonzero though later assertions still match', () => {
+  const injected = injectIntoRoute({ exitCode: 1 });
+  const later = p01.expectations.on.filter(assertion => assertion.id.startsWith('verify-obligation') || assertion.id.startsWith('stop-'));
+  for (const leg of ['source', 'packaged']) {
+    const before = fx.evaluateAll(healthyP01.on[leg], later);
+    const after = fx.evaluateAll(injected.on[leg], later);
+    assert.deepStrictEqual(after.map(item => [item.id, item.pass, item.actual]), before.map(item => [item.id, item.pass, item.actual]),
+      `${leg}: the later assertions evaluate exactly as in the unmodified replay`);
+    for (const item of after) {
+      const entry = p01Entries.find(candidate => candidate.assertionId === `P01.on.${item.id}` && candidate.distribution === leg);
+      assert.ok(entry && JSON.stringify(fx.normalize(entry.actual)) === JSON.stringify(fx.normalize(item.actual)),
+        `${leg}: ${item.id} still matches its registry actual, so only the infrastructure rule can stop qualification`);
+    }
+  }
+  const result = runner.classifyCase(p01, injected, p01Entries);
+  assert.strictEqual(result.status, 'INFRASTRUCTURE', `status ${result.status}`);
+  assert.deepStrictEqual(result.infrastructure, ['source.on.route: exit 1 outside policy [0]', 'packaged.on.route: exit 1 outside policy [0]']);
+  assert.deepStrictEqual(result.offending, { leg: 'source', mode: 'on', actionId: 'route', fault: 'exit 1 outside policy [0]' });
+  assert.deepStrictEqual(result.assertions, [], 'no assertion is qualified or classified for an infrastructure case');
+  assert.strictEqual(runner.exitCodeFor({ cases: [result] }, 'expect-red'), 2, 'expected-RED mode exits nonzero');
+});
+
+checkCase('negative control: a route killed by a signal or without an exit status is infrastructure', () => {
+  const result = runner.classifyCase(p01, injectIntoRoute({ exitCode: null, signal: 'SIGTERM' }), p01Entries);
+  assert.strictEqual(result.status, 'INFRASTRUCTURE');
+  assert.ok(result.infrastructure.includes('source.on.route: terminated by signal SIGTERM'), result.infrastructure.join('; '));
+  assert.ok(result.infrastructure.includes('source.on.route: no exit status'), result.infrastructure.join('; '));
+});
+
+checkCase('negative control: a spawn error on the route is infrastructure', () => {
+  const result = runner.classifyCase(p01, injectIntoRoute({ exitCode: null, error: 'spawnSync node ENOENT' }), p01Entries);
+  assert.strictEqual(result.status, 'INFRASTRUCTURE');
+  assert.ok(result.infrastructure.includes('source.on.route: spawn error spawnSync node ENOENT'), result.infrastructure.join('; '));
+});
+
+checkCase('negative control: an accepted route exit without the routing checkpoint is malformed required output', () => {
+  const result = runner.classifyCase(p01, injectIntoRoute({ stdout: 'routing unavailable' }), p01Entries);
+  assert.strictEqual(result.status, 'INFRASTRUCTURE');
+  assert.ok(result.infrastructure.includes('source.on.route: malformed required output'), result.infrastructure.join('; '));
+});
+
+checkCase('--expect-red exits nonzero from the CLI when a real route exit falls outside its policy', () => {
+  const corpusCopy = JSON.parse(JSON.stringify(corpus));
+  corpusCopy.cases.find(item => item.id === 'P01').actions.find(action => action.id === 'route').expectExit = { off: 1, on: 1 };
+  const file = path.join(workDir, 'route-policy-cases.json');
+  fs.writeFileSync(file, JSON.stringify(corpusCopy), 'utf8');
+  const run = runRunner(['--expect-red', '--case', 'P01', '--cases', file]);
+  assert.strictEqual(run.status, 2, `an infrastructure fault exits 2: ${run.stdout} ${run.stderr}`);
+  assert.ok(run.stdout.includes('INFRASTRUCTURE'), run.stdout);
+});
+
+// Real process boundary: a substituted child (hung or flooding) under a short deadline runs through the CLI. The
+// outer SIGKILL deadline turns a regression (the runner never returns) into a failed check instead of a hung suite.
+const OUTER_DEADLINE_MS = 90000;
+const PROMPT_EXIT_MS = 30000;
+// Replay directories still on disk: for one case, or for every case when caseId is empty.
+const replayDirsFor = caseId => fs.readdirSync(os.tmpdir()).filter(name => name.startsWith(caseId ? `doc-recon-${caseId}-` : 'doc-recon-')).length;
+function runWithChildLimits(caseId, childLimits) {
+  const corpusCopy = JSON.parse(JSON.stringify(corpus));
+  corpusCopy.cases.find(item => item.id === caseId).childLimits = childLimits;
+  const file = path.join(workDir, `${caseId}-child-limits.json`);
+  fs.writeFileSync(file, JSON.stringify(corpusCopy), 'utf8');
+  const started = Date.now();
+  const run = spawnSync(process.execPath, [RUNNER, '--expect-red', '--case', caseId, '--cases', file], {
+    cwd: ROOT, encoding: 'utf8', timeout: OUTER_DEADLINE_MS, killSignal: 'SIGKILL'
+  });
+  return { run, elapsed: Date.now() - started };
+}
+
+checkCase('a hung route entrypoint cannot stall --expect-red: the CLI exits 2 promptly and removes the replay directories', () => {
+  const before = replayDirsFor('P01');
+  const { run, elapsed } = runWithChildLimits('P01', { timeoutMs: 500, substitutes: { route: 'hang-entrypoint.js' } });
+  assert.strictEqual(run.signal, null, `the runner hung until the outer ${OUTER_DEADLINE_MS} ms deadline (signal ${run.signal})`);
+  assert.strictEqual(run.status, 2, `exit ${run.status}: ${run.stdout} ${run.stderr}`);
+  assert.ok(elapsed < PROMPT_EXIT_MS, `exit took ${elapsed} ms, bound ${PROMPT_EXIT_MS} ms`);
+  assert.ok(run.stdout.includes('INFRASTRUCTURE') && run.stdout.includes('timed out at the child deadline (ETIMEDOUT)'), run.stdout);
+  assert.strictEqual(replayDirsFor('P01'), before, 'replay directories are removed after the timeout');
+});
+
+checkCase('a route that floods stdout is stopped by the output bound and exits 2 through the CLI', () => {
+  const before = replayDirsFor('P01');
+  const { run, elapsed } = runWithChildLimits('P01', { timeoutMs: 5000, substitutes: { route: 'flood-entrypoint.js' } });
+  assert.strictEqual(run.signal, null, `the runner hung until the outer ${OUTER_DEADLINE_MS} ms deadline (signal ${run.signal})`);
+  assert.strictEqual(run.status, 2, `exit ${run.status}: ${run.stdout} ${run.stderr}`);
+  assert.ok(elapsed < PROMPT_EXIT_MS, `exit took ${elapsed} ms, bound ${PROMPT_EXIT_MS} ms`);
+  assert.ok(run.stdout.includes('child output exceeded maxBuffer (ENOBUFS)'), run.stdout);
+  assert.strictEqual(replayDirsFor('P01'), before, 'replay directories are removed after the output bound');
+});
+
+checkCase('a faulted replay runs no action after its first infrastructure fault and still removes its directories', () => {
+  const before = replayDirsFor('P01');
+  const item = { ...p01, childLimits: { timeoutMs: 500, substitutes: { route: 'hang-entrypoint.js' } } };
+  const root = fx.replayCase(item, 'source');
+  assert.deepStrictEqual(Object.keys(root.actions), ['route'], 'only the faulted route is recorded');
+  const faults = fx.infrastructureFaults(item, root, 'off');
+  assert.ok(faults.length > 0 && faults.every(entry => entry.actionId === 'route'), `faults name only the route: ${JSON.stringify(faults)}`);
+  assert.strictEqual(replayDirsFor('P01'), before, 'replay directories are removed after the fault');
+});
+
+// Corpus-level fail-fast through the real CLI. Every case hangs on the same shared route, so an unbounded runner would
+// spend one deadline per replay (64 route timeouts). The fail-fast spends one, names the rest NOT_RUN, and exits 2.
+const SHARED_HANG_DEADLINE_MS = 500;
+const SHARED_HANG_BOUND_MS = 5000;
+checkCase('corpus-level: a route hung in every case costs one deadline, exits 2, and names the other cases NOT_RUN', () => {
+  const everyCaseHangs = JSON.parse(JSON.stringify(corpus));
+  for (const item of everyCaseHangs.cases) {
+    item.childLimits = { timeoutMs: SHARED_HANG_DEADLINE_MS, substitutes: { route: 'hang-entrypoint.js' } };
+  }
+  const file = path.join(workDir, 'every-case-hangs.json');
+  fs.writeFileSync(file, JSON.stringify(everyCaseHangs), 'utf8');
+  const before = replayDirsFor('');
+  const started = Date.now();
+  const run = spawnSync(process.execPath, [RUNNER, '--expect-red', '--json', '--cases', file], {
+    cwd: ROOT, encoding: 'utf8', timeout: OUTER_DEADLINE_MS, killSignal: 'SIGKILL'
+  });
+  const elapsed = Date.now() - started;
+  assert.strictEqual(run.signal, null, `the runner hung until the outer ${OUTER_DEADLINE_MS} ms deadline (signal ${run.signal})`);
+  assert.strictEqual(run.status, 2, `exit ${run.status}: ${run.stdout} ${run.stderr}`);
+  assert.ok(elapsed < SHARED_HANG_BOUND_MS, `exit took ${elapsed} ms; one ${SHARED_HANG_DEADLINE_MS} ms deadline plus overhead must stay under ${SHARED_HANG_BOUND_MS} ms`);
+  const report = JSON.parse(run.stdout);
+  assert.strictEqual(report.replaysRun, 1, 'exactly one replay ran');
+  const [first, ...rest] = report.cases;
+  assert.strictEqual(first.caseId, 'P01');
+  assert.strictEqual(first.status, 'INFRASTRUCTURE');
+  assert.deepStrictEqual(first.offending, { leg: 'source', mode: 'off', actionId: 'route', fault: 'timed out at the child deadline (ETIMEDOUT)' });
+  assert.strictEqual(first.actionsRun, 1, 'only the hung route ran');
+  assert.deepStrictEqual(rest.map(item => item.caseId), corpus.cases.slice(1).map(item => item.id), 'every other case is named');
+  assert.ok(rest.every(item => item.status === 'NOT_RUN'), 'the other cases are NOT_RUN, never silently omitted');
+  assert.strictEqual(replayDirsFor(''), before, 'replay directories are removed');
+});
+
+checkCase('the committed corpus carries no child-limit override, so production replays use the default deadline', () => {
+  assert.ok(corpus.cases.every(item => item.childLimits === undefined), 'a childLimits key is test-only');
+});
+
+checkCase('a child deadline override can only shorten the default deadline', () => {
+  const item = { ...corpus.cases.find(candidate => candidate.id === 'P06'), childLimits: { timeoutMs: 60000 } };
+  assert.throws(() => fx.replayCase(item, 'source'), /may only shorten/);
+});
+
+checkCase('a malformed expectExit policy is an infrastructure error, not a RED pass', () => {
+  const corpusCopy = JSON.parse(JSON.stringify(corpus));
+  corpusCopy.cases.find(item => item.id === 'P06').actions.find(action => action.id === 'route').expectExit = { off: 'two' };
+  const file = path.join(workDir, 'malformed-policy-cases.json');
+  fs.writeFileSync(file, JSON.stringify(corpusCopy), 'utf8');
+  const run = runRunner(['--expect-red', '--case', 'P06', '--cases', file]);
+  assert.strictEqual(run.status, 2, `a malformed policy exits 2: ${run.stdout} ${run.stderr}`);
+});
+
+checkCase('a runtime fingerprint change invalidates qualification and prints the exact deliberate re-capture command', () => {
+  const file = writeRegistry('stale-fingerprint.json', copy => { copy.runtimeFingerprint = '0'.repeat(64); });
+  const run = runRunner(['--expect-red', '--case', 'P01', '--registry', file]);
+  assert.strictEqual(run.status, 1, `a fingerprint mismatch fails: ${run.stdout}`);
+  const output = run.stdout + run.stderr;
+  assert.ok(output.includes('--recapture-candidate ci/fixtures/doc-obligations/reconciliation-prep/pending-red.candidate.json'), 'the re-capture command names the candidate');
+  assert.ok(/--baseline-sha [0-9a-f]{40}/.test(output), 'the re-capture command names the commit');
+  assert.ok(output.includes('nothing is auto-accepted'), 'the message says nothing is auto-accepted');
+});
+
+checkCase('recapture writes a reviewable candidate and never the committed registry', () => {
+  const candidate = path.join(workDir, 'candidate.json');
+  const before = fs.readFileSync(path.join(PREP_DIR, 'pending-red.json'), 'utf8');
+  const run = spawnSync(process.execPath, [RUNNER, '--recapture-candidate', candidate, '--baseline-sha', registry.baselineSha, '--case', 'P06'], { cwd: ROOT, encoding: 'utf8' });
+  assert.strictEqual(run.status, 0, run.stderr);
+  assert.strictEqual(fs.readFileSync(path.join(PREP_DIR, 'pending-red.json'), 'utf8'), before, 'the committed registry is untouched');
+  const saved = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+  assert.strictEqual(saved.entries.length, 0, 'a control case has no gaps to record');
+  assert.strictEqual(saved.runtimeFingerprint, registry.runtimeFingerprint, 'the candidate describes the current runtime');
+});
+
+checkCase('a candidate with unreviewed reasons is rejected by the registry validator', () => {
+  const file = writeRegistry('unreviewed.json', copy => { copy.entries[0].reasonCode = 'needs-reason'; });
+  const run = runRunner(['--expect-red', '--case', 'P01', '--registry', file]);
+  assert.strictEqual(run.status, 2, 'an unreviewed reason is a registry error');
+});
+
+checkCase('P08 parity: shared runtime files are byte-identical between the source and packaged legs', () => {
+  for (const [source, packaged] of SHARED_FILES) {
+    const left = crypto.createHash('sha256').update(fs.readFileSync(path.join(ROOT, source))).digest('hex');
+    const right = crypto.createHash('sha256').update(fs.readFileSync(path.join(ROOT, packaged))).digest('hex');
+    assert.strictEqual(left, right, `${source} matches ${packaged}`);
+  }
+});
+
+// Switch sanitation: an inherited ON request does not reach an OFF replay (one replay).
+checkCase('switch sanitation: an inherited ON request does not reach an OFF replay', () => {
+  const previous = process.env[fx.PILOT_SWITCH];
+  process.env[fx.PILOT_SWITCH] = '1';
+  try {
+    const item = corpus.cases.find(candidate => candidate.id === 'P06');
+    const root = fx.replayCase(item, 'source');
+    const failures = fx.evaluateAll(root, item.expectations.off).filter(result => !result.pass);
+    assert.strictEqual(failures.length, 0, 'OFF expectations still hold with an inherited ON request');
+  } finally {
+    if (previous === undefined) delete process.env[fx.PILOT_SWITCH];
+    else process.env[fx.PILOT_SWITCH] = previous;
+  }
+});
+
+checkCase('cleanup: replays remove their temporary workspace and state directories', () => {
+  const prefix = 'doc-recon-P06-source-';
+  const before = fs.readdirSync(os.tmpdir()).filter(name => name.startsWith(prefix)).length;
+  fx.replayCase(corpus.cases.find(item => item.id === 'P06'), 'source');
+  const after = fs.readdirSync(os.tmpdir()).filter(name => name.startsWith(prefix)).length;
+  assert.strictEqual(after, before, 'no replay directory is left behind');
+});
+
+// F-a: separator-agnostic scrubbing. Windows-shaped strings from each leg must normalize to the same markers.
+checkCase('F-a: Windows-shaped source and packaged paths normalize identically', () => {
+  const roots = { repo: 'D:\\a\\repo', tmp: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp'] };
+  const sourceSkill = fx.scrubText('D:\\a\\repo\\tdd\\SKILL.md', roots);
+  const packagedSkill = fx.scrubText('D:\\a\\repo\\plugins\\harness-everything\\skills\\tdd\\SKILL.md', roots);
+  assert.strictEqual(sourceSkill, '<skill:tdd>', 'the source skill path is marked by skill id');
+  assert.strictEqual(packagedSkill, sourceSkill, 'the packaged skill path is marked the same way');
+  const sourceTmp = fx.scrubText('C:\\Users\\runneradmin\\AppData\\Local\\Temp\\doc-recon-P01-source-ws-0a1b2c3d-x9\\state\\workflow-run.json', roots);
+  const packagedTmp = fx.scrubText('C:\\Users\\runneradmin\\AppData\\Local\\Temp\\doc-recon-P01-packaged-ws-5e6f7a8b-y2\\state\\workflow-run.json', roots);
+  assert.strictEqual(packagedTmp, sourceTmp, 'temporary paths from each leg are marked the same way');
+  assert.ok(!sourceTmp.includes('\\') && !sourceTmp.includes('doc-recon'), 'no raw separator or temp name survives');
+  const sameAfterFold = fx.scrubText('C:/Users/runneradmin/AppData/Local/Temp/doc-recon-P01-source-ws-0a1b2c3d-x9/state/workflow-run.json', roots);
+  assert.strictEqual(sameAfterFold, sourceTmp, 'POSIX and Windows spellings of one path normalize identically');
+});
+
+// F-b: a per-action switch override must not reach an OFF replay.
+checkCase('F-b: an OFF replay of P05 carries no per-action switch; the ON replay keeps its overrides', () => {
+  const item = corpus.cases.find(candidate => candidate.id === 'P05');
+  const off = fx.replayCase(item, 'source');
+  for (const [id, action] of Object.entries(off.actions)) {
+    assert.strictEqual(action.pilot, undefined, `OFF replay action ${id} has no switch value`);
+  }
+  const on = fx.replayCase(item, 'source', { pilot: '1' });
+  assert.strictEqual(on.actions['stop-on-1'].pilot, '1', 'an ON replay keeps the ON action value');
+  assert.strictEqual(on.actions['stop-off'].pilot, '0', 'an ON replay keeps the explicit OFF action value');
+});
+
+fs.rmSync(workDir, { recursive: true, force: true });
+console.log(failed ? `\n${failed} preparation check(s) failed` : '\nAll preparation checks passed (desired-contract gaps are qualified, not asserted as behaviour)');
+process.exitCode = failed ? 1 : 0;