@tekyzinc/gsd-t 3.18.13 → 3.19.0

package/bin/gsd-t-worker-dispatch.cjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * GSD-T Worker Sub-Dispatch (M46 D2 T2)
+ *
+ * Thin adapter that lets an unattended supervisor worker fan out its own
+ * file-disjoint tasks by reusing the M44-verified `runDispatch` instrument.
+ * This module is a new CONSUMER of `bin/gsd-t-parallel.cjs::runDispatch` —
+ * not a modifier. The in-session dispatch path is byte-identical post-D2.
+ *
+ * Contract: .gsd-t/contracts/headless-default-contract.md v2.1.0 §Worker Sub-Dispatch
+ *
+ * Public API:
+ *   dispatchWorkerTasks({projectDir, parentSessionId, tasks, maxParallel})
+ *     → { parallel, taskResults, wallClockMs, reason }
+ *
+ * Triggers sub-dispatch when all hold:
+ *   - tasks.length > 1
+ *   - tasks are file-disjoint (pairwise no overlap on `task.files`)
+ * Otherwise returns `{parallel: false, …}` and the caller falls through to
+ * its current serial behavior.
+ */
+
+const path = require('path');
+
+const SPAWN_PLAN_KIND = 'unattended-worker-sub';
+const DEFAULT_MAX_PARALLEL = 4;
+
+/**
+ * Pairwise file-disjointness across a task set. Returns true iff no two
+ * tasks share any file in their `files` arrays. Tasks without a `files`
+ * array (or empty) are treated as having no declared file scope and
+ * therefore never overlap with anyone — callers upstream should not
+ * pass such tasks to sub-dispatch, but we remain conservative: a task
+ * with no `files` is considered disjoint from every other task only
+ * when every counterpart also has files declared. When both sides lack
+ * `files`, we conservatively report NOT disjoint so the caller falls
+ * back to serial — an undeclared scope is an unknown scope.
+ */
+function _areFileDisjoint(tasks) {
+  if (!Array.isArray(tasks) || tasks.length < 2) return true;
+  for (let i = 0; i < tasks.length; i++) {
+    const a = tasks[i];
+    const aFiles = (a && Array.isArray(a.files)) ? a.files : null;
+    for (let j = i + 1; j < tasks.length; j++) {
+      const b = tasks[j];
+      const bFiles = (b && Array.isArray(b.files)) ? b.files : null;
+      if (!aFiles || !bFiles) return false;
+      const set = new Set(aFiles);
+      for (const f of bFiles) {
+        if (set.has(f)) return false;
+      }
+    }
+  }
+  return true;
+}
+
+/**
+ * Emit a spawn-plan frame for this sub-dispatch. Best-effort; writer
+ * failures never propagate (per spawn-plan-writer.cjs §Hard rules).
+ */
+function _writeSubDispatchSpawnPlan({ projectDir, parentSessionId, tasks }) {
+  try {
+    const writer = require(path.join(__dirname, 'spawn-plan-writer.cjs'));
+    const spawnId = `worker-sub-${parentSessionId}-${Date.now()}`;
+    const planTasks = tasks.map((t) => ({
+      id: (t && typeof t.taskId === 'string') ? t.taskId : String((t && t.taskId) || ''),
+      title: (t && typeof t.title === 'string') ? t.title : '',
+      status: 'pending',
+    }));
+    writer.writeSpawnPlan({
+      spawnId,
+      kind: SPAWN_PLAN_KIND,
+      projectDir,
+      tasks: planTasks,
+    });
+  } catch (_e) {
+    /* best-effort; never block dispatch */
+  }
+}
+
+/**
+ * dispatchWorkerTasks — the M46 D2 sub-dispatch entry point.
+ *
+ * @param {object}   opts
+ * @param {string}   opts.projectDir        absolute project root
+ * @param {string}   opts.parentSessionId   $GSD_T_PARENT_AGENT_ID from worker env
+ * @param {Array}    opts.tasks             [{taskId, files, command, ...}]
+ * @param {number}   [opts.maxParallel=4]   concurrency cap (default matches M44)
+ * @returns {Promise<{parallel: boolean, taskResults: Array, wallClockMs: number, reason: string}>}
+ */
+async function dispatchWorkerTasks(opts) {
+  const projectDir = (opts && opts.projectDir) || process.cwd();
+  const parentSessionId = (opts && opts.parentSessionId) || '';
+  const tasks = (opts && Array.isArray(opts.tasks)) ? opts.tasks : [];
+  const maxParallel = Number.isFinite(opts && opts.maxParallel) && opts.maxParallel > 0
+    ? Math.floor(opts.maxParallel)
+    : DEFAULT_MAX_PARALLEL;
+
+  if (tasks.length === 0) {
+    return { parallel: false, taskResults: [], wallClockMs: 0, reason: 'no-tasks' };
+  }
+  if (tasks.length === 1) {
+    return { parallel: false, taskResults: [], wallClockMs: 0, reason: 'single-task' };
+  }
+  if (!_areFileDisjoint(tasks)) {
+    return { parallel: false, taskResults: [], wallClockMs: 0, reason: 'file-overlap' };
+  }
+
+  _writeSubDispatchSpawnPlan({ projectDir, parentSessionId, tasks });
+
+  const startedAt = Date.now();
+  try {
+    const parallel = require(path.join(__dirname, 'gsd-t-parallel.cjs'));
+    const result = await parallel.runDispatch({
+      projectDir,
+      tasks,
+      maxWorkers: maxParallel,
+      mode: 'worker-subdispatch',
+    });
+    const wallClockMs = Date.now() - startedAt;
+    const taskResults = (result && Array.isArray(result.workerResults))
+      ? result.workerResults
+      : (result && Array.isArray(result.taskResults) ? result.taskResults : []);
+    return {
+      parallel: true,
+      taskResults,
+      wallClockMs,
+      reason: 'dispatched',
+    };
+  } catch (e) {
+    const wallClockMs = Date.now() - startedAt;
+    const msg = (e && e.message) ? e.message : String(e);
+    return {
+      parallel: false,
+      taskResults: [],
+      wallClockMs,
+      reason: `dispatch-error: ${msg}`,
+    };
+  }
+}
+
+module.exports = {
+  dispatchWorkerTasks,
+  _areFileDisjoint,
+  SPAWN_PLAN_KIND,
+};
+
+if (require.main === module) {
+  (async () => {
+    const fs = require('fs');
+    const argv = process.argv.slice(2);
+    let parentSessionId = null;
+    let tasksPath = null;
+    let maxParallel = DEFAULT_MAX_PARALLEL;
+    for (let i = 0; i < argv.length; i++) {
+      const a = argv[i];
+      if (a === '--parent-session') {
+        parentSessionId = argv[++i];
+      } else if (a === '--tasks') {
+        tasksPath = argv[++i];
+      } else if (a === '--max-parallel') {
+        const n = parseInt(argv[++i], 10);
+        if (Number.isFinite(n) && n > 0) maxParallel = n;
+      }
+    }
+    if (!parentSessionId) {
+      process.stderr.write('error: --parent-session required\n');
+      process.exit(2);
+    }
+    if (!tasksPath) {
+      process.stderr.write('error: --tasks required\n');
+      process.exit(2);
+    }
+    let raw;
+    try {
+      raw = fs.readFileSync(tasksPath, 'utf8');
+    } catch (e) {
+      process.stderr.write(`error: cannot read tasks file ${tasksPath}: ${(e && e.message) || e}\n`);
+      process.exit(2);
+    }
+    let tasks;
+    try {
+      tasks = JSON.parse(raw);
+    } catch (e) {
+      process.stderr.write(`error: malformed tasks JSON: ${(e && e.message) || e}\n`);
+      process.exit(2);
+    }
+    if (!Array.isArray(tasks)) {
+      process.stderr.write('error: tasks JSON must be an array\n');
+      process.exit(2);
+    }
+    const projectDir = process.cwd();
+    try {
+      const result = await dispatchWorkerTasks({
+        projectDir,
+        parentSessionId,
+        tasks,
+        maxParallel,
+      });
+      process.stdout.write(JSON.stringify(result) + '\n');
+      const anyFailed = Array.isArray(result && result.taskResults)
+        && result.taskResults.some((r) => r && (r.exitCode !== 0 && r.exitCode != null));
+      process.exit(anyFailed ? 1 : 0);
+    } catch (e) {
+      process.stderr.write(`error: dispatch threw: ${(e && e.message) || e}\n`);
+      process.exit(1);
+    }
+  })();
+}

package/bin/headless-auto-spawn.cjs

@@ -73,7 +73,9 @@ let _deprecatedWatchWarned = false;
  *   sessionContext?: object,
  *   sessionId?: string,
  *   watch?: boolean,
- *   spawnType?: 'primary' | 'validation'
+ *   spawnType?: 'primary' | 'validation',
+ *   env?: object,
+ *   workerModel?: string
  * }} opts
  * @returns {{ id: string | null, pid: number | null, logPath: string | null, timestamp: string, mode: 'headless' | 'in-context' }}
  */
@@ -83,6 +85,12 @@ function autoSpawnHeadless(opts) {
   const continue_from = opts.continue_from || ".";
   const projectDir = opts.projectDir || process.cwd();
   const context = opts.context || opts.sessionContext || null;
+  // M44 D9 Step 3 — optional per-call env overrides layered over the inherited
+  // process.env. Used by `runDispatch` in gsd-t-parallel.cjs to forward
+  // GSD_T_WORKER_TASK_IDS / _WORKER_INDEX / _WORKER_TOTAL to each fan-out
+  // child so the child knows which task subset to handle. Purely additive —
+  // callers that don't pass `env` get the pre-M44-D9 behavior unchanged.
+  const envOverride = (opts.env && typeof opts.env === "object") ? opts.env : null;
   // M43 D4 — `watch` is accepted for caller backward-compat but IGNORED.
   // `inSession` was never shipped; accept+ignore for the same reason.
   // Under headless-default-contract v2.0.0 every spawn goes headless; the
@@ -129,6 +137,24 @@ function autoSpawnHeadless(opts) {
     /* best-effort; fall through without banner port info */
   }
 
+  // M46 follow-up — Date + version banner. Printed before the transcript URL
+  // so multi-day-old read-backs are immediately dated. Best-effort.
+  try {
+    const { dateStamp } = require("../scripts/gsd-t-update-check.js");
+    const fsLocal = require("fs");
+    const osLocal = require("os");
+    const pathLocal = require("path");
+    let v = "unknown";
+    try {
+      v = fsLocal.readFileSync(
+        pathLocal.join(osLocal.homedir(), ".claude/.gsd-t-version"), "utf8"
+      ).trim();
+    } catch (_) { /* fall through with "unknown" */ }
+    process.stdout.write(`${dateStamp()}GSD-T v${v} — CURRENT\n`);
+  } catch (_) {
+    /* best-effort — never crash the spawn on banner failure */
+  }
+
   // M43 D6-T3 — Live transcript URL banner. Printed for every spawn so the
   // viewer at :PORT is "the" primary watching surface. Never throws.
   // Text is coordinated with D4 — exact line shape is part of
@@ -195,6 +221,23 @@ function autoSpawnHeadless(opts) {
     if (process.env.GSD_T_AGENT_ID) {
       workerEnv.GSD_T_PARENT_AGENT_ID = process.env.GSD_T_AGENT_ID;
     }
+    // M44 D9 Step 3 — caller-supplied env overrides (e.g., fan-out task ids).
+    // Applied AFTER the canonical GSD_T_* keys so a caller can override any
+    // of them if needed; opaque for everything else.
+    if (envOverride) {
+      for (const [k, v] of Object.entries(envOverride)) {
+        if (v == null) continue;
+        workerEnv[k] = String(v);
+      }
+    }
+    // Worker-model override (v3.18.18) — let `runDispatch` fan-outs default to
+    // Sonnet while the orchestrator stays on whatever the parent runs (often
+    // Opus). Moves mechanical fan-out work onto a separate rate-limit bucket,
+    // raising the provider concurrency ceiling from ~3 to ~6+ per the
+    // Max-subscription concurrency analysis (2026-04-23).
+    if (typeof opts.workerModel === "string" && opts.workerModel) {
+      workerEnv.ANTHROPIC_MODEL = opts.workerModel;
+    }
 
     const child = spawn("node", childArgs, {
       cwd: projectDir,

package/bin/headless-exit-codes.cjs

@@ -19,29 +19,47 @@
 
 "use strict";
 
+// Match terminal markers, not narration. A bare "tests failed" substring will
+// appear in healthy output ("0 tests failed", "no tests failed", quoted as an
+// example in prose). Require either a non-zero count prefix or a structured
+// terminal marker (start of line, uppercase-FAIL prefix, Jest-style summary).
+// Bug history: M45 worker output contained "tests failed" 6× in narration,
+// causing the supervisor to map exit 0 → exit 1 and halt a successful run.
+
+const NONZERO_FAILURE_COUNT_RE =
+  /(?:^|\b)([1-9]\d*)\s+(?:tests?|specs?|assertions?|examples?|suites?)\s+failed\b/i;
+const STRUCTURED_FAIL_RE = /^FAIL[:\s]/m;
+const JEST_SUMMARY_FAIL_RE = /^Tests:\s+\d+\s+failed/im;
+
+// Verification-phrase matchers: require the phrase at a line boundary or
+// preceded by a sentence-start punctuation — not mid-prose. Each phrase is
+// distinctive enough that start-of-line / post-punctuation is a reliable
+// terminal-marker signal.
+const VERIFICATION_FAILED_RE =
+  /(?:^|[.!?]\s+)(?:verification|verify|quality gate)\s+failed\b/im;
+
+// Context-budget phrases — same polarity discipline. Tolerant of surrounding
+// punctuation (— / :) but requires the phrase at a line boundary.
+const CONTEXT_BUDGET_RE =
+  /(?:^|[.!?]\s+)(?:context budget exceeded|context window exceeded|budget exceeded|token limit)\b/im;
+
+// Blocker compound: "blocked" within 80 chars of a human-gate phrase, both
+// anchored to recognizable boundaries. The 80-char proximity keeps unrelated
+// mentions from compounding.
+const BLOCKED_HUMAN_RE =
+  /\bblocked\b[\s\S]{0,80}?\b(?:needs? human|human input|human approval)\b/i;
+
 function mapHeadlessExitCode(processExitCode, output) {
   if (processExitCode !== 0 && processExitCode !== null) return 3;
   const raw = output || "";
-  const lower = raw.toLowerCase();
   if (/^unknown command:/im.test(raw)) return 5;
+  if (CONTEXT_BUDGET_RE.test(raw)) return 2;
+  if (BLOCKED_HUMAN_RE.test(raw)) return 4;
   if (
-    lower.includes("context budget exceeded") ||
-    lower.includes("context window exceeded") ||
-    lower.includes("budget exceeded") ||
-    lower.includes("token limit")
-  ) return 2;
-  if (
-    lower.includes("blocked") &&
-    (lower.includes("needs human") ||
-      lower.includes("need human") ||
-      lower.includes("human input") ||
-      lower.includes("human approval"))
-  ) return 4;
-  if (
-    lower.includes("verification failed") ||
-    lower.includes("verify failed") ||
-    lower.includes("quality gate failed") ||
-    lower.includes("tests failed")
+    VERIFICATION_FAILED_RE.test(raw) ||
+    NONZERO_FAILURE_COUNT_RE.test(raw) ||
+    STRUCTURED_FAIL_RE.test(raw) ||
+    JEST_SUMMARY_FAIL_RE.test(raw)
   ) return 1;
   return 0;
 }

package/bin/m44-proof-measure.cjs

@@ -0,0 +1,285 @@
+#!/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); });