@tekyzinc/gsd-t 3.29.11 → 4.0.12

package/bin/m44-proof-measure.cjs

@@ -1,285 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * M44 Proof Measurement Driver (backlog #15 — T/2 criterion)
- *
- * Goal: prove v3.19.00's parallel dispatcher actually fans out concurrently.
- *
- * Method:
- *   1. Build a temp project with a 4-task file-disjoint tasks.md fixture.
- *   2. Inject a synthetic spawner into bin/gsd-t-parallel.cjs::runDispatch
- *      that launches test/fixtures/m44-proof/worker-sim.js as a detached
- *      child (same contract as the real autoSpawnHeadless).
- *   3. Measure:
- *        T_seq = sum of per-worker durations when called sequentially.
- *        T_par = wall-clock span from first spawn_started to last .done
- *                marker when dispatched via runDispatch.
- *   4. Criterion: T_par ≤ T_seq / 2   ( = parallelism_factor ≥ 2 for N=4 )
- *
- * This proves the DISPATCHER. It does NOT prove that 4 Claude workers
- * produce correct code in T/2. That is a separate, API-budget-intensive
- * experiment (backlog #15 follow-up). The dispatcher is the shipped code
- * in v3.19.00, and its mechanics are what the tag certifies.
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { spawn } = require('child_process');
-
-const { runDispatch } = require(path.join(__dirname, 'gsd-t-parallel.cjs'));
-const { writeSpawnPlan } = require(path.join(__dirname, 'spawn-plan-writer.cjs'));
-const { markTaskDone, markSpawnEnded } = require(path.join(__dirname, 'spawn-plan-status-updater.cjs'));
-
-// When invoked with --visualize, write spawn-plan files into the REAL project
-// directory (not the temp fixture dir) so the live dashboard at :7455 can
-// render the fan-out in real time. Off by default to keep the measurement
-// directory clean.
-const VISUALIZE = process.argv.includes('--visualize');
-const REAL_PROJECT_DIR = path.resolve(__dirname, '..');
-
-// ── fixture setup ───────────────────────────────────────────────────────────
-
-function buildFixtureProject(workDurationMs) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'm44-proof-'));
-  fs.mkdirSync(path.join(root, '.gsd-t', 'domains', 'm99-d1-proof'), { recursive: true });
-  fs.mkdirSync(path.join(root, '.gsd-t', 'spawns'), { recursive: true });
-  fs.mkdirSync(path.join(root, '.gsd-t', 'events'), { recursive: true });
-
-  const tasksMd = fs.readFileSync(
-    path.join(__dirname, '..', 'test', 'fixtures', 'm44-proof', 'fixture.tasks.md'),
-    'utf8',
-  );
-  fs.writeFileSync(path.join(root, '.gsd-t', 'domains', 'm99-d1-proof', 'tasks.md'), tasksMd);
-
-  const partitionMd = [
-    '# Partition — M99',
-    '',
-    '## Wave 1',
-    '- m99-d1-proof (all tasks disjoint, no deps)',
-    '',
-  ].join('\n');
-  fs.writeFileSync(path.join(root, '.gsd-t', 'partition.md'), partitionMd);
-
-  return root;
-}
-
-function cleanup(root) {
-  try { fs.rmSync(root, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-// ── spawner (injected into runDispatch) ────────────────────────────────────
-
-function makeSpawner({ outDir, workerDurationMs }) {
-  const launched = [];
-  const spawner = ({ env }) => {
-    const childEnv = Object.assign({}, process.env, env, {
-      OUT_DIR: outDir,
-      WORKER_DURATION_MS: String(workerDurationMs),
-    });
-    const workerPath = path.join(__dirname, '..', 'test', 'fixtures', 'm44-proof', 'worker-sim.js');
-    const child = spawn(process.execPath, [workerPath], {
-      env: childEnv, detached: true, stdio: 'ignore',
-    });
-    child.unref();
-    const spawnId = 'm44-proof-' + env.GSD_T_WORKER_INDEX + '-' + Date.now();
-    const taskIds = env.GSD_T_WORKER_TASK_IDS.split(',');
-
-    if (VISUALIZE) {
-      try {
-        writeSpawnPlan({
-          spawnId,
-          kind: 'headless-detached',
-          milestone: 'M99',
-          wave: 'wave-1',
-          domains: ['m99-d1-proof'],
-          tasks: taskIds.map((id) => ({ id, title: 'Proof ' + id, status: 'in_flight' })),
-          projectDir: REAL_PROJECT_DIR,
-        });
-      } catch (e) { process.stderr.write('[visualize] writeSpawnPlan failed: ' + e.message + '\n'); }
-    }
-
-    launched.push({
-      spawnId, pid: child.pid,
-      taskIds,
-      launchedAt: process.hrtime.bigint(),
-    });
-    return { id: spawnId, pid: child.pid, logPath: null };
-  };
-  return { spawner, launched };
-}
-
-function markLaunchedDone(launched) {
-  if (!VISUALIZE) return;
-  for (const l of launched) {
-    try {
-      for (const id of l.taskIds) {
-        markTaskDone({ spawnId: l.spawnId, taskId: id, projectDir: REAL_PROJECT_DIR, commit: 'proof-sim', tokens: null });
-      }
-      markSpawnEnded({ spawnId: l.spawnId, projectDir: REAL_PROJECT_DIR });
-    } catch (e) { process.stderr.write('[visualize] mark-done failed: ' + e.message + '\n'); }
-  }
-}
-
-// ── wait for all .done markers ─────────────────────────────────────────────
-
-async function waitForMarkers(outDir, expectedCount, timeoutMs = 60000) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    let present;
-    try { present = fs.readdirSync(outDir).filter((n) => n.endsWith('.done')); }
-    catch { present = []; }
-    if (present.length >= expectedCount) return present;
-    await new Promise((r) => setTimeout(r, 100));
-  }
-  throw new Error('timeout waiting for ' + expectedCount + ' .done markers in ' + outDir);
-}
-
-function readMarkers(outDir) {
-  return fs.readdirSync(outDir)
-    .filter((n) => n.endsWith('.done'))
-    .map((n) => JSON.parse(fs.readFileSync(path.join(outDir, n), 'utf8')))
-    .sort((a, b) => a.workerIndex - b.workerIndex);
-}
-
-// ── runs ────────────────────────────────────────────────────────────────────
-
-async function runParallelPass(workerDurationMs) {
-  const projectDir = buildFixtureProject(workerDurationMs);
-  const outDir = path.join(projectDir, 'worker-out');
-  fs.mkdirSync(outDir, { recursive: true });
-
-  const { spawner, launched } = makeSpawner({ outDir, workerDurationMs });
-
-  const t0 = process.hrtime.bigint();
-  const result = runDispatch({
-    projectDir,
-    command: 'gsd-t-execute',
-    mode: 'unattended',
-    env: { GSD_T_UNATTENDED: '1' },
-    spawnHeadlessImpl: spawner,
-  });
-  const dispatchReturnedAt = process.hrtime.bigint();
-
-  if (result.fanOutCount < 2) {
-    cleanup(projectDir);
-    throw new Error('parallel dispatch did not fan out (decision=' + result.decision + ', fanOutCount=' + result.fanOutCount + ')');
-  }
-
-  await waitForMarkers(outDir, result.fanOutCount);
-  const t1 = process.hrtime.bigint();
-
-  markLaunchedDone(launched);
-
-  const markers = readMarkers(outDir);
-  const wallClockMs = Number(t1 - t0) / 1e6;
-  const dispatchOverheadMs = Number(dispatchReturnedAt - t0) / 1e6;
-  const perWorkerDurationMs = markers.map((m) => m.durationMs);
-  const sumWorkerDurationMs = perWorkerDurationMs.reduce((a, b) => a + b, 0);
-
-  cleanup(projectDir);
-  return {
-    mode: 'parallel',
-    fanOutCount: result.fanOutCount,
-    launched: launched.length,
-    wallClockMs,
-    dispatchOverheadMs,
-    perWorkerDurationMs,
-    sumWorkerDurationMs,
-    workerPids: markers.map((m) => m.pid),
-    markers,
-  };
-}
-
-async function runSequentialPass(workerDurationMs, taskCount = 4) {
-  // Sequential baseline: run N workers back-to-back, same worker-sim.js.
-  // This is what a single-worker supervisor would do before v3.19.00.
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'm44-proof-seq-'));
-  const outDir = path.join(tmp, 'worker-out');
-  fs.mkdirSync(outDir, { recursive: true });
-
-  const t0 = process.hrtime.bigint();
-  for (let i = 0; i < taskCount; i++) {
-    await new Promise((resolve, reject) => {
-      const child = spawn(process.execPath, [
-        path.join(__dirname, '..', 'test', 'fixtures', 'm44-proof', 'worker-sim.js'),
-      ], {
-        env: Object.assign({}, process.env, {
-          OUT_DIR: outDir,
-          WORKER_DURATION_MS: String(workerDurationMs),
-          GSD_T_WORKER_INDEX: String(i),
-          GSD_T_WORKER_TOTAL: String(taskCount),
-          GSD_T_WORKER_TASK_IDS: 'M99-D1-T' + (i + 1),
-        }),
-        stdio: 'ignore',
-      });
-      child.on('exit', (code) => code === 0 ? resolve() : reject(new Error('worker exit ' + code)));
-      child.on('error', reject);
-    });
-  }
-  const t1 = process.hrtime.bigint();
-  const markers = readMarkers(outDir);
-  const wallClockMs = Number(t1 - t0) / 1e6;
-  cleanup(tmp);
-
-  return {
-    mode: 'sequential',
-    taskCount,
-    wallClockMs,
-    perWorkerDurationMs: markers.map((m) => m.durationMs),
-    sumWorkerDurationMs: markers.map((m) => m.durationMs).reduce((a, b) => a + b, 0),
-  };
-}
-
-// ── main ────────────────────────────────────────────────────────────────────
-
-async function main() {
-  const workerDurationMs = parseInt(process.env.WORKER_DURATION_MS || '8000', 10);
-  process.stdout.write('M44 Proof Measurement (worker duration=' + workerDurationMs + 'ms)\n');
-  process.stdout.write('─'.repeat(60) + '\n');
-
-  const seq = await runSequentialPass(workerDurationMs);
-  process.stdout.write('Sequential (N=4 workers run back-to-back)\n');
-  process.stdout.write('  T_seq (wall-clock):   ' + seq.wallClockMs.toFixed(1) + ' ms\n');
-  process.stdout.write('  sum(worker durations): ' + seq.sumWorkerDurationMs.toFixed(1) + ' ms\n');
-  process.stdout.write('\n');
-
-  const par = await runParallelPass(workerDurationMs);
-  process.stdout.write('Parallel (runDispatch, N=' + par.fanOutCount + ' concurrent workers)\n');
-  process.stdout.write('  T_par (wall-clock):   ' + par.wallClockMs.toFixed(1) + ' ms\n');
-  process.stdout.write('  dispatch overhead:     ' + par.dispatchOverheadMs.toFixed(1) + ' ms\n');
-  process.stdout.write('  sum(worker durations): ' + par.sumWorkerDurationMs.toFixed(1) + ' ms\n');
-  process.stdout.write('  per-worker durations:  [' + par.perWorkerDurationMs.map((x) => x.toFixed(0)).join(', ') + '] ms\n');
-  process.stdout.write('  worker pids:           [' + par.workerPids.join(', ') + ']\n');
-  process.stdout.write('\n');
-
-  const ratio = par.wallClockMs / seq.wallClockMs;
-  const speedup = seq.wallClockMs / par.wallClockMs;
-  const parallelismFactor = par.sumWorkerDurationMs / par.wallClockMs;
-  const criterion = par.wallClockMs <= seq.wallClockMs / 2;
-
-  process.stdout.write('─'.repeat(60) + '\n');
-  process.stdout.write('Result\n');
-  process.stdout.write('  T_par / T_seq        = ' + ratio.toFixed(3) + '\n');
-  process.stdout.write('  speedup              = ' + speedup.toFixed(2) + '×\n');
-  process.stdout.write('  parallelism_factor   = ' + parallelismFactor.toFixed(2) + '  (ideal = ' + par.fanOutCount + ')\n');
-  process.stdout.write('  T/2 criterion        = ' + (criterion ? 'MET ✓' : 'NOT MET ✗') + '  (T_par ≤ T_seq/2)\n');
-
-  const report = {
-    generatedAt: new Date().toISOString(),
-    workerDurationMs,
-    sequential: seq,
-    parallel: par,
-    ratio, speedup, parallelismFactor,
-    criterionMet: criterion,
-  };
-  const reportPath = path.join(process.cwd(), '.gsd-t', 'm44-proof-report.json');
-  fs.mkdirSync(path.dirname(reportPath), { recursive: true });
-  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
-  process.stdout.write('\nReport written: ' + reportPath + '\n');
-
-  process.exit(criterion ? 0 : 1);
-}
-
-main().catch((e) => { process.stderr.write('ERROR: ' + (e && e.stack || e) + '\n'); process.exit(2); });

package/bin/m46-iter-proof.cjs

@@ -1,149 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * M46-D1 Iter-Parallel Proof Harness (T10)
- *
- * Measures the parallelism speedup of `_runIterParallel` vs. a serial
- * baseline using a synthetic 10-iter workload where each iter sleeps
- * 200ms and returns a successful IterResult.
- *
- * Method:
- *   1. Serial baseline (batchSize=1): run 10 iters one at a time via
- *      `_runIterParallel(..., batchSize=1)` in a loop. Expect ~2000ms.
- *   2. Parallel (batchSize=4): run 10 iters in batches of 4+4+2 via the
- *      same helper. Expect ~600ms (3 batches × 200ms).
- *   3. Compute speedup = T_serial / T_par,
- *      parallelism_factor = (10 × 200) / T_par.
- *   4. Pass iff T_par/T_serial ≤ 0.35 AND speedup ≥ 3.0.
- *
- * Output: .gsd-t/metrics/m46-iter-proof.json + human summary on stdout.
- * Exit: 0 on pass, 1 on fail.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const ITER_COUNT = 10;
-const ITER_SLEEP_MS = 200;
-const BATCH_SERIAL = 1;
-const BATCH_PARALLEL = 4;
-const THRESHOLD_RATIO = 0.35;
-const THRESHOLD_SPEEDUP = 3.0;
-
-const { _runIterParallel } = require(path.join(__dirname, 'gsd-t-unattended.cjs')).__test__;
-
-// ── synthetic iterFn ───────────────────────────────────────────────────────
-
-let iterSeq = 0;
-function makeIterFn(sleepMs) {
-  return async function fakeIter(_state, _opts) {
-    const id = iterSeq++;
-    await new Promise((r) => setTimeout(r, sleepMs));
-    return {
-      status: 'ok',
-      tasksDone: ['t' + id],
-      verifyNeeded: false,
-      artifacts: [],
-    };
-  };
-}
-
-// ── runners ────────────────────────────────────────────────────────────────
-
-async function runSerial(total, sleepMs) {
-  const iterFn = makeIterFn(sleepMs);
-  const state = {};
-  const opts = {};
-  const t0 = process.hrtime.bigint();
-  const results = [];
-  for (let i = 0; i < total; i++) {
-    const batch = await _runIterParallel(state, opts, iterFn, BATCH_SERIAL);
-    results.push(...batch);
-  }
-  const t1 = process.hrtime.bigint();
-  return {
-    wallClockMs: Number(t1 - t0) / 1e6,
-    results,
-  };
-}
-
-async function runParallel(total, batchSize, sleepMs) {
-  const iterFn = makeIterFn(sleepMs);
-  const state = {};
-  const opts = {};
-  const t0 = process.hrtime.bigint();
-  const results = [];
-  let remaining = total;
-  while (remaining > 0) {
-    const n = Math.min(batchSize, remaining);
-    const batch = await _runIterParallel(state, opts, iterFn, n);
-    results.push(...batch);
-    remaining -= n;
-  }
-  const t1 = process.hrtime.bigint();
-  return {
-    wallClockMs: Number(t1 - t0) / 1e6,
-    results,
-  };
-}
-
-// ── main ───────────────────────────────────────────────────────────────────
-
-async function main() {
-  process.stdout.write(
-    `M46-D1 Iter-Parallel Proof (N=${ITER_COUNT} iters, sleep=${ITER_SLEEP_MS}ms each)\n`,
-  );
-  process.stdout.write('─'.repeat(60) + '\n');
-
-  iterSeq = 0;
-  const serial = await runSerial(ITER_COUNT, ITER_SLEEP_MS);
-  process.stdout.write(`Serial baseline (batchSize=${BATCH_SERIAL}, ${ITER_COUNT} iters sequentially)\n`);
-  process.stdout.write(`  T_serial (wall-clock): ${serial.wallClockMs.toFixed(1)} ms\n`);
-  process.stdout.write(`  results:               ${serial.results.length} (ok=${serial.results.filter((r) => r.status === 'ok').length})\n\n`);
-
-  iterSeq = 0;
-  const parallel = await runParallel(ITER_COUNT, BATCH_PARALLEL, ITER_SLEEP_MS);
-  process.stdout.write(`Parallel (batchSize=${BATCH_PARALLEL}, batches of 4+4+2)\n`);
-  process.stdout.write(`  T_par (wall-clock):    ${parallel.wallClockMs.toFixed(1)} ms\n`);
-  process.stdout.write(`  results:               ${parallel.results.length} (ok=${parallel.results.filter((r) => r.status === 'ok').length})\n\n`);
-
-  const ratio = parallel.wallClockMs / serial.wallClockMs;
-  const speedup = serial.wallClockMs / parallel.wallClockMs;
-  const parallelismFactor = (ITER_COUNT * ITER_SLEEP_MS) / parallel.wallClockMs;
-  const passed = ratio <= THRESHOLD_RATIO && speedup >= THRESHOLD_SPEEDUP;
-
-  process.stdout.write('─'.repeat(60) + '\n');
-  process.stdout.write('Result\n');
-  process.stdout.write(`  T_par / T_serial     = ${ratio.toFixed(3)} (threshold ≤ ${THRESHOLD_RATIO})\n`);
-  process.stdout.write(`  speedup              = ${speedup.toFixed(2)}× (threshold ≥ ${THRESHOLD_SPEEDUP})\n`);
-  process.stdout.write(`  parallelism_factor   = ${parallelismFactor.toFixed(2)} (ideal ≈ ${BATCH_PARALLEL})\n`);
-  process.stdout.write(`  verdict              = ${passed ? 'PASS ✓' : 'FAIL ✗'}\n`);
-
-  const report = {
-    timestamp: new Date().toISOString(),
-    iter_count: ITER_COUNT,
-    iter_sleep_ms: ITER_SLEEP_MS,
-    batch_size_serial: BATCH_SERIAL,
-    batch_size_parallel: BATCH_PARALLEL,
-    T_serial_ms: serial.wallClockMs,
-    T_par_ms: parallel.wallClockMs,
-    speedup,
-    parallelism_factor: parallelismFactor,
-    threshold_T_par_over_T_serial: THRESHOLD_RATIO,
-    threshold_speedup: THRESHOLD_SPEEDUP,
-    passed,
-  };
-  const reportDir = path.join(process.cwd(), '.gsd-t', 'metrics');
-  fs.mkdirSync(reportDir, { recursive: true });
-  const reportPath = path.join(reportDir, 'm46-iter-proof.json');
-  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
-  process.stdout.write(`\nReport written: ${reportPath}\n`);
-
-  process.exit(passed ? 0 : 1);
-}
-
-main().catch((e) => {
-  process.stderr.write(`ERROR: ${(e && e.stack) || e}\n`);
-  process.exit(2);
-});

package/bin/m46-worker-proof.cjs

@@ -1,201 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * M46-D2 Worker Sub-Dispatch Proof Harness (T7)
- *
- * Measures the parallelism speedup of `dispatchWorkerTasks` vs. a serial
- * baseline using a synthetic 6-task file-disjoint workload.
- *
- * Method:
- *   1. Serial baseline: run 6 `sleep 2 && echo done > …` tasks one by one
- *      via `child_process.execSync`. Record `T_serial` (wall-clock ms).
- *   2. Parallel via `dispatchWorkerTasks`: stub the dispatcher's
- *      `runDispatch` boundary (via a mocked `gsd-t-parallel.cjs` in
- *      require.cache) to execute tasks concurrently with
- *      `child_process.exec` + `Promise.all`. This measures the dispatch
- *      SCHEDULER's fan-out behaviour, not real headless claude-p spawns.
- *   3. Compute speedup and parallelism_factor. Pass iff speedup ≥ 2.5.
- *
- * Output: .gsd-t/metrics/m46-worker-proof.json + human summary on stdout.
- * Exit: 0 on pass, 1 on fail.
- */
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { exec, execSync } = require('child_process');
-
-const THRESHOLD = 2.5;
-const TASK_COUNT = 6;
-const PID = process.pid;
-const TMP_DIR = path.join(os.tmpdir(), `m46-proof-${PID}`);
-
-function ensureTmpDir() {
-  fs.mkdirSync(TMP_DIR, { recursive: true });
-}
-
-function cleanupTmpDir() {
-  try { fs.rmSync(TMP_DIR, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-function buildTasks() {
-  const tasks = [];
-  for (let i = 0; i < TASK_COUNT; i++) {
-    const outPath = path.join(TMP_DIR, `task-${i}.out`);
-    tasks.push({
-      taskId: `T-${i}`,
-      files: [outPath],
-      command: `sleep 2 && echo done > ${outPath}`,
-    });
-  }
-  return tasks;
-}
-
-// ── serial baseline ────────────────────────────────────────────────────────
-
-function runSerial(tasks) {
-  const perTaskMs = [];
-  const t0 = process.hrtime.bigint();
-  for (const task of tasks) {
-    const ts = process.hrtime.bigint();
-    execSync(task.command, { stdio: 'ignore' });
-    const te = process.hrtime.bigint();
-    perTaskMs.push(Number(te - ts) / 1e6);
-  }
-  const t1 = process.hrtime.bigint();
-  return {
-    wallClockMs: Number(t1 - t0) / 1e6,
-    perTaskMs,
-    meanTaskMs: perTaskMs.reduce((a, b) => a + b, 0) / perTaskMs.length,
-  };
-}
-
-// ── parallel via stubbed runDispatch ──────────────────────────────────────
-
-function installParallelStub() {
-  // Pre-populate require.cache for bin/gsd-t-parallel.cjs with a stub whose
-  // `runDispatch` executes the task `command` field concurrently via exec +
-  // Promise.all. This isolates measurement to the dispatcher scheduler and
-  // avoids invoking real claude-p children.
-  const parallelPath = require.resolve(path.join(__dirname, 'gsd-t-parallel.cjs'));
-  const stubModule = {
-    exports: {
-      runDispatch: async ({ tasks }) => {
-        const workerResults = await Promise.all(tasks.map((task) => new Promise((resolve) => {
-          const started = Date.now();
-          exec(task.command, (err) => {
-            resolve({
-              taskId: task.taskId,
-              exitCode: err ? (err.code || 1) : 0,
-              durationMs: Date.now() - started,
-            });
-          });
-        })));
-        return {
-          decision: 'fan-out',
-          fanOutCount: tasks.length,
-          workerResults,
-        };
-      },
-    },
-    loaded: true,
-    id: parallelPath,
-    filename: parallelPath,
-    paths: [],
-    children: [],
-  };
-  require.cache[parallelPath] = stubModule;
-}
-
-async function runParallel(tasks) {
-  installParallelStub();
-  // Fresh require after stub install, in case worker-dispatch was pre-loaded.
-  const dispatchPath = require.resolve(path.join(__dirname, 'gsd-t-worker-dispatch.cjs'));
-  delete require.cache[dispatchPath];
-  const { dispatchWorkerTasks } = require(dispatchPath);
-
-  const t0 = process.hrtime.bigint();
-  const result = await dispatchWorkerTasks({
-    projectDir: TMP_DIR,
-    parentSessionId: `m46-proof-${PID}`,
-    tasks,
-    maxParallel: TASK_COUNT,
-  });
-  const t1 = process.hrtime.bigint();
-
-  return {
-    wallClockMs: Number(t1 - t0) / 1e6,
-    parallel: result.parallel,
-    reason: result.reason,
-    taskResults: result.taskResults,
-  };
-}
-
-// ── main ────────────────────────────────────────────────────────────────────
-
-async function main() {
-  ensureTmpDir();
-  process.stdout.write(`M46-D2 Worker Sub-Dispatch Proof (N=${TASK_COUNT} tasks, tmp=${TMP_DIR})\n`);
-  process.stdout.write('─'.repeat(60) + '\n');
-
-  const tasks = buildTasks();
-
-  const serial = runSerial(tasks);
-  process.stdout.write('Serial baseline (execSync, tasks run back-to-back)\n');
-  process.stdout.write(`  T_serial (wall-clock): ${serial.wallClockMs.toFixed(1)} ms\n`);
-  process.stdout.write(`  per-task durations:    [${serial.perTaskMs.map((x) => x.toFixed(0)).join(', ')}] ms\n`);
-  process.stdout.write(`  mean(task duration):   ${serial.meanTaskMs.toFixed(1)} ms\n\n`);
-
-  // Reset task output files before parallel run so exec doesn't race on
-  // leftovers (each task writes its own file so this is just hygiene).
-  for (let i = 0; i < TASK_COUNT; i++) {
-    const p = path.join(TMP_DIR, `task-${i}.out`);
-    try { fs.unlinkSync(p); } catch (_) { /* ignore */ }
-  }
-
-  const parallel = await runParallel(tasks);
-  process.stdout.write(`Parallel via dispatchWorkerTasks (runDispatch stub, concurrent exec)\n`);
-  process.stdout.write(`  T_par (wall-clock):    ${parallel.wallClockMs.toFixed(1)} ms\n`);
-  process.stdout.write(`  parallel dispatched:   ${parallel.parallel} (reason=${parallel.reason})\n`);
-  process.stdout.write(`  per-task results:      ${parallel.taskResults.length} tasks\n\n`);
-
-  const speedup = serial.wallClockMs / parallel.wallClockMs;
-  const parallelismFactor = (TASK_COUNT * serial.meanTaskMs) / parallel.wallClockMs;
-  const passed = speedup >= THRESHOLD;
-
-  process.stdout.write('─'.repeat(60) + '\n');
-  process.stdout.write('Result\n');
-  process.stdout.write(`  speedup              = ${speedup.toFixed(2)}× (threshold ≥ ${THRESHOLD})\n`);
-  process.stdout.write(`  parallelism_factor   = ${parallelismFactor.toFixed(2)} (ideal = ${TASK_COUNT})\n`);
-  process.stdout.write(`  verdict              = ${passed ? 'PASS ✓' : 'FAIL ✗'}\n`);
-
-  const report = {
-    timestamp: new Date().toISOString(),
-    task_count: TASK_COUNT,
-    T_serial_ms: serial.wallClockMs,
-    T_par_ms: parallel.wallClockMs,
-    speedup,
-    parallelism_factor: parallelismFactor,
-    threshold: THRESHOLD,
-    passed,
-  };
-  const reportDir = path.join(process.cwd(), '.gsd-t', 'metrics');
-  fs.mkdirSync(reportDir, { recursive: true });
-  const reportPath = path.join(reportDir, 'm46-worker-proof.json');
-  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
-  process.stdout.write(`\nReport written: ${reportPath}\n`);
-
-  cleanupTmpDir();
-  process.exit(passed ? 0 : 1);
-}
-
-process.on('exit', cleanupTmpDir);
-process.on('SIGINT', () => { cleanupTmpDir(); process.exit(130); });
-process.on('SIGTERM', () => { cleanupTmpDir(); process.exit(143); });
-
-main().catch((e) => {
-  process.stderr.write(`ERROR: ${(e && e.stack) || e}\n`);
-  cleanupTmpDir();
-  process.exit(2);
-});