@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/clients/test-runner-client.js

@@ -6,7 +6,9 @@ import { emitBounded } from "./bounded-telemetry.js";
 import { LEDGER_FIELD_MAX } from "./degradation-ledger.js";
 import { minimatch } from "./deps/minimatch.js";
 import { createSubsystemLogger } from "./extension-log.js";
+import { detectFileKind } from "./file-kinds.js";
 import { detectFileRole } from "./file-role.js";
+import { resolveLanguageRootForFile } from "./language-profile.js";
 import { findGlobalBinary } from "./package-manager.js";
 import { PathKeyedMap } from "./path-keyed-map.js";
 import {
@@ -14,14 +16,20 @@ import {
   detectPythonEnvironment
 } from "./python-environment.js";
 import {
+  isUnderDir,
   normalizeEphemeralMapKey,
   normalizeMapKey,
   toPosix
 } from "./path-utils.js";
+import { findNearestDirWithAnyBasename } from "./workspace-topology.js";
 import { isMeasuredDuration, toMeasuredDurationMs } from "./run-duration.js";
 import { safeSpawn, safeSpawnAsync } from "./safe-spawn.js";
 import { stripAnsi } from "./sanitize.js";
-const SOURCE_TO_TEST_PATTERNS = [
+import { resolveToolCwd } from "./tool-cwd.js";
+export function isRunnerErrorResult(result) {
+  return result.failed === 0 && !!result.error;
+}
+export const SOURCE_TO_TEST_PATTERNS = [
   {
     ext: ".ts",
     testExts: [".test.ts", ".spec.ts"],
@@ -52,7 +60,11 @@ const SOURCE_TO_TEST_PATTERNS = [
   { ext: ".php", testExts: ["Test.php"], dirs: ["tests"] },
   { ext: ".ex", testExts: ["_test.exs"], dirs: ["test"] }
 ];
-const MAX_NODE_MODULES_WALK_UP = 5;
+function findHoistedNodeModulesPackage(cwd, packageName) {
+  return findNearestDirWithAnyBasename(path.resolve(cwd), [
+    `node_modules/${packageName}`
+  ]);
+}
 const MAX_PYTEST_RECURSE_DEPTH = 3;
 export const TURN_END_EXCLUDED_TEST_GLOBS = [
   "**/integration/**",
@@ -68,6 +80,7 @@ export function isExcludedTestTarget(testFilePath, cwd) {
 }
 export const RUNNERS = {
   vitest: {
+    kinds: ["jsts"],
     configFiles: ["vitest.config.ts", "vitest.config.js", "vitest.config.mjs"],
     command: "npx",
     binName: "vitest",
@@ -81,6 +94,7 @@ export const RUNNERS = {
     parseJson: true
   },
   jest: {
+    kinds: ["jsts"],
     configFiles: [
       "jest.config.ts",
       "jest.config.js",
@@ -99,12 +113,15 @@ export const RUNNERS = {
     parseJson: true
   },
   pytest: {
+    kinds: ["python"],
     configFiles: ["pytest.ini", "pyproject.toml", "setup.cfg", "tox.ini"],
+    spawnCwdMarkers: ["pytest.ini", "tox.ini", "setup.cfg"],
     command: "python",
     args: (testFile, _cwd) => ["-m", "pytest", testFile, "--tb=short", "-q"],
     parseJson: false
   },
   go: {
+    kinds: ["go"],
     configFiles: ["go.mod"],
     command: "go",
     args: (testFile, cwd) => {
@@ -115,30 +132,41 @@ export const RUNNERS = {
     parseJson: false
   },
   cargo: {
+    kinds: ["rust"],
     configFiles: ["Cargo.toml"],
     command: "cargo",
     args: (_testFile, _cwd) => ["test", "--no-fail-fast"],
     parseJson: false
   },
   dotnet: {
+    kinds: ["csharp", "fsharp"],
     configFiles: ["*.csproj", "*.sln"],
     command: "dotnet",
     args: (_testFile, _cwd) => ["test", "--no-build"],
     parseJson: false
   },
   gradle: {
-    configFiles: ["build.gradle", "build.gradle.kts", "settings.gradle"],
+    kinds: ["java", "kotlin"],
+    configFiles: [
+      "build.gradle",
+      "build.gradle.kts",
+      "settings.gradle",
+      "settings.gradle.kts"
+    ],
     command: process.platform === "win32" ? "gradlew.bat" : "./gradlew",
+    spawnCwdMarkers: ["gradlew", "gradlew.bat"],
     args: (_testFile, _cwd) => ["test", "--no-daemon"],
     parseJson: false
   },
   maven: {
+    kinds: ["java", "kotlin"],
     configFiles: ["pom.xml"],
     command: "mvn",
     args: (_testFile, _cwd) => ["test", "-q"],
     parseJson: false
   },
   rspec: {
+    kinds: ["ruby"],
     configFiles: [".rspec", "spec/spec_helper.rb"],
     command: "bundle",
     binName: "bundle",
@@ -146,18 +174,22 @@ export const RUNNERS = {
     parseJson: false
   },
   minitest: {
+    kinds: ["ruby"],
     configFiles: ["Gemfile"],
     command: "ruby",
     args: (testFile, _cwd) => ["-Itest", testFile],
     parseJson: false
   },
   phpunit: {
+    kinds: ["php"],
     configFiles: ["phpunit.xml", "phpunit.xml.dist", "composer.json"],
+    spawnCwdMarkers: ["phpunit.xml", "phpunit.xml.dist"],
     command: "phpunit",
     args: (testFile, _cwd) => [testFile],
     parseJson: false
   },
   mix: {
+    kinds: ["elixir"],
     configFiles: ["mix.exs"],
     command: "mix",
     args: (testFile, _cwd) => ["test", testFile],
@@ -273,7 +305,54 @@ export class TestRunnerClient {
       return;
     byRunner.set(runner, { available, evidencePath });
   }
-  detectRunner(cwd, sourceFilePath) {
+  resolveDetectionScope(cwd, sourceFilePath) {
+    if (sourceFilePath === undefined)
+      return { root: cwd, eligible: null };
+    const absoluteFile = path.resolve(sourceFilePath);
+    if (!isUnderDir(absoluteFile, path.resolve(cwd))) {
+      return { root: cwd, eligible: null };
+    }
+    const kind = detectFileKind(absoluteFile);
+    if (!kind)
+      return null;
+    const eligible = new Set(Object.entries(RUNNERS).filter(([, config]) => config.kinds.includes(kind)).map(([name]) => name));
+    if (eligible.size === 0)
+      return null;
+    return {
+      root: resolveLanguageRootForFile(absoluteFile, cwd),
+      eligible
+    };
+  }
+  detectRunner(dispatchRoot, sourceFilePath) {
+    const scope = this.resolveDetectionScope(dispatchRoot, sourceFilePath);
+    if (!scope)
+      return null;
+    const { root, eligible } = scope;
+    const anchored = this.probeRunnersAt(root, eligible);
+    if (anchored)
+      return anchored;
+    const dispatch = path.resolve(dispatchRoot);
+    if (path.resolve(root) !== dispatch) {
+      const atDispatch = this.probeRunnersAt(dispatch, eligible);
+      if (atDispatch)
+        return atDispatch;
+    }
+    const isPythonSource = typeof sourceFilePath === "string" && sourceFilePath.endsWith(".py");
+    if (!isPythonSource)
+      return null;
+    try {
+      const whichCmd = process.platform === "win32" ? "where" : "which";
+      const result = safeSpawn(whichCmd, ["pytest"], {
+        timeout: 2000
+      });
+      if (result.status === 0) {
+        this.log("Detected pytest globally");
+        return { runner: "pytest", config: RUNNERS.pytest };
+      }
+    } catch (err) {}
+    return null;
+  }
+  probeRunnersAt(cwd, eligible) {
     const rootKey = this.getCanonicalProjectRoot(cwd);
     let byRunner = this.availableRunners.get(rootKey);
     if (!byRunner) {
@@ -281,6 +360,8 @@ export class TestRunnerClient {
       this.availableRunners.set(rootKey, byRunner);
     }
     for (const [name, config] of Object.entries(RUNNERS)) {
+      if (eligible && !eligible.has(name))
+        continue;
       const cached = this.getRunnerAvailability(byRunner, name);
       if (cached !== undefined) {
         if (cached) {
@@ -341,33 +422,34 @@ export class TestRunnerClient {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (allDeps.vitest) {
+      if (allDeps.vitest && (!eligible || eligible.has("vitest"))) {
         this.log("Detected vitest in package.json");
         this.setRunnerAvailability(byRunner, "vitest", true, packageJsonPath);
         return { runner: "vitest", config: RUNNERS.vitest };
       }
-      if (allDeps.jest) {
+      if (allDeps.jest && (!eligible || eligible.has("jest"))) {
         this.log("Detected jest in package.json");
         this.setRunnerAvailability(byRunner, "jest", true, packageJsonPath);
         return { runner: "jest", config: RUNNERS.jest };
       }
-      if (allDeps.pytest || allDeps["pytest-cov"]) {
+      if ((allDeps.pytest || allDeps["pytest-cov"]) && (!eligible || eligible.has("pytest"))) {
         this.log("Detected pytest in package.json (unusual)");
         this.setRunnerAvailability(byRunner, "pytest", true, packageJsonPath);
         return { runner: "pytest", config: RUNNERS.pytest };
       }
     } catch (err) {}
-    const hoistedVitest = this.findHoistedNodeModulesPackage(cwd, "vitest");
-    if (hoistedVitest) {
-      this.log(`Detected vitest in node_modules (${hoistedVitest})`);
-      return { runner: "vitest", config: RUNNERS.vitest };
-    }
-    const hoistedJest = this.findHoistedNodeModulesPackage(cwd, "jest");
-    if (hoistedJest) {
-      this.log(`Detected jest in node_modules (${hoistedJest})`);
-      return { runner: "jest", config: RUNNERS.jest };
+    for (const name of ["vitest", "jest"]) {
+      if (eligible && !eligible.has(name))
+        continue;
+      const hoisted = findHoistedNodeModulesPackage(cwd, name);
+      if (hoisted) {
+        this.log(`Detected ${name} in node_modules (${hoisted})`);
+        return { runner: name, config: RUNNERS[name] };
+      }
     }
     for (const name of ["go", "cargo", "dotnet", "gradle", "maven"]) {
+      if (eligible && !eligible.has(name))
+        continue;
       const config = RUNNERS[name];
       const found = config.configFiles.some((cf) => {
         if (cf.includes("*")) {
@@ -385,33 +467,6 @@ export class TestRunnerClient {
         return { runner: name, config };
       }
     }
-    const isPythonSource = typeof sourceFilePath === "string" && sourceFilePath.endsWith(".py");
-    if (!isPythonSource)
-      return null;
-    try {
-      const whichCmd = process.platform === "win32" ? "where" : "which";
-      const result = safeSpawn(whichCmd, ["pytest"], {
-        timeout: 2000
-      });
-      if (result.status === 0) {
-        this.log("Detected pytest globally");
-        return { runner: "pytest", config: RUNNERS.pytest };
-      }
-    } catch (err) {}
-    return null;
-  }
-  findHoistedNodeModulesPackage(cwd, packageName) {
-    let dir = path.resolve(cwd);
-    for (let level = 0;level <= MAX_NODE_MODULES_WALK_UP; level++) {
-      const nodeModulesPath = path.join(dir, "node_modules");
-      if (fs.existsSync(path.join(nodeModulesPath, packageName))) {
-        return nodeModulesPath;
-      }
-      const parent = path.dirname(dir);
-      if (parent === dir)
-        break;
-      dir = parent;
-    }
     return null;
   }
   findPytestMatchRecursive(rootDir, pattern, basename, maxDepth) {
@@ -662,10 +717,14 @@ export class TestRunnerClient {
       return this.emptyResult(absoluteTestFile, "", runner, "Test file not found");
     }
     try {
-      const { command, args, env } = await this.resolveExec(runner, config, absoluteTestFile, cwd);
-      this.log(`Running (async): ${command} ${args.join(" ")}`);
+      const spawnCwd = resolveToolCwd("runner", runner, absoluteTestFile, {
+        cwd: path.resolve(cwd),
+        rootMarkers: config.spawnCwdMarkers ?? config.configFiles
+      }).cwd;
+      const { command, args, env } = await this.resolveExec(runner, config, absoluteTestFile, cwd, spawnCwd);
+      this.log(`Running (async): ${command} ${args.join(" ")} (cwd ${spawnCwd})`);
       const result = await safeSpawnAsync(command, args, {
-        cwd,
+        cwd: spawnCwd,
         timeout: 60000,
         env,
         signal
@@ -972,7 +1031,7 @@ ${stderr}`;
       skipped,
       failures,
       duration,
-      error: exitCode === 2 ? "Pytest configuration error" : undefined
+      error: exitCode === 4 ? "Pytest configuration error" : exitCode === 2 ? "Pytest interrupted" : undefined
     };
   }
   parsePhpunitOutput(stdout, stderr, exitCode, testFile, runner) {
@@ -1226,7 +1285,9 @@ ${stderr}`;
       const slash = name.indexOf("/");
       return slash === -1 || !goFailNameSet.has(name.slice(0, slash));
     }).length;
+    let goInfraVerdict = false;
     if (runner === "go") {
+      goInfraVerdict = /^FAIL[^\S\n]+\S+[^\S\n]+\[setup failed\]/m.test(output);
       const goFailPackage = /^FAIL(?![^\n]*\[(?:build|setup) failed\])[^\S\n]+\S+/m.test(output);
       const goOkPackages = [
         ...output.matchAll(/^ok[^\S\n]+\S+[^\S\n]+[\d.]+s/gm)
@@ -1253,7 +1314,7 @@ ${stderr}`;
         break;
       failures.push({ name: m[1].trim(), message: m[1].trim() });
     }
-    const runnerError = exitCode !== 0 && !matched && goFailNames.length === 0 && lower.includes("error") ? `Runner ${runner} exited with ${exitCode}` : undefined;
+    const runnerError = exitCode !== 0 && !matched && goFailNames.length === 0 && (lower.includes("error") || goInfraVerdict) ? `Runner ${runner} exited with ${exitCode}` : undefined;
     if (runnerError) {
       failures.length = 0;
     }
@@ -1282,8 +1343,8 @@ ${stderr}`;
     };
   }
   formatResult(result) {
-    if (result.error && result.passed === 0 && result.failed === 0) {
-      return `[Tests] ⚠ Could not run tests: ${result.error}`;
+    if (isRunnerErrorResult(result)) {
+      return result.passed > 0 ? `[Tests] ⚠ Could not complete tests: ${result.error} (${result.passed} passed before)` : `[Tests] ⚠ Could not run tests: ${result.error}`;
     }
     const total = result.passed + result.failed + result.skipped;
     if (total === 0) {
@@ -1358,13 +1419,13 @@ ${stderr}`;
     }
     return null;
   }
-  async resolveExec(runner, config, testFile, cwd) {
+  async resolveExec(runner, config, testFile, cwd, spawnCwd = cwd) {
     if (runner === "pytest") {
       const pythonEnvironment = await detectPythonEnvironment(cwd);
       if (pythonEnvironment) {
         return {
           command: pythonEnvironment.pythonPath,
-          args: config.args(testFile, cwd),
+          args: config.args(testFile, spawnCwd),
           env: augmentPythonEnvironment(process.env, pythonEnvironment)
         };
       }
@@ -1373,9 +1434,9 @@ ${stderr}`;
       const suffix = process.platform === "win32" ? ".bat" : "";
       const vendorBin = path.join(cwd, "vendor", "bin", `phpunit${suffix}`);
       if (fs.existsSync(vendorBin)) {
-        return { command: vendorBin, args: config.args(testFile, cwd) };
+        return { command: vendorBin, args: config.args(testFile, spawnCwd) };
       }
-      return { command: "phpunit", args: config.args(testFile, cwd) };
+      return { command: "phpunit", args: config.args(testFile, spawnCwd) };
     }
     const binName = config.binName ?? runner;
     const suffix = process.platform === "win32" ? ".cmd" : "";
@@ -1383,17 +1444,17 @@ ${stderr}`;
     if (fs.existsSync(localBin)) {
       return {
         command: localBin,
-        args: stripWrapperArgs(binName, config.args(testFile, cwd))
+        args: stripWrapperArgs(binName, config.args(testFile, spawnCwd))
       };
     }
     const globalBin = await findGlobalBinary(binName);
     if (globalBin) {
       return {
         command: globalBin,
-        args: stripWrapperArgs(binName, config.args(testFile, cwd))
+        args: stripWrapperArgs(binName, config.args(testFile, spawnCwd))
       };
     }
-    return { command: config.command, args: config.args(testFile, cwd) };
+    return { command: config.command, args: config.args(testFile, spawnCwd) };
   }
   emptyResult(testFile, sourceFile, runner, error) {
     return {

package/extensions/dm-lens/clients/test-runner-delivery.js

@@ -1,22 +1,52 @@
 import { emitBounded } from "./bounded-telemetry.js";
-import { peekTestFindings } from "./runtime-context.js";
-import { fitLines } from "./tui-fit.js";
-export const TEST_RUNNER_ENTRY_TYPE = "dmlens:test-runner-findings";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { logLatency } from "./latency-logger.js";
+import { consumeTestFindings, peekTestFindings } from "./runtime-context.js";
 const MAX_PENDING_DELIVERIES = 32;
-const MAX_ENTRY_CONTENT = 12000;
 const pending = new Map;
+function logDeliveredVerdicts(cacheManager, cwd, runtime, delivery) {
+  const verdicts = cacheManager.readCache("test-runner-findings", cwd)?.data?.verdicts;
+  let knownCount = 0;
+  let staleCount = 0;
+  let unknownCount = 0;
+  for (const verdict of verdicts ?? []) {
+    const evidence = verdict.fileSeq ?? {
+      state: "unknown",
+      reason: "legacy-cache-record"
+    };
+    if (evidence.state === "unknown") {
+      unknownCount += 1;
+      recordDegradationOnce({
+        kind: "test-runner-delivery",
+        subject: `${delivery.sessionId}:${verdict.sourceFile}`,
+        reason: `missing file sequence evidence (${evidence.reason})`
+      });
+      continue;
+    }
+    knownCount += 1;
+    const currentFileSeq = runtime.getFileSeq(verdict.sourceFile);
+    if (currentFileSeq > evidence.value)
+      staleCount += 1;
+  }
+  if (knownCount === 0 && unknownCount === 0)
+    return;
+  logLatency({
+    type: "phase",
+    phase: "test_runner_verdict_delivery",
+    filePath: cwd,
+    durationMs: 0,
+    metadata: {
+      sessionId: delivery.sessionId,
+      generation: delivery.generation,
+      verdictCount: knownCount,
+      staleCount,
+      unknownCount
+    }
+  });
+}
 function key(cwd, sessionId, ownerId) {
   return `${ownerId ?? "direct"}\x00${cwd}\x00${sessionId}`;
 }
-function boundedContent(content) {
-  if (content.length <= MAX_ENTRY_CONTENT)
-    return { content, droppedDetailCount: 0 };
-  return {
-    content: `${content.slice(0, MAX_ENTRY_CONTENT)}
-[…details truncated]`,
-    droppedDetailCount: content.length - MAX_ENTRY_CONTENT
-  };
-}
 function record(identity, outcome, delivery, metadata = {}) {
   emitBounded("test_runner_delivery", identity, {
     filePath: delivery.cwd,
@@ -33,7 +63,7 @@ function record(identity, outcome, delivery, metadata = {}) {
     }
   }, {
     capPerTurn: { limit: 8, turnIndex: delivery.generation },
-    ledgerKind: outcome === "delivery-failed" || outcome === "capability-unavailable" ? "test-runner-delivery" : undefined,
+    ledgerKind: outcome === "delivery-failed" ? "test-runner-delivery" : undefined,
     reason: `test runner delivery ${outcome}`
   });
 }
@@ -56,6 +86,7 @@ export function stageTestRunnerDelivery(args) {
       generation: args.generation,
       targetCount: args.targetCount,
       createdAt: Date.now(),
+      eligible: false,
       owner: args.owner
     };
     record(deliveryKey, "superseded", superseded, {
@@ -81,6 +112,7 @@ export function stageTestRunnerDelivery(args) {
     generation: args.generation,
     targetCount: args.targetCount,
     createdAt: Date.now(),
+    eligible: false,
     owner: args.owner
   };
   pending.set(deliveryKey, delivery);
@@ -96,16 +128,11 @@ export function deliverTestRunnerFindings(args) {
   const currentGeneration = args.cacheManager.readCache("test-runner-findings", cwd)?.data?.testRunGeneration;
   if (currentGeneration !== undefined && currentGeneration > delivery.generation) {
     pending.delete(deliveryKey);
-    record(deliveryKey, "superseded", delivery, {
-      currentGeneration
-    });
+    record(deliveryKey, "superseded", delivery, { currentGeneration });
     return;
   }
   if (typeof args.ctx.isIdle !== "function") {
     pending.delete(deliveryKey);
-    record(deliveryKey, "capability-unavailable", delivery, {
-      reason: "host does not expose ctx.isIdle"
-    });
     return;
   }
   try {
@@ -119,8 +146,7 @@ export function deliverTestRunnerFindings(args) {
     });
     return;
   }
-  const findings = peekTestFindings(args.cacheManager, cwd, args.runtime, true);
-  if (!findings) {
+  if (!peekTestFindings(args.cacheManager, cwd, args.runtime, true)) {
     pending.delete(deliveryKey);
     record(deliveryKey, "superseded", delivery);
     return;
@@ -136,29 +162,23 @@ export function deliverTestRunnerFindings(args) {
     });
     return;
   }
-  const bounded = boundedContent(findings.messages[0]?.content ?? "");
-  try {
-    args.pi.sendMessage({
-      customType: TEST_RUNNER_ENTRY_TYPE,
-      content: "",
-      details: {
-        ...bounded,
-        sessionId: delivery.sessionId,
-        generation: delivery.generation,
-        targetCount: delivery.targetCount
-      },
-      display: true
-    }, { triggerTurn: false });
+  delivery.eligible = true;
+  const current = args.cacheManager.readCache("test-runner-findings", cwd)?.data;
+  if (!current?.content || current.testRunGeneration !== delivery.generation) {
     pending.delete(deliveryKey);
-    record(deliveryKey, "delivered", delivery, {
-      droppedDetailCount: bounded.droppedDetailCount,
-      ageMs: Math.max(0, Date.now() - delivery.createdAt)
-    });
-  } catch (error) {
-    record(deliveryKey, "delivery-failed", delivery, {
-      error: String(error).slice(0, 500)
-    });
+    return;
   }
+  args.cacheManager.writeCache("test-runner-findings", {
+    ...current,
+    deliveryEligible: {
+      sessionId: delivery.sessionId,
+      generation: delivery.generation,
+      eligibleAt: Date.now()
+    }
+  }, cwd);
+  record(deliveryKey, "eligible", delivery, {
+    ageMs: Math.max(0, Date.now() - delivery.createdAt)
+  });
 }
 export function deliverStagedTestRunnerFindings(args) {
   if (!args?.cwd || !args.ownerId)
@@ -167,7 +187,6 @@ export function deliverStagedTestRunnerFindings(args) {
   if (!delivery?.owner)
     return;
   deliverTestRunnerFindings({
-    pi: delivery.owner.pi,
     ctx: delivery.owner.getCtx(),
     cacheManager: delivery.owner.cacheManager,
     runtime: delivery.owner.runtime,
@@ -175,30 +194,63 @@ export function deliverStagedTestRunnerFindings(args) {
     ownerId: delivery.ownerId
   });
 }
-export function registerTestRunnerMessageRenderer(pi) {
-  const register = pi.registerMessageRenderer;
-  if (typeof register !== "function")
-    return false;
-  try {
-    register.call(pi, TEST_RUNNER_ENTRY_TYPE, renderTestRunnerEntry);
-    return true;
-  } catch {
-    return false;
+export function consumeStagedTestRunnerFindings(args) {
+  const deliveryKey = key(args.cwd, args.sessionId, args.ownerId);
+  let delivery = pending.get(deliveryKey);
+  const persisted = args.cacheManager.readCache("test-runner-findings", args.cwd)?.data;
+  const eligible = persisted?.deliveryEligible;
+  if (!delivery && persisted?.content && eligible) {
+    const sameSession = eligible.sessionId === args.sessionId;
+    if (!sameSession) {
+      const foreignDelivery = {
+        cwd: args.cwd,
+        sessionId: eligible.sessionId,
+        generation: eligible.generation,
+        targetCount: 0,
+        createdAt: eligible.eligibleAt,
+        eligible: true,
+        rehydrated: true
+      };
+      record(deliveryKey, "foreign-session", foreignDelivery, {
+        currentSessionId: args.sessionId,
+        currentOwnerId: args.ownerId,
+        reason: "session-mismatch"
+      });
+      return;
+    }
+    delivery = {
+      cwd: args.cwd,
+      sessionId: args.sessionId,
+      ownerId: args.ownerId,
+      generation: eligible.generation,
+      targetCount: 0,
+      createdAt: eligible.eligibleAt,
+      eligible: true,
+      rehydrated: true
+    };
+    pending.set(deliveryKey, delivery);
   }
-}
-function renderTestRunnerEntry(entry, _options, theme) {
-  const content = entry.details?.content;
-  if (typeof content !== "string")
+  if (!delivery?.eligible)
     return;
-  const lines = [
-    theme.fg("error", "dm-lens test failures"),
-    ...content.split(`
-`)
-  ];
-  return {
-    render: (width) => fitLines(lines, width),
-    invalidate: () => {}
-  };
+  const currentGeneration = persisted?.testRunGeneration;
+  if (currentGeneration !== delivery.generation) {
+    pending.delete(deliveryKey);
+    record(deliveryKey, "superseded", delivery, { currentGeneration });
+    return;
+  }
+  logDeliveredVerdicts(args.cacheManager, args.cwd, args.runtime, delivery);
+  const findings = consumeTestFindings(args.cacheManager, args.cwd, args.runtime);
+  if (!findings) {
+    pending.delete(deliveryKey);
+    record(deliveryKey, "superseded", delivery);
+    return;
+  }
+  pending.delete(deliveryKey);
+  record(deliveryKey, "delivered", delivery, {
+    ageMs: Math.max(0, Date.now() - delivery.createdAt),
+    rehydrated: delivery.rehydrated === true
+  });
+  return findings;
 }
 export function _resetTestRunnerDeliveryForTests() {
   pending.clear();