@elench/testkit 0.1.15 → 0.1.17

package/lib/runner.mjs

@@ -17,169 +17,802 @@ const TYPE_ORDER = ["dal", "integration", "e2e", "load"];
 const HTTP_K6_TYPES = new Set(["integration", "e2e", "load"]);
 const DEFAULT_READY_TIMEOUT_MS = 120_000;
 const PORT_STRIDE = 100;
+const TIMINGS_FILENAME = "timings.json";
+const GRAPH_METADATA = "graph.json";
 
 export async function runAll(configs, suiteType, suiteNames, opts, allConfigs = configs) {
   const configMap = new Map(allConfigs.map((config) => [config.name, config]));
-  const targetSpan = Math.max(1, opts.jobs || 1);
   const startedAt = Date.now();
-  const results = await Promise.all(
-    configs.map(async (config, targetSlot) => {
-      console.log(`\n══ ${config.name} ══`);
-      return runService(config, configMap, suiteType, suiteNames, opts, {
-        targetSlot,
-        targetSpan,
-      });
-    })
+  const servicePlans = collectServicePlans(configs, configMap, suiteType, suiteNames, opts);
+  const trackers = buildServiceTrackers(servicePlans, startedAt);
+  const executedPlans = servicePlans.filter((plan) => !plan.skipped);
+
+  if (executedPlans.length > 0) {
+    const productDir = executedPlans[0].config.productDir;
+    const timings = loadTimings(productDir);
+    const graphs = buildRuntimeGraphs(executedPlans);
+    const queue = buildTaskQueue(executedPlans, graphs, timings);
+    const workerCount = Math.max(1, Math.min(opts.jobs || 1, queue.length));
+    const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
+    const workers = Array.from({ length: workerCount }, (_unused, index) =>
+      createWorker(index + 1, productDir)
+    );
+    const timingUpdates = [];
+
+    const workerResults = await Promise.allSettled(
+      workers.map((worker) =>
+        runWorker(worker, queue, graphByKey, trackers, timingUpdates)
+      )
+    );
+
+    for (const result of workerResults) {
+      if (result.status === "rejected") {
+        const message = formatError(result.reason);
+        for (const tracker of trackers.values()) {
+          if (!tracker.skipped) addTrackerError(tracker, message);
+        }
+      }
+    }
+
+    saveTimings(productDir, timings, timingUpdates);
+  }
+
+  const finishedAt = Date.now();
+  const results = configs.map((config) =>
+    finalizeServiceResult(trackers.get(config.name), startedAt, finishedAt)
   );
 
-  printRunSummary(results, Date.now() - startedAt);
+  printRunSummary(results, finishedAt - startedAt);
   if (results.some((result) => result.failed)) process.exit(1);
 }
 
 export async function destroy(config) {
-  if (!fs.existsSync(config.stateDir)) return;
-
-  const runtimeStateDirs = findRuntimeStateDirs(config.stateDir);
-  for (const stateDir of runtimeStateDirs) {
-    await destroyRuntimeDatabase({
-      productDir: config.productDir,
-      stateDir,
-    });
+  const roots = new Set([config.stateDir, ...findGraphDirsForService(config.productDir, config.name)]);
+
+  for (const rootDir of roots) {
+    if (!fs.existsSync(rootDir)) continue;
+    const runtimeStateDirs = findRuntimeStateDirs(rootDir);
+    for (const stateDir of runtimeStateDirs) {
+      await destroyRuntimeDatabase({
+        productDir: config.productDir,
+        stateDir,
+      });
+    }
+    fs.rmSync(rootDir, { recursive: true, force: true });
   }
 
   await destroyServiceDatabaseCache(config.productDir, config.name);
-  fs.rmSync(config.stateDir, { recursive: true, force: true });
   await cleanupOrphanedLocalInfrastructure(config.productDir);
 }
 
 export function showStatus(config) {
-  if (!fs.existsSync(config.stateDir)) {
+  const graphDirs = findGraphDirsForService(config.productDir, config.name);
+  const hasDirectState = fs.existsSync(config.stateDir);
+  const hasGraphState = graphDirs.length > 0;
+
+  if (!hasDirectState && !hasGraphState) {
     console.log("No state — run tests first.");
   } else {
-    printStateDir(config.stateDir, "  ");
+    if (hasDirectState) {
+      console.log("  service-state/");
+      printStateDir(config.stateDir, "    ");
+    }
+    for (const graphDir of graphDirs) {
+      console.log(`  graph-state/${path.basename(graphDir)}/`);
+      printStateDir(graphDir, "    ");
+    }
   }
+
   showServiceDatabaseStatus(config.productDir, config.name);
 }
 
-async function runService(targetConfig, configMap, suiteType, suiteNames, opts, runtimeSlot) {
-  const startedAt = Date.now();
-  const suites = applyShard(
-    collectSuites(targetConfig, suiteType, suiteNames, opts.framework),
-    opts.shard
-  );
-  if (suites.length === 0) {
-    console.log(
-      `No test files for ${targetConfig.name} type="${suiteType}" suites=${suiteNames.join(",") || "all"} — skipping`
+function collectServicePlans(configs, configMap, suiteType, suiteNames, opts) {
+  return configs.map((config) => {
+    console.log(`\n══ ${config.name} ══`);
+    const suites = applyShard(
+      collectSuites(config, suiteType, suiteNames, opts.framework),
+      opts.shard
     );
+
+    if (suites.length === 0) {
+      console.log(
+        `No test files for ${config.name} type="${suiteType}" suites=${suiteNames.join(",") || "all"} — skipping`
+      );
+      return {
+        config,
+        skipped: true,
+        suites: [],
+        runtimeConfigs: [],
+        runtimeNames: [],
+        runtimeKey: null,
+      };
+    }
+
+    const runtimeConfigs = resolveRuntimeConfigs(config, configMap);
     return {
-      name: targetConfig.name,
-      failed: false,
-      skipped: true,
-      suiteCount: 0,
-      completedSuiteCount: 0,
-      failedSuiteCount: 0,
-      durationMs: Date.now() - startedAt,
-      workers: [],
+      config,
+      skipped: false,
+      suites,
+      runtimeConfigs,
+      runtimeNames: runtimeConfigs.map((runtimeConfig) => runtimeConfig.name).sort(),
+      runtimeKey: runtimeConfigs.map((runtimeConfig) => runtimeConfig.name).sort().join("|"),
+    };
+  });
+}
+
+function buildServiceTrackers(servicePlans, startedAt) {
+  const trackers = new Map();
+
+  for (const plan of servicePlans) {
+    if (plan.skipped) {
+      trackers.set(plan.config.name, {
+        name: plan.config.name,
+        skipped: true,
+        suiteCount: 0,
+        suites: [],
+        suitesByKey: new Map(),
+        errors: [],
+        errorSet: new Set(),
+        startedAt,
+        firstTaskAt: null,
+        lastTaskAt: null,
+      });
+      continue;
+    }
+
+    const suites = plan.suites.map((suite) => ({
+      key: `${suite.type}:${suite.name}`,
+      name: suite.name,
+      type: suite.type,
+      framework: suite.framework,
+      orderIndex: suite.orderIndex,
+      fileCount: suite.files.length,
+      completedFileCount: 0,
+      failedFiles: [],
+      failedFileSet: new Set(),
+      durationMs: 0,
+      error: null,
+    }));
+
+    trackers.set(plan.config.name, {
+      name: plan.config.name,
+      skipped: false,
+      suiteCount: suites.length,
+      suites,
+      suitesByKey: new Map(suites.map((suite) => [suite.key, suite])),
       errors: [],
+      errorSet: new Set(),
+      startedAt,
+      firstTaskAt: null,
+      lastTaskAt: null,
+    });
+  }
+
+  return trackers;
+}
+
+function buildRuntimeGraphs(servicePlans) {
+  const executed = servicePlans.filter((plan) => !plan.skipped);
+  const uniqueGraphs = [];
+  const graphByRuntimeKey = new Map();
+
+  for (const plan of executed) {
+    if (graphByRuntimeKey.has(plan.runtimeKey)) {
+      graphByRuntimeKey.get(plan.runtimeKey).exactTargets.push(plan.config.name);
+      continue;
+    }
+
+    const graph = {
+      key: plan.runtimeKey,
+      runtimeNames: plan.runtimeNames,
+      runtimeConfigs: plan.runtimeConfigs,
+      exactTargets: [plan.config.name],
+      assignedTargets: [],
+      dirName: null,
+      rootConfig: null,
     };
+    uniqueGraphs.push(graph);
+    graphByRuntimeKey.set(plan.runtimeKey, graph);
   }
 
-  const runtimeConfigs = resolveRuntimeConfigs(targetConfig, configMap);
-  fs.mkdirSync(targetConfig.stateDir, { recursive: true });
+  const maximalGraphs = uniqueGraphs.filter(
+    (graph) =>
+      !uniqueGraphs.some(
+        (other) =>
+          other.key !== graph.key &&
+          isRuntimeSuperset(other.runtimeNames, graph.runtimeNames)
+      )
+  );
+
+  for (const plan of executed) {
+    const compatible = maximalGraphs.filter((graph) =>
+      isRuntimeSuperset(graph.runtimeNames, plan.runtimeNames)
+    );
+    if (compatible.length === 0) {
+      throw new Error(`No runtime graph found for service "${plan.config.name}"`);
+    }
 
-  const jobs = Math.max(1, Math.min(opts.jobs || 1, suites.length));
-  const workerPlans = buildWorkerPlans(
-    targetConfig,
-    runtimeConfigs,
-    suites,
-    jobs,
-    runtimeSlot
+    const assigned = compatible.sort(compareGraphsForAssignment)[0];
+    plan.assignedGraphKey = assigned.key;
+    assigned.assignedTargets.push(plan.config.name);
+  }
+
+  for (const graph of maximalGraphs) {
+    const rootName = [...graph.exactTargets].sort()[0];
+    const rootPlan = executed.find((plan) => plan.config.name === rootName);
+    if (!rootPlan) {
+      throw new Error(`Missing root plan for graph "${graph.key}"`);
+    }
+    graph.rootConfig = rootPlan.config;
+    graph.dirName = buildGraphDirName(graph.runtimeNames);
+  }
+
+  return maximalGraphs.sort((a, b) => a.dirName.localeCompare(b.dirName));
+}
+
+function buildTaskQueue(servicePlans, graphs, timings) {
+  const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
+  const tasks = [];
+  let nextId = 1;
+
+  for (const plan of servicePlans) {
+    if (plan.skipped) continue;
+
+    const graph = graphByKey.get(plan.assignedGraphKey);
+    if (!graph) {
+      throw new Error(`Assigned graph "${plan.assignedGraphKey}" not found for ${plan.config.name}`);
+    }
+
+    for (const suite of plan.suites) {
+      for (const file of suite.files) {
+        const timingKey = buildTimingKey(plan.config.name, suite, file);
+        tasks.push({
+          id: nextId,
+          graphKey: graph.key,
+          targetName: plan.config.name,
+          serviceName: plan.config.name,
+          suiteKey: `${suite.type}:${suite.name}`,
+          suiteName: suite.name,
+          type: suite.type,
+          framework: suite.framework,
+          orderIndex: suite.orderIndex,
+          file,
+          timingKey,
+          estimatedDurationMs: estimateTaskDuration(timings, timingKey, suite),
+          maxBatchSize:
+            suite.framework === "playwright"
+              ? Number.POSITIVE_INFINITY
+              : suite.maxFileConcurrency || 1,
+        });
+        nextId += 1;
+      }
+    }
+  }
+
+  return tasks.sort(
+    (a, b) =>
+      b.estimatedDurationMs - a.estimatedDurationMs ||
+      a.serviceName.localeCompare(b.serviceName) ||
+      a.suiteKey.localeCompare(b.suiteKey) ||
+      a.file.localeCompare(b.file)
   );
+}
+
+function createWorker(workerId, productDir) {
+  return {
+    workerId,
+    productDir,
+    currentGraphKey: null,
+    graphContexts: new Map(),
+    graphSwitches: 0,
+    taskCount: 0,
+  };
+}
 
-  const results = await Promise.allSettled(workerPlans.map((plan) => runWorkerPlan(plan)));
-  let failed = false;
-  const workers = [];
+async function runWorker(worker, queue, graphByKey, trackers, timingUpdates) {
+  const startedAt = Date.now();
+  console.log(`\n══ global worker ${worker.workerId} ══`);
   const errors = [];
-  let failedSuiteCount = 0;
-  let completedSuiteCount = 0;
 
-  for (const result of results) {
-    if (result.status === "rejected") {
-      failed = true;
-      console.error(result.reason);
-      errors.push(formatError(result.reason));
-      continue;
+  try {
+    while (true) {
+      const batch = claimNextBatch(queue, worker.currentGraphKey);
+      if (!batch) break;
+
+      try {
+        const context = await ensureWorkerGraph(worker, batch, graphByKey);
+        const outcomes = await runBatch(context, batch);
+        for (const outcome of outcomes) {
+          recordTaskOutcome(trackers, outcome.task, outcome);
+          timingUpdates.push({
+            key: outcome.task.timingKey,
+            durationMs: outcome.durationMs,
+          });
+          worker.taskCount += 1;
+        }
+      } catch (error) {
+        const message = formatError(error);
+        errors.push(message);
+        recordGraphError(trackers, graphByKey.get(batch.graphKey), message);
+        await resetCurrentGraph(worker);
+      }
     }
-    workers.push(result.value);
-    completedSuiteCount += result.value.completedSuiteCount;
-    failedSuiteCount += result.value.failedSuiteCount;
-    if (result.value.failed) failed = true;
+  } finally {
+    await cleanupWorker(worker);
   }
 
   return {
-    name: targetConfig.name,
-    failed,
-    skipped: false,
-    suiteCount: suites.length,
-    completedSuiteCount,
-    failedSuiteCount,
+    workerId: worker.workerId,
+    failed: errors.length > 0,
     durationMs: Date.now() - startedAt,
-    workers,
+    taskCount: worker.taskCount,
+    graphSwitches: worker.graphSwitches,
     errors,
   };
 }
 
-function collectSuites(config, suiteType, suiteNames, frameworkFilter) {
-  const types =
-    suiteType === "all"
-      ? orderedTypes(Object.keys(config.suites))
-      : [suiteType === "int" ? "integration" : suiteType];
+function claimNextBatch(queue, preferredGraphKey) {
+  if (queue.length === 0) return null;
 
-  const selectedNames = new Set(suiteNames);
-  const suites = [];
-  let orderIndex = 0;
+  let index = -1;
+  if (preferredGraphKey) {
+    index = queue.findIndex((task) => task.graphKey === preferredGraphKey);
+  }
+  if (index === -1) index = 0;
 
-  for (const type of types) {
-    for (const suite of config.suites[type] || []) {
-      const framework = suite.framework || "k6";
-      if (selectedNames.size > 0 && !selectedNames.has(suite.name)) continue;
-      if (frameworkFilter && frameworkFilter !== "all" && framework !== frameworkFilter) continue;
+  const seed = queue.splice(index, 1)[0];
+  const tasks = [seed];
 
-      suites.push({
-        ...suite,
-        framework,
-        type,
-        orderIndex,
-        sortKey: `${type}:${suite.name}`,
-        weight:
-          suite.testkit?.weight ||
-          (framework === "playwright"
-            ? Math.max(2, suite.files.length)
-            : Math.max(1, suite.files.length)),
-        maxFileConcurrency:
-          framework === "k6" ? suite.testkit?.maxFileConcurrency || 1 : 1,
-      });
-      orderIndex += 1;
+  if (seed.framework === "playwright") {
+    for (let cursor = queue.length - 1; cursor >= 0; cursor -= 1) {
+      const candidate = queue[cursor];
+      if (
+        candidate.framework === "playwright" &&
+        candidate.graphKey === seed.graphKey &&
+        candidate.targetName === seed.targetName
+      ) {
+        tasks.push(candidate);
+        queue.splice(cursor, 1);
+      }
+    }
+  } else if (seed.maxBatchSize > 1) {
+    for (let cursor = queue.length - 1; cursor >= 0 && tasks.length < seed.maxBatchSize; cursor -= 1) {
+      const candidate = queue[cursor];
+      if (
+        candidate.framework === seed.framework &&
+        candidate.type === seed.type &&
+        candidate.graphKey === seed.graphKey &&
+        candidate.targetName === seed.targetName &&
+        candidate.suiteKey === seed.suiteKey
+      ) {
+        tasks.push(candidate);
+        queue.splice(cursor, 1);
+      }
     }
   }
 
-  return suites;
+  tasks.sort(
+    (a, b) =>
+      a.orderIndex - b.orderIndex ||
+      a.file.localeCompare(b.file)
+  );
+
+  return {
+    graphKey: seed.graphKey,
+    targetName: seed.targetName,
+    framework: seed.framework,
+    type: seed.type,
+    tasks,
+  };
 }
 
-function applyShard(suites, shard) {
-  if (!shard) return suites;
-  return suites.filter((_, index) => index % shard.total === shard.index - 1);
+async function ensureWorkerGraph(worker, batch, graphByKey) {
+  const graph = graphByKey.get(batch.graphKey);
+  if (!graph) {
+    throw new Error(`Unknown graph "${batch.graphKey}"`);
+  }
+
+  if (worker.currentGraphKey && worker.currentGraphKey !== batch.graphKey) {
+    await deactivateGraphContext(worker.graphContexts.get(worker.currentGraphKey));
+    worker.graphSwitches += 1;
+    worker.currentGraphKey = null;
+  }
+
+  let context = worker.graphContexts.get(batch.graphKey);
+  if (!context) {
+    context = createGraphContext(worker, graph);
+    worker.graphContexts.set(batch.graphKey, context);
+  }
+
+  if (!context.prepared) {
+    await prepareDatabases(context.runtimeConfigs);
+    context.prepared = true;
+  }
+
+  if (batchNeedsLocalRuntime(batch) && !context.started) {
+    context.startedServices = await startLocalServices(context.runtimeConfigs);
+    context.started = true;
+  }
+
+  worker.currentGraphKey = batch.graphKey;
+  return context;
 }
 
-function orderedTypes(types) {
-  const ordered = [];
-  for (const known of TYPE_ORDER) {
-    if (types.includes(known)) ordered.push(known);
+function createGraphContext(worker, graph) {
+  const graphDir = path.join(worker.productDir, ".testkit", "_graphs", graph.dirName);
+  const workerStateDir = path.join(graphDir, "workers", `worker-${worker.workerId}`);
+  fs.mkdirSync(workerStateDir, { recursive: true });
+  writeGraphMetadata(graphDir, graph);
+
+  const runtimeConfigs = resolveWorkerRuntimeConfigs(
+    graph.rootConfig,
+    graph.runtimeConfigs,
+    worker.workerId,
+    workerStateDir
+  );
+
+  return {
+    graphKey: graph.key,
+    graphDir,
+    workerStateDir,
+    runtimeConfigs,
+    configByName: new Map(runtimeConfigs.map((config) => [config.name, config])),
+    prepared: false,
+    started: false,
+    startedServices: [],
+  };
+}
+
+async function deactivateGraphContext(context) {
+  if (!context?.started) return;
+  await stopLocalServices(context.startedServices);
+  context.started = false;
+  context.startedServices = [];
+}
+
+async function resetCurrentGraph(worker) {
+  if (!worker.currentGraphKey) return;
+  await deactivateGraphContext(worker.graphContexts.get(worker.currentGraphKey));
+  worker.currentGraphKey = null;
+}
+
+async function cleanupWorker(worker) {
+  for (const context of worker.graphContexts.values()) {
+    await deactivateGraphContext(context);
   }
-  for (const type of types) {
-    if (!ordered.includes(type)) ordered.push(type);
+  worker.currentGraphKey = null;
+}
+
+async function runBatch(context, batch) {
+  const targetConfig = context.configByName.get(batch.targetName);
+  if (!targetConfig) {
+    throw new Error(`Worker graph missing target config "${batch.targetName}"`);
   }
-  return ordered;
+
+  if (batch.framework === "playwright") {
+    return runPlaywrightBatch(targetConfig, batch);
+  }
+  if (batch.type === "dal") {
+    return runDalBatch(targetConfig, batch);
+  }
+  if (batch.framework === "k6" && HTTP_K6_TYPES.has(batch.type)) {
+    return runHttpK6Batch(targetConfig, batch);
+  }
+
+  throw new Error(
+    `Unsupported task combination for ${batch.targetName}: type=${batch.type} framework=${batch.framework}`
+  );
+}
+
+async function prepareDatabases(runtimeConfigs) {
+  for (const config of runtimeConfigs) {
+    await prepareDatabaseRuntime(config, {
+      runMigrate: config.testkit.migrate
+        ? (databaseUrl) => runMigrate(config, databaseUrl)
+        : null,
+      runSeed: config.testkit.seed ? (databaseUrl) => runSeed(config, databaseUrl) : null,
+    });
+  }
+}
+
+async function runMigrate(config, databaseUrl) {
+  const migrate = config.testkit.migrate;
+  if (!migrate) return;
+
+  const env = buildExecutionEnv(config);
+  if (databaseUrl) env.DATABASE_URL = databaseUrl;
+
+  console.log(`\n── migrate:${config.workerLabel}:${config.name} ──`);
+  await execaCommand(migrate.cmd, {
+    cwd: resolveServiceCwd(config.productDir, migrate.cwd),
+    env,
+    stdio: "inherit",
+    shell: true,
+  });
+}
+
+async function runSeed(config, databaseUrl) {
+  const seed = config.testkit.seed;
+  if (!seed) return;
+
+  const env = buildExecutionEnv(config);
+  if (databaseUrl) env.DATABASE_URL = databaseUrl;
+
+  console.log(`\n── seed:${config.workerLabel}:${config.name} ──`);
+  await execaCommand(seed.cmd, {
+    cwd: resolveServiceCwd(config.productDir, seed.cwd),
+    env,
+    stdio: "inherit",
+    shell: true,
+  });
+}
+
+async function startLocalServices(runtimeConfigs) {
+  const started = [];
+
+  try {
+    for (const config of runtimeConfigs) {
+      if (!config.testkit.local) continue;
+      const proc = await startLocalService(config);
+      started.push(proc);
+    }
+  } catch (error) {
+    await stopLocalServices(started);
+    throw error;
+  }
+
+  return started;
+}
+
+async function startLocalService(config) {
+  const cwd = resolveServiceCwd(config.productDir, config.testkit.local.cwd);
+  const env = buildExecutionEnv(config, config.testkit.local.env);
+  const port = config.testkit.local.port || numericPortFromUrl(config.testkit.local.baseUrl);
+  if (port) {
+    env.PORT = String(port);
+  }
+
+  const dbUrl = readDatabaseUrl(config.stateDir);
+  if (dbUrl) {
+    env.DATABASE_URL = dbUrl;
+  }
+
+  await assertLocalServicePortsAvailable(config);
+
+  console.log(`Starting ${config.workerLabel}:${config.name}: ${config.testkit.local.start}`);
+  const child = spawn(config.testkit.local.start, {
+    cwd,
+    env,
+    detached: true,
+    shell: true,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  const outputDrains = [
+    pipeOutput(child.stdout, `[${config.workerLabel}:${config.name}]`),
+    pipeOutput(child.stderr, `[${config.workerLabel}:${config.name}]`),
+  ];
+
+  const readyTimeoutMs = config.testkit.local.readyTimeoutMs || DEFAULT_READY_TIMEOUT_MS;
+
+  try {
+    await waitForReady({
+      name: `${config.workerLabel}:${config.name}`,
+      url: config.testkit.local.readyUrl,
+      timeoutMs: readyTimeoutMs,
+      process: child,
+    });
+  } catch (error) {
+    await stopChildProcess(child, outputDrains);
+    throw error;
+  }
+
+  return { name: config.name, child, outputDrains };
+}
+
+async function runHttpK6Batch(targetConfig, batch) {
+  const baseUrl = targetConfig.testkit.local?.baseUrl;
+  if (!baseUrl) {
+    throw new Error(`Service "${targetConfig.name}" requires local.baseUrl for HTTP k6 suites`);
+  }
+
+  console.log(
+    `\n── ${targetConfig.workerLabel} ${batch.type}:${batch.tasks[0].suiteName} (${batch.framework}, ${batch.tasks.length} file${batch.tasks.length === 1 ? "" : "s"}) ──`
+  );
+
+  return Promise.all(
+    batch.tasks.map((task) => runHttpK6Task(targetConfig, task, baseUrl))
+  );
+}
+
+async function runHttpK6Task(targetConfig, task, baseUrl) {
+  const absFile = path.join(targetConfig.productDir, task.file);
+  console.log(`·· ${targetConfig.workerLabel}:${task.suiteName} → ${task.file}`);
+  const startedAt = Date.now();
+  try {
+    await execa("k6", ["run", "--address", "127.0.0.1:0", "-e", `BASE_URL=${baseUrl}`, absFile], {
+      cwd: targetConfig.productDir,
+      env: buildExecutionEnv(targetConfig),
+      stdio: "inherit",
+    });
+    return {
+      task,
+      failed: false,
+      error: null,
+      durationMs: Date.now() - startedAt,
+    };
+  } catch (error) {
+    return {
+      task,
+      failed: true,
+      error: formatError(error),
+      durationMs: Date.now() - startedAt,
+    };
+  }
+}
+
+async function runDalBatch(targetConfig, batch) {
+  const databaseUrl = readDatabaseUrl(targetConfig.stateDir);
+  if (!databaseUrl) {
+    throw new Error(`Service "${targetConfig.name}" requires a database for DAL suites`);
+  }
+
+  console.log(
+    `\n── ${targetConfig.workerLabel} ${batch.type}:${batch.tasks[0].suiteName} (${batch.framework}, ${batch.tasks.length} file${batch.tasks.length === 1 ? "" : "s"}) ──`
+  );
+
+  return Promise.all(
+    batch.tasks.map((task) => runDalTask(targetConfig, task, databaseUrl))
+  );
+}
+
+async function runDalTask(targetConfig, task, databaseUrl) {
+  const absFile = path.join(targetConfig.productDir, task.file);
+  const k6Binary = resolveDalBinary();
+  console.log(`·· ${targetConfig.workerLabel}:${task.suiteName} → ${task.file}`);
+  const startedAt = Date.now();
+  try {
+    await execa(
+      k6Binary,
+      ["run", "--address", "127.0.0.1:0", "-e", `DATABASE_URL=${databaseUrl}`, absFile],
+      {
+      cwd: targetConfig.productDir,
+      env: buildExecutionEnv(targetConfig),
+      stdio: "inherit",
+      }
+    );
+    return {
+      task,
+      failed: false,
+      error: null,
+      durationMs: Date.now() - startedAt,
+    };
+  } catch (error) {
+    return {
+      task,
+      failed: true,
+      error: formatError(error),
+      durationMs: Date.now() - startedAt,
+    };
+  }
+}
+
+async function runPlaywrightBatch(targetConfig, batch) {
+  const local = targetConfig.testkit.local;
+  if (!local?.baseUrl) {
+    throw new Error(
+      `Service "${targetConfig.name}" requires local.baseUrl for Playwright suites`
+    );
+  }
+
+  console.log(
+    `\n── ${targetConfig.workerLabel} playwright:${targetConfig.name} (${batch.tasks.length} file${batch.tasks.length === 1 ? "" : "s"}) ──`
+  );
+
+  const cwd = resolveServiceCwd(targetConfig.productDir, local.cwd);
+  const requestedFiles = batch.tasks.map((task) =>
+    path.relative(cwd, path.join(targetConfig.productDir, task.file))
+  );
+  const startedAt = Date.now();
+  const result = await execa(
+    "npx",
+    ["playwright", "test", "--reporter=json", ...requestedFiles],
+    {
+      cwd,
+      env: buildPlaywrightEnv(targetConfig, local.baseUrl),
+      reject: false,
+    }
+  );
+
+  if (result.stderr) {
+    printBufferedOutput(result.stderr, `[${targetConfig.workerLabel}:${targetConfig.name}:playwright]`);
+  }
+
+  const parsed = parsePlaywrightJsonResults(result.stdout, cwd);
+  const batchDurationMs = Date.now() - startedAt;
+  const genericError =
+    result.exitCode === 0
+      ? parsed.errors[0] || null
+      : parsed.errors[0] ||
+        result.stderr.trim() ||
+        `Playwright exited with code ${result.exitCode}`;
+
+  return batch.tasks.map((task) => {
+    const relativeFile = normalizePathSeparators(
+      path.relative(cwd, path.join(targetConfig.productDir, task.file))
+    );
+    const fileResult = parsed.fileResults.get(relativeFile);
+    if (fileResult) {
+      return {
+        task,
+        failed: fileResult.failed,
+        error: fileResult.error,
+        durationMs:
+          fileResult.durationMs > 0
+            ? fileResult.durationMs
+            : Math.round(batchDurationMs / Math.max(1, batch.tasks.length)),
+      };
+    }
+
+    return {
+      task,
+      failed: result.exitCode !== 0,
+      error: result.exitCode !== 0 ? genericError : null,
+      durationMs: Math.round(batchDurationMs / Math.max(1, batch.tasks.length)),
+    };
+  });
+}
+
+async function stopLocalServices(started) {
+  for (const service of [...started].reverse()) {
+    await stopChildProcess(service.child, service.outputDrains);
+  }
+}
+
+async function stopChildProcess(child, outputDrains = []) {
+  if (!child) return;
+  if (child.exitCode !== null) {
+    await Promise.all(outputDrains);
+    return;
+  }
+
+  killChildProcess(child, "SIGTERM");
+  const exited = await Promise.race([
+    new Promise((resolve) => child.once("exit", () => resolve(true))),
+    sleep(5_000).then(() => false),
+  ]);
+
+  if (!exited && child.exitCode === null) {
+    killChildProcess(child, "SIGKILL");
+    await new Promise((resolve) => child.once("exit", resolve));
+  }
+
+  await Promise.all(outputDrains);
+}
+
+async function waitForReady({ name, url, timeoutMs, process }) {
+  const start = Date.now();
+
+  while (Date.now() - start < timeoutMs) {
+    if (process.exitCode !== null) {
+      throw new Error(`Service "${name}" exited before becoming ready`);
+    }
+
+    try {
+      const response = await fetch(url);
+      if (response.ok) return;
+    } catch {
+      // Service still warming up.
+    }
+
+    await sleep(1_000);
+  }
+
+  throw new Error(`Timed out waiting for "${name}" to become ready at ${url}`);
+}
+
+function batchNeedsLocalRuntime(batch) {
+  return batch.tasks.some((task) => task.type !== "dal");
 }
 
 function resolveRuntimeConfigs(targetConfig, configMap) {
@@ -210,81 +843,61 @@ function resolveRuntimeConfigs(targetConfig, configMap) {
   return ordered;
 }
 
-function buildWorkerPlans(targetConfig, runtimeConfigs, suites, jobs, runtimeSlot) {
-  const buckets = distributeSuites(suites, jobs);
-  return buckets
-    .map((bucket, index) =>
-      createWorkerPlan(targetConfig, runtimeConfigs, bucket.suites, index + 1, runtimeSlot)
-    )
-    .filter(Boolean);
-}
-
-function distributeSuites(suites, jobs) {
-  const buckets = Array.from({ length: jobs }, () => ({
-    suites: [],
-    totalWeight: 0,
-  }));
-  const ordered = [...suites].sort(
-    (a, b) => b.weight - a.weight || a.sortKey.localeCompare(b.sortKey)
-  );
+function collectSuites(config, suiteType, suiteNames, frameworkFilter) {
+  const types =
+    suiteType === "all"
+      ? orderedTypes(Object.keys(config.suites))
+      : [suiteType === "int" ? "integration" : suiteType];
 
-  for (const suite of ordered) {
-    let bestBucket = buckets[0];
-    for (const bucket of buckets.slice(1)) {
-      if (bucket.totalWeight < bestBucket.totalWeight) {
-        bestBucket = bucket;
-        continue;
-      }
-      if (
-        bucket.totalWeight === bestBucket.totalWeight &&
-        bucket.suites.length < bestBucket.suites.length
-      ) {
-        bestBucket = bucket;
-      }
-    }
+  const selectedNames = new Set(suiteNames);
+  const suites = [];
+  let orderIndex = 0;
 
-    bestBucket.suites.push(suite);
-    bestBucket.totalWeight += suite.weight;
-  }
+  for (const type of types) {
+    for (const suite of config.suites[type] || []) {
+      const framework = suite.framework || "k6";
+      if (selectedNames.size > 0 && !selectedNames.has(suite.name)) continue;
+      if (frameworkFilter && frameworkFilter !== "all" && framework !== frameworkFilter) continue;
 
-  for (const bucket of buckets) {
-    bucket.suites.sort((a, b) => a.orderIndex - b.orderIndex);
+      suites.push({
+        ...suite,
+        framework,
+        type,
+        orderIndex,
+        sortKey: `${type}:${suite.name}`,
+        weight:
+          suite.testkit?.weight ||
+          (framework === "playwright"
+            ? Math.max(2, suite.files.length)
+            : Math.max(1, suite.files.length)),
+        maxFileConcurrency:
+          framework === "k6" ? suite.testkit?.maxFileConcurrency || 1 : 1,
+      });
+      orderIndex += 1;
+    }
   }
 
-  return buckets.filter((bucket) => bucket.suites.length > 0);
+  return suites;
 }
 
-function createWorkerPlan(targetConfig, runtimeConfigs, suites, workerId, runtimeSlot) {
-  if (suites.length === 0) return null;
-
-  const workerStateDir = path.join(targetConfig.stateDir, "workers", `worker-${workerId}`);
-  const workerRuntimeConfigs = resolveWorkerRuntimeConfigs(
-    targetConfig,
-    runtimeConfigs,
-    workerId,
-    workerStateDir,
-    runtimeSlot
-  );
-  const workerTargetConfig = workerRuntimeConfigs.find(
-    (config) => config.name === targetConfig.name
-  );
+function applyShard(suites, shard) {
+  if (!shard) return suites;
+  return suites.filter((unused, index) => index % shard.total === shard.index - 1);
+}
 
-  return {
-    workerId,
-    suites,
-    runtimeConfigs: workerRuntimeConfigs,
-    targetConfig: workerTargetConfig,
-  };
+function orderedTypes(types) {
+  const ordered = [];
+  for (const known of TYPE_ORDER) {
+    if (types.includes(known)) ordered.push(known);
+  }
+  for (const type of types) {
+    if (!ordered.includes(type)) ordered.push(type);
+  }
+  return ordered;
 }
 
-function resolveWorkerRuntimeConfigs(
-  targetConfig,
-  runtimeConfigs,
-  workerId,
-  workerStateDir,
-  runtimeSlot
-) {
-  const portMap = buildPortMap(runtimeConfigs, workerId, runtimeSlot);
+function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, workerId, workerStateDir) {
+  const portMap = buildPortMap(runtimeConfigs, workerId);
   const baseUrlByService = new Map();
   const readyUrlByService = new Map();
 
@@ -337,10 +950,10 @@ function resolveWorkerRuntimeConfigs(
   );
 }
 
-function buildPortMap(runtimeConfigs, workerId, runtimeSlot) {
+function buildPortMap(runtimeConfigs, workerId) {
   const portMap = new Map();
   const seen = new Map();
-  const offset = PORT_STRIDE * ((workerId - 1) + runtimeSlot.targetSlot * runtimeSlot.targetSpan);
+  const offset = PORT_STRIDE * (workerId - 1);
 
   for (const config of runtimeConfigs) {
     if (!config.testkit.local) continue;
@@ -435,328 +1048,25 @@ function resolveWorkerConfig(
           Object.entries(config.testkit.local.env || {}).map(([key, value]) => [
             key,
             finalizeString(String(value), context),
-          ])
-        ),
-      }
-    : undefined;
-
-  return {
-    ...config,
-    stateDir,
-    workerId,
-    workerLabel: `w${workerId}`,
-    targetName: targetConfig.name,
-    testkit: {
-      ...config.testkit,
-      database,
-      migrate,
-      seed,
-      local,
-    },
-  };
-}
-
-async function runWorkerPlan(plan) {
-  const startedAt = Date.now();
-  console.log(
-    `\n══ ${plan.targetConfig.name} worker ${plan.workerId} (${plan.suites.length} suite${plan.suites.length === 1 ? "" : "s"}) ══`
-  );
-
-  let startedServices = [];
-  let failed = false;
-  const suiteResults = [];
-  let fatalError = null;
-
-  try {
-    await prepareDatabases(plan.runtimeConfigs);
-
-    if (needsLocalRuntime(plan.suites)) {
-      startedServices = await startLocalServices(plan.runtimeConfigs);
-    }
-
-    for (const suite of plan.suites) {
-      console.log(
-        `\n── ${plan.targetConfig.workerLabel} ${suite.type}:${suite.name} (${suite.framework}) ──`
-      );
-      const result = await runSuite(plan.targetConfig, suite);
-      suiteResults.push(result);
-      if (result.failed) failed = true;
-    }
-  } catch (error) {
-    fatalError = error;
-    failed = true;
-    throw error;
-  } finally {
-    await stopLocalServices(startedServices);
-  }
-
-  return {
-    workerId: plan.workerId,
-    failed,
-    fatalError: fatalError ? formatError(fatalError) : null,
-    durationMs: Date.now() - startedAt,
-    suiteCount: plan.suites.length,
-    completedSuiteCount: suiteResults.length,
-    failedSuiteCount: suiteResults.filter((result) => result.failed).length,
-    suites: suiteResults,
-  };
-}
-
-async function prepareDatabases(runtimeConfigs) {
-  for (const config of runtimeConfigs) {
-    await prepareDatabaseRuntime(config, {
-      runMigrate: config.testkit.migrate
-        ? (databaseUrl) => runMigrate(config, databaseUrl)
-        : null,
-      runSeed: config.testkit.seed ? (databaseUrl) => runSeed(config, databaseUrl) : null,
-    });
-  }
-}
-
-async function runMigrate(config, databaseUrl) {
-  const migrate = config.testkit.migrate;
-  if (!migrate) return;
-
-  const env = buildExecutionEnv(config);
-  if (databaseUrl) env.DATABASE_URL = databaseUrl;
-
-  console.log(`\n── migrate:${config.workerLabel}:${config.name} ──`);
-  await execaCommand(migrate.cmd, {
-    cwd: resolveServiceCwd(config.productDir, migrate.cwd),
-    env,
-    stdio: "inherit",
-    shell: true,
-  });
-}
-
-async function runSeed(config, databaseUrl) {
-  const seed = config.testkit.seed;
-  if (!seed) return;
-
-  const env = buildExecutionEnv(config);
-  if (databaseUrl) env.DATABASE_URL = databaseUrl;
-
-  console.log(`\n── seed:${config.workerLabel}:${config.name} ──`);
-  await execaCommand(seed.cmd, {
-    cwd: resolveServiceCwd(config.productDir, seed.cwd),
-    env,
-    stdio: "inherit",
-    shell: true,
-  });
-}
-
-async function startLocalServices(runtimeConfigs) {
-  const started = [];
-
-  try {
-    for (const config of runtimeConfigs) {
-      if (!config.testkit.local) continue;
-      const proc = await startLocalService(config);
-      started.push(proc);
-    }
-  } catch (error) {
-    await stopLocalServices(started);
-    throw error;
-  }
-
-  return started;
-}
-
-async function startLocalService(config) {
-  const cwd = resolveServiceCwd(config.productDir, config.testkit.local.cwd);
-  const env = buildExecutionEnv(config, config.testkit.local.env);
-  const port = config.testkit.local.port || numericPortFromUrl(config.testkit.local.baseUrl);
-  if (port) {
-    env.PORT = String(port);
-  }
-
-  const dbUrl = readDatabaseUrl(config.stateDir);
-  if (dbUrl) {
-    env.DATABASE_URL = dbUrl;
-  }
-
-  await assertLocalServicePortsAvailable(config);
-
-  console.log(`Starting ${config.workerLabel}:${config.name}: ${config.testkit.local.start}`);
-  const child = spawn(config.testkit.local.start, {
-    cwd,
-    env,
-    detached: true,
-    shell: true,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  const outputDrains = [
-    pipeOutput(child.stdout, `[${config.workerLabel}:${config.name}]`),
-    pipeOutput(child.stderr, `[${config.workerLabel}:${config.name}]`),
-  ];
-
-  const readyTimeoutMs = config.testkit.local.readyTimeoutMs || DEFAULT_READY_TIMEOUT_MS;
-
-  try {
-    await waitForReady({
-      name: `${config.workerLabel}:${config.name}`,
-      url: config.testkit.local.readyUrl,
-      timeoutMs: readyTimeoutMs,
-      process: child,
-    });
-  } catch (error) {
-    await stopChildProcess(child, outputDrains);
-    throw error;
-  }
-
-  return { name: config.name, child, outputDrains };
-}
-
-async function runSuite(targetConfig, suite) {
-  if (suite.type === "dal") {
-    return runDalSuite(targetConfig, suite);
-  }
-
-  if (suite.framework === "playwright") {
-    return runPlaywrightSuite(targetConfig, suite);
-  }
-
-  if (suite.framework === "k6" && HTTP_K6_TYPES.has(suite.type)) {
-    return runHttpK6Suite(targetConfig, suite);
-  }
-
-  throw new Error(
-    `Unsupported suite combination for ${targetConfig.name}: type=${suite.type} framework=${suite.framework}`
-  );
-}
-
-async function runHttpK6Suite(targetConfig, suite) {
-  const baseUrl = targetConfig.testkit.local?.baseUrl;
-  if (!baseUrl) {
-    throw new Error(`Service "${targetConfig.name}" requires local.baseUrl for HTTP k6 suites`);
-  }
-
-  const startedAt = Date.now();
-  let failed = false;
-  const failedFiles = [];
-  await runWithConcurrency(suite.files, suite.maxFileConcurrency, async (file) => {
-    const absFile = path.join(targetConfig.productDir, file);
-    console.log(`·· ${targetConfig.workerLabel}:${suite.name} → ${file}`);
-    try {
-      await execa("k6", ["run", "-e", `BASE_URL=${baseUrl}`, absFile], {
-        cwd: targetConfig.productDir,
-        env: buildExecutionEnv(targetConfig),
-        stdio: "inherit",
-      });
-    } catch {
-      failed = true;
-      failedFiles.push(file);
-    }
-  });
-
-  return buildSuiteResult(suite, failed, startedAt, failedFiles);
-}
-
-async function runDalSuite(targetConfig, suite) {
-  const databaseUrl = readDatabaseUrl(targetConfig.stateDir);
-  if (!databaseUrl) {
-    throw new Error(`Service "${targetConfig.name}" requires a database for DAL suites`);
-  }
-
-  const k6Binary = resolveDalBinary();
-  const startedAt = Date.now();
-  let failed = false;
-  const failedFiles = [];
-  await runWithConcurrency(suite.files, suite.maxFileConcurrency, async (file) => {
-    const absFile = path.join(targetConfig.productDir, file);
-    console.log(`·· ${targetConfig.workerLabel}:${suite.name} → ${file}`);
-    try {
-      await execa(k6Binary, ["run", "-e", `DATABASE_URL=${databaseUrl}`, absFile], {
-        cwd: targetConfig.productDir,
-        env: buildExecutionEnv(targetConfig),
-        stdio: "inherit",
-      });
-    } catch {
-      failed = true;
-      failedFiles.push(file);
-    }
-  });
-
-  return buildSuiteResult(suite, failed, startedAt, failedFiles);
-}
-
-async function runPlaywrightSuite(targetConfig, suite) {
-  const local = targetConfig.testkit.local;
-  if (!local?.baseUrl) {
-    throw new Error(
-      `Service "${targetConfig.name}" requires local.baseUrl for Playwright suites`
-    );
-  }
-
-  const cwd = resolveServiceCwd(targetConfig.productDir, local.cwd);
-  const files = suite.files.map((file) =>
-    path.relative(cwd, path.join(targetConfig.productDir, file))
-  );
-  const startedAt = Date.now();
-
-  try {
-    await execa("npx", ["playwright", "test", ...files], {
-      cwd,
-      env: buildPlaywrightEnv(targetConfig, local.baseUrl),
-      stdio: "inherit",
-    });
-    return buildSuiteResult(suite, false, startedAt);
-  } catch {
-    return buildSuiteResult(suite, true, startedAt);
-  }
-}
-
-async function stopLocalServices(started) {
-  for (const service of [...started].reverse()) {
-    await stopChildProcess(service.child, service.outputDrains);
-  }
-}
-
-async function stopChildProcess(child, outputDrains = []) {
-  if (!child) return;
-  if (child.exitCode !== null) {
-    await Promise.all(outputDrains);
-    return;
-  }
-
-  killChildProcess(child, "SIGTERM");
-  const exited = await Promise.race([
-    new Promise((resolve) => child.once("exit", () => resolve(true))),
-    sleep(5_000).then(() => false),
-  ]);
-
-  if (!exited && child.exitCode === null) {
-    killChildProcess(child, "SIGKILL");
-    await new Promise((resolve) => child.once("exit", resolve));
-  }
-
-  await Promise.all(outputDrains);
-}
-
-async function waitForReady({ name, url, timeoutMs, process }) {
-  const start = Date.now();
-
-  while (Date.now() - start < timeoutMs) {
-    if (process.exitCode !== null) {
-      throw new Error(`Service "${name}" exited before becoming ready`);
-    }
-
-    try {
-      const response = await fetch(url);
-      if (response.ok) return;
-    } catch {
-      // Service still warming up.
-    }
-
-    await sleep(1_000);
-  }
-
-  throw new Error(`Timed out waiting for "${name}" to become ready at ${url}`);
-}
+          ])
+        ),
+      }
+    : undefined;
 
-function needsLocalRuntime(suites) {
-  return suites.some((suite) => suite.type !== "dal");
+  return {
+    ...config,
+    stateDir,
+    workerId,
+    workerLabel: `w${workerId}`,
+    targetName: targetConfig.name,
+    testkit: {
+      ...config.testkit,
+      database,
+      migrate,
+      seed,
+      local,
+    },
+  };
 }
 
 function resolveServiceStateDir(workerStateDir, targetName, config) {
@@ -780,7 +1090,7 @@ function buildExecutionEnv(config, extraEnv = {}) {
 }
 
 function buildPlaywrightEnv(config, baseUrl) {
-  const env = buildExecutionEnv(config, {
+  return buildExecutionEnv(config, {
     BASE_URL: baseUrl,
     PLAYWRIGHT_HTML_OPEN: "never",
     PLAYWRIGHT_SKIP_VALIDATE_HOST_REQUIREMENTS:
@@ -788,36 +1098,97 @@ function buildPlaywrightEnv(config, baseUrl) {
     TESTKIT_MANAGED_SERVERS: "1",
     TESTKIT_WORKER_ID: String(config.workerId),
   });
+}
 
-  const browsersPath = resolvePlaywrightBrowsersPath(env.PLAYWRIGHT_BROWSERS_PATH);
-  if (browsersPath) {
-    env.PLAYWRIGHT_BROWSERS_PATH = browsersPath;
-  }
+function recordTaskOutcome(trackers, task, outcome) {
+  const tracker = trackers.get(task.serviceName);
+  if (!tracker || tracker.skipped) return;
 
-  return env;
+  const finishedAt = Date.now();
+  if (!tracker.firstTaskAt) tracker.firstTaskAt = finishedAt;
+  tracker.lastTaskAt = finishedAt;
+
+  const suite = tracker.suitesByKey.get(task.suiteKey);
+  if (!suite) return;
+
+  suite.completedFileCount += 1;
+  suite.durationMs += outcome.durationMs;
+  if (outcome.failed && !suite.failedFileSet.has(task.file)) {
+    suite.failedFileSet.add(task.file);
+    suite.failedFiles.push(task.file);
+  }
+  if (outcome.error && !suite.error) {
+    suite.error = outcome.error;
+  }
 }
 
-function resolvePlaywrightBrowsersPath(configuredPath) {
-  const home = process.env.HOME;
-  if (home) {
-    const fallback = path.join(home, ".cache", "ms-playwright");
-    if (fs.existsSync(fallback)) {
-      return fallback;
+function recordGraphError(trackers, graph, message) {
+  const targetNames = graph?.assignedTargets || [];
+  for (const targetName of targetNames) {
+    const tracker = trackers.get(targetName);
+    if (tracker && !tracker.skipped) {
+      addTrackerError(tracker, message);
+      tracker.lastTaskAt = Date.now();
     }
   }
+}
 
-  return configuredPath;
+function addTrackerError(tracker, message) {
+  if (tracker.errorSet.has(message)) return;
+  tracker.errorSet.add(message);
+  tracker.errors.push(message);
 }
 
-function buildSuiteResult(suite, failed, startedAt, failedFiles = []) {
+function finalizeServiceResult(tracker, startedAt, finishedAt) {
+  if (!tracker || tracker.skipped) {
+    return {
+      name: tracker?.name || "unknown",
+      failed: false,
+      skipped: true,
+      suiteCount: 0,
+      completedSuiteCount: 0,
+      failedSuiteCount: 0,
+      durationMs: 0,
+      suites: [],
+      errors: [],
+    };
+  }
+
+  const suites = [...tracker.suites].sort(
+    (a, b) => a.orderIndex - b.orderIndex || a.name.localeCompare(b.name)
+  );
+  const completedSuiteCount = suites.filter(
+    (suite) => suite.completedFileCount === suite.fileCount
+  ).length;
+  const failedSuiteCount = suites.filter((suite) => suite.failedFiles.length > 0).length;
+  const accumulatedDurationMs = suites.reduce((sum, suite) => sum + suite.durationMs, 0);
+  const durationMs =
+    tracker.firstTaskAt && tracker.lastTaskAt
+      ? Math.max(tracker.lastTaskAt - tracker.firstTaskAt, accumulatedDurationMs)
+      : Math.max(finishedAt - startedAt, accumulatedDurationMs);
+
   return {
-    name: suite.name,
-    type: suite.type,
-    framework: suite.framework,
-    failed,
-    fileCount: suite.files.length,
-    failedFiles,
-    durationMs: Date.now() - startedAt,
+    name: tracker.name,
+    failed:
+      failedSuiteCount > 0 ||
+      tracker.errors.length > 0 ||
+      completedSuiteCount < tracker.suiteCount,
+    skipped: false,
+    suiteCount: tracker.suiteCount,
+    completedSuiteCount,
+    failedSuiteCount,
+    durationMs,
+    suites: suites.map((suite) => ({
+      name: suite.name,
+      type: suite.type,
+      framework: suite.framework,
+      failed: suite.failedFiles.length > 0,
+      fileCount: suite.fileCount,
+      failedFiles: suite.failedFiles,
+      durationMs: suite.durationMs,
+      error: suite.error,
+    })),
+    errors: tracker.errors,
   };
 }
 
@@ -855,15 +1226,16 @@ function printRunSummary(results, durationMs) {
     );
 
     if (result.failed) {
-      const failedSuiteResults = result.workers.flatMap((worker) =>
-        worker.suites.filter((suite) => suite.failed)
-      );
-      for (const suite of failedSuiteResults) {
+      const failedSuitesForService = result.suites.filter((suite) => suite.failed);
+      for (const suite of failedSuitesForService) {
         const fileDetail =
           suite.failedFiles.length > 0 ? `  (${suite.failedFiles.join(", ")})` : "";
         console.log(
           `  - ${suite.type}:${suite.name} [${suite.framework}]${fileDetail} · ${formatDuration(suite.durationMs)}`
         );
+        if (suite.error) {
+          console.log(`    ${suite.error}`);
+        }
       }
       for (const error of result.errors) {
         console.log(`  - worker error: ${error}`);
@@ -891,11 +1263,6 @@ function formatDuration(durationMs) {
   return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
 }
 
-function formatError(error) {
-  if (error instanceof Error) return error.message;
-  return String(error);
-}
-
 function formatServiceSummary(result) {
   const passedSuites = result.completedSuiteCount - result.failedSuiteCount;
   const notRun = result.suiteCount - result.completedSuiteCount;
@@ -906,97 +1273,216 @@ function formatServiceSummary(result) {
   return detail;
 }
 
-function killChildProcess(child, signal) {
-  if (!child?.pid) return;
+function formatError(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+function loadTimings(productDir) {
+  const filePath = path.join(productDir, ".testkit", TIMINGS_FILENAME);
+  if (!fs.existsSync(filePath)) {
+    return {
+      version: 1,
+      files: {},
+    };
+  }
 
   try {
-    process.kill(-child.pid, signal);
-    return;
-  } catch (error) {
-    if (error?.code !== "ESRCH") {
-      // Fall back to the direct child if process-group signalling is unavailable.
-    } else {
-      return;
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return {
+      version: 1,
+      files: parsed.files && typeof parsed.files === "object" ? parsed.files : {},
+    };
+  } catch {
+    return {
+      version: 1,
+      files: {},
+    };
+  }
+}
+
+function saveTimings(productDir, timings, updates) {
+  if (updates.length === 0) return;
+
+  const next = {
+    version: 1,
+    files: { ...timings.files },
+  };
+
+  for (const update of updates) {
+    const existing = next.files[update.key];
+    if (!existing) {
+      next.files[update.key] = {
+        durationMs: Math.max(1, Math.round(update.durationMs)),
+        runs: 1,
+        updatedAt: new Date().toISOString(),
+      };
+      continue;
     }
+
+    const runs = Number(existing.runs || 0) + 1;
+    const durationMs = Math.max(
+      1,
+      Math.round(((existing.durationMs || update.durationMs) * (runs - 1) + update.durationMs) / runs)
+    );
+    next.files[update.key] = {
+      durationMs,
+      runs,
+      updatedAt: new Date().toISOString(),
+    };
   }
 
+  const rootDir = path.join(productDir, ".testkit");
+  fs.mkdirSync(rootDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(rootDir, TIMINGS_FILENAME),
+    JSON.stringify(next, null, 2)
+  );
+}
+
+function estimateTaskDuration(timings, timingKey, suite) {
+  const cached = timings.files[timingKey];
+  if (cached?.durationMs) return cached.durationMs;
+
+  const base =
+    suite.framework === "playwright"
+      ? 20_000
+      : suite.type === "dal"
+        ? 4_000
+        : 8_000;
+  return Math.max(1_000, Math.round((base * suite.weight) / Math.max(1, suite.files.length)));
+}
+
+function buildTimingKey(serviceName, suite, file) {
+  return [
+    serviceName,
+    suite.framework,
+    suite.type,
+    normalizePathSeparators(file),
+  ].join("|");
+}
+
+function parsePlaywrightJsonResults(stdout, cwd) {
+  if (!stdout.trim()) {
+    return { fileResults: new Map(), errors: [] };
+  }
+
+  let parsed;
   try {
-    child.kill(signal);
+    parsed = JSON.parse(stdout);
   } catch (error) {
-    if (error?.code !== "ESRCH") throw error;
+    return {
+      fileResults: new Map(),
+      errors: [`Could not parse Playwright JSON output: ${formatError(error)}`],
+    };
   }
-}
 
-function readDatabaseUrl(stateDir) {
-  return readStateValue(path.join(stateDir, "database_url"));
+  const fileResults = new Map();
+  visitPlaywrightSuites(parsed.suites || [], null, fileResults, cwd);
+  return {
+    fileResults,
+    errors: (parsed.errors || []).map(formatPlaywrightReporterError).filter(Boolean),
+  };
 }
 
-function readStateValue(filePath) {
-  if (!fs.existsSync(filePath)) return null;
-  return fs.readFileSync(filePath, "utf8").trim();
+function visitPlaywrightSuites(suites, inheritedFile, fileResults, cwd) {
+  for (const suite of suites || []) {
+    const suiteFile = normalizeReportedFile(extractReporterFile(suite) || inheritedFile, cwd);
+    for (const child of suite.suites || []) {
+      visitPlaywrightSuites([child], suiteFile, fileResults, cwd);
+    }
+    for (const spec of suite.specs || []) {
+      collectPlaywrightSpec(spec, suiteFile, fileResults, cwd);
+    }
+  }
 }
 
-function printStateDir(dir, indent) {
-  for (const file of fs.readdirSync(dir)) {
-    const filePath = path.join(dir, file);
-    if (fs.statSync(filePath).isDirectory()) {
-      console.log(`${indent}${file}/`);
-      printStateDir(filePath, `${indent}  `);
-      continue;
+function collectPlaywrightSpec(spec, inheritedFile, fileResults, cwd) {
+  const file = normalizeReportedFile(extractReporterFile(spec) || inheritedFile, cwd);
+  if (!file) return;
+
+  const current = fileResults.get(file) || {
+    failed: false,
+    error: null,
+    durationMs: 0,
+  };
+
+  for (const test of spec.tests || []) {
+    const results = Array.isArray(test.results) ? test.results : [];
+    current.durationMs += results.reduce(
+      (sum, result) => sum + Number(result?.duration || 0),
+      0
+    );
+
+    const final = choosePlaywrightFinalResult(results);
+    const failed =
+      test.outcome === "unexpected" ||
+      !isPlaywrightPassingStatus(final?.status);
+
+    if (failed) {
+      current.failed = true;
+      current.error ||= extractPlaywrightFailure(final, spec, test);
     }
-    const value = fs.readFileSync(filePath, "utf8").trim();
-    console.log(`${indent}${file}: ${value}`);
   }
+
+  fileResults.set(file, current);
 }
 
-function pipeOutput(stream, prefix) {
-  if (!stream) return Promise.resolve();
+function choosePlaywrightFinalResult(results) {
+  if (!results || results.length === 0) return null;
+  return results[results.length - 1];
+}
 
-  let pending = "";
-  return new Promise((resolve) => {
-    let settled = false;
-    const settle = () => {
-      if (settled) return;
-      settled = true;
-      resolve();
-    };
+function isPlaywrightPassingStatus(status) {
+  return !status || ["passed", "skipped", "expected"].includes(status);
+}
 
-    stream.on("data", (chunk) => {
-      pending += chunk.toString();
-      const lines = pending.split(/\r?\n/);
-      pending = lines.pop() || "";
-      for (const line of lines) {
-        if (line.length > 0) console.log(`${prefix} ${line}`);
-      }
-    });
-    stream.on("end", () => {
-      if (pending.length > 0) {
-        console.log(`${prefix} ${pending}`);
-      }
-      settle();
-    });
-    stream.on("close", settle);
-    stream.on("error", settle);
-  });
+function extractPlaywrightFailure(finalResult, spec, test) {
+  const fromResult =
+    finalResult?.error?.message ||
+    finalResult?.error?.value ||
+    finalResult?.error?.stack;
+  if (fromResult) return firstLine(fromResult);
+
+  const fromTest = test?.errors?.[0]?.message;
+  if (fromTest) return firstLine(fromTest);
+
+  return firstLine(spec?.title || "Playwright test failed");
 }
 
-async function runWithConcurrency(items, limit, handler) {
-  const concurrency = Math.max(1, Math.min(limit || 1, items.length || 1));
-  let nextIndex = 0;
+function formatPlaywrightReporterError(error) {
+  if (!error) return null;
+  if (typeof error === "string") return firstLine(error);
+  if (typeof error.message === "string") return firstLine(error.message);
+  if (typeof error.value === "string") return firstLine(error.value);
+  return null;
+}
 
-  const workers = Array.from({ length: concurrency }, async () => {
-    while (nextIndex < items.length) {
-      const current = nextIndex;
-      nextIndex += 1;
-      await handler(items[current], current);
-    }
-  });
+function extractReporterFile(node) {
+  if (!node || typeof node !== "object") return null;
+  if (typeof node.file === "string" && node.file.length > 0) return node.file;
+  if (node.location && typeof node.location.file === "string" && node.location.file.length > 0) {
+    return node.location.file;
+  }
+  return null;
+}
 
-  await Promise.all(workers);
+function normalizeReportedFile(filePath, cwd) {
+  if (!filePath) return null;
+  const absolute = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+  return normalizePathSeparators(path.relative(cwd, absolute));
 }
 
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function firstLine(value) {
+  return String(value).split(/\r?\n/).find((line) => line.trim().length > 0)?.trim() || null;
+}
+
+function printBufferedOutput(output, prefix) {
+  for (const line of output.split(/\r?\n/)) {
+    if (line.trim().length > 0) {
+      console.log(`${prefix} ${line}`);
+    }
+  }
 }
 
 function resolveRuntimeUrl(rawUrl, serviceName, targetConfig, workerId, context) {
@@ -1162,6 +1648,85 @@ async function isPortInUse({ host, port }) {
   });
 }
 
+function killChildProcess(child, signal) {
+  if (!child?.pid) return;
+
+  try {
+    process.kill(-child.pid, signal);
+    return;
+  } catch (error) {
+    if (error?.code !== "ESRCH") {
+      // Fall back to the direct child if process-group signalling is unavailable.
+    } else {
+      return;
+    }
+  }
+
+  try {
+    child.kill(signal);
+  } catch (error) {
+    if (error?.code !== "ESRCH") throw error;
+  }
+}
+
+function readDatabaseUrl(stateDir) {
+  return readStateValue(path.join(stateDir, "database_url"));
+}
+
+function readStateValue(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return fs.readFileSync(filePath, "utf8").trim();
+}
+
+function printStateDir(dir, indent) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const filePath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      console.log(`${indent}${entry.name}/`);
+      printStateDir(filePath, `${indent}  `);
+      continue;
+    }
+    const value =
+      entry.name === "password" ? "********" : fs.readFileSync(filePath, "utf8").trim();
+    console.log(`${indent}${entry.name}: ${value}`);
+  }
+}
+
+function pipeOutput(stream, prefix) {
+  if (!stream) return Promise.resolve();
+
+  let pending = "";
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      resolve();
+    };
+
+    stream.on("data", (chunk) => {
+      pending += chunk.toString();
+      const lines = pending.split(/\r?\n/);
+      pending = lines.pop() || "";
+      for (const line of lines) {
+        if (line.length > 0) console.log(`${prefix} ${line}`);
+      }
+    });
+    stream.on("end", () => {
+      if (pending.length > 0) {
+        console.log(`${prefix} ${pending}`);
+      }
+      settle();
+    });
+    stream.on("close", settle);
+    stream.on("error", settle);
+  });
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 function findRuntimeStateDirs(rootDir) {
   const found = [];
 
@@ -1182,3 +1747,69 @@ function findRuntimeStateDirs(rootDir) {
   visit(rootDir);
   return found.sort((a, b) => b.length - a.length);
 }
+
+function findGraphDirsForService(productDir, serviceName) {
+  const graphsRoot = path.join(productDir, ".testkit", "_graphs");
+  if (!fs.existsSync(graphsRoot)) return [];
+
+  const matches = [];
+  for (const entry of fs.readdirSync(graphsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const graphDir = path.join(graphsRoot, entry.name);
+    const metadata = readGraphMetadata(graphDir);
+    if (!metadata) continue;
+    if ((metadata.runtimeServices || []).includes(serviceName)) {
+      matches.push(graphDir);
+    }
+  }
+
+  return matches.sort();
+}
+
+function writeGraphMetadata(graphDir, graph) {
+  fs.mkdirSync(graphDir, { recursive: true });
+  const metadata = {
+    runtimeServices: graph.runtimeNames,
+    assignedTargets: [...graph.assignedTargets].sort(),
+    rootService: graph.rootConfig.name,
+  };
+  fs.writeFileSync(
+    path.join(graphDir, GRAPH_METADATA),
+    JSON.stringify(metadata, null, 2)
+  );
+}
+
+function readGraphMetadata(graphDir) {
+  const metadataPath = path.join(graphDir, GRAPH_METADATA);
+  if (!fs.existsSync(metadataPath)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function isRuntimeSuperset(candidate, target) {
+  return target.every((name) => candidate.includes(name));
+}
+
+function compareGraphsForAssignment(left, right) {
+  if (left.runtimeNames.length !== right.runtimeNames.length) {
+    return left.runtimeNames.length - right.runtimeNames.length;
+  }
+  return left.key.localeCompare(right.key);
+}
+
+function buildGraphDirName(runtimeNames) {
+  const slug = runtimeNames.map(slugSegment).join("__");
+  return slug.length > 0 ? slug : "graph";
+}
+
+function slugSegment(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "svc";
+}
+
+function normalizePathSeparators(filePath) {
+  return filePath.split(path.sep).join("/");
+}