gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -1,345 +1,138 @@
-/**
- * Triage dispatch ordering contract tests.
- *
- * These tests verify structural invariants of the triage integration
- * by inspecting the actual source code of auto-post-unit.ts, auto.ts,
- * and post-unit-hooks.ts. Full behavioral testing requires the
- * @gsd/pi-coding-agent runtime.
- */
+// GSD-2 — Triage and quick-task dispatch behavior tests.
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const hooksPath = join(__dirname, "..", "post-unit-hooks.ts");
-const registryPath = join(__dirname, "..", "rule-registry.ts");
-const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
-
-// After decomposition, triage/dispatch logic lives in auto-post-unit.ts
-const postUnitSrc = readFileSync(join(__dirname, "..", "auto-post-unit.ts"), "utf-8");
-// auto.ts retains top-level orchestration and imports
-const autoSrc = [
-  readFileSync(join(__dirname, "..", "auto.ts"), "utf-8"),
-  postUnitSrc,
-  readFileSync(join(__dirname, "..", "auto-start.ts"), "utf-8"),
-].join("\n");
-// Hook exclusion logic lives in the rule-registry (facade delegates there)
-const hooksSrc = [
-  readFileSync(hooksPath, "utf-8"),
-  readFileSync(registryPath, "utf-8"),
-].join("\n");
-const autoPromptsSrc = (() => { try { return readFileSync(autoPromptsPath, "utf-8"); } catch { return autoSrc; } })();
-
-// ─── Hook exclusion ──────────────────────────────────────────────────────────
-
-test("dispatch: triage-captures excluded from post-unit hook triggering", () => {
-  assert.ok(
-    hooksSrc.includes('"triage-captures"'),
-    "post-unit-hooks.ts should reference triage-captures",
-  );
-  assert.ok(
-    hooksSrc.includes('completedUnitType === "triage-captures"'),
-    "should check for triage-captures in the hook exclusion guard",
-  );
-});
-
-// ─── Triage check placement ──────────────────────────────────────────────────
-
-test("dispatch: triage check appears after hook section and before stepMode check", () => {
-  const triageCheckIndex = postUnitSrc.indexOf("// ── Triage check");
-  const quickTaskIndex = postUnitSrc.indexOf("// ── Quick-task dispatch");
-  const stepModeIndex = postUnitSrc.indexOf("if (s.stepMode)");
-
-  assert.ok(triageCheckIndex > 0, "triage check block should exist");
-  assert.ok(quickTaskIndex > 0, "quick-task dispatch block should exist");
-  assert.ok(stepModeIndex > 0, "step mode check should exist");
-
-  assert.ok(
-    triageCheckIndex < quickTaskIndex,
-    "triage check should come before quick-task dispatch",
-  );
-  assert.ok(
-    quickTaskIndex < stepModeIndex,
-    "quick-task dispatch should come before stepMode check",
-  );
-});
-
-// ─── Guard conditions ────────────────────────────────────────────────────────
-
-test("dispatch: triage check guards against step mode", () => {
-  const triageBlock = postUnitSrc.slice(
-    postUnitSrc.indexOf("// ── Triage check"),
-    postUnitSrc.indexOf("// ── Quick-task dispatch"),
-  );
-  assert.ok(
-    triageBlock.includes("!s.stepMode"),
-    "triage block should guard against step mode",
-  );
-});
-
-test("dispatch: triage check guards against hook unit types", () => {
-  const triageBlock = postUnitSrc.slice(
-    postUnitSrc.indexOf("// ── Triage check"),
-    postUnitSrc.indexOf("// ── Quick-task dispatch"),
-  );
-  assert.ok(
-    triageBlock.includes('!s.currentUnit.type.startsWith("hook/")'),
-    "triage block should not fire for hook units",
-  );
-});
-
-test("dispatch: triage check guards against triage-on-triage", () => {
-  const triageBlock = postUnitSrc.slice(
-    postUnitSrc.indexOf("// ── Triage check"),
-    postUnitSrc.indexOf("// ── Quick-task dispatch"),
-  );
-  assert.ok(
-    triageBlock.includes('s.currentUnit.type !== "triage-captures"'),
-    "triage block should not fire for triage units",
-  );
-});
-
-test("dispatch: triage check guards against quick-task triggering triage", () => {
-  const triageBlock = postUnitSrc.slice(
-    postUnitSrc.indexOf("// ── Triage check"),
-    postUnitSrc.indexOf("// ── Quick-task dispatch"),
-  );
-  assert.ok(
-    triageBlock.includes('s.currentUnit.type !== "quick-task"'),
-    "triage block should not fire for quick-task units",
-  );
-});
-
-test("dispatch: triage dispatch keeps the loop in continue mode", () => {
-  const triageBlock = postUnitSrc.slice(
-    postUnitSrc.indexOf("// ── Triage check"),
-    postUnitSrc.indexOf("// ── Quick-task dispatch"),
-  );
-  assert.ok(
-    triageBlock.includes('return "continue"') || triageBlock.includes("return enqueueSidecar("),
-    "triage dispatch should return 'continue' after enqueuing sidecar work",
-  );
-});
-
-test("dispatch: triage imports hasPendingCaptures and loadPendingCaptures", () => {
-  assert.ok(
-    autoSrc.includes("hasPendingCaptures") && autoSrc.includes("loadPendingCaptures"),
-    "should import capture functions",
-  );
-  assert.ok(
-    autoSrc.includes('from "./captures.js"'),
-    "should import from captures module",
-  );
-});
-
-// ─── Prompt integration ──────────────────────────────────────────────────────
-
-test("dispatch: replan prompt builder loads capture context", () => {
-  const src = autoPromptsSrc;
-  assert.ok(
-    src.includes("loadReplanCaptures"),
-    "buildReplanSlicePrompt should load replan captures",
-  );
-  assert.ok(
-    src.includes("captureContext"),
-    "buildReplanSlicePrompt should pass captureContext to template",
-  );
-});
-
-test("dispatch: reassess prompt builder loads deferred captures", () => {
-  const src = autoPromptsSrc;
-  assert.ok(
-    src.includes("loadDeferredCaptures"),
-    "buildReassessRoadmapPrompt should load deferred captures",
-  );
-  assert.ok(
-    src.includes("deferredCaptures"),
-    "buildReassessRoadmapPrompt should pass deferredCaptures to template",
-  );
-});
-
-// ─── Prompt templates ────────────────────────────────────────────────────────
-
-test("dispatch: replan prompt template includes captureContext variable", () => {
-  const promptPath = join(__dirname, "..", "prompts", "replan-slice.md");
-  const prompt = readFileSync(promptPath, "utf-8");
-  assert.ok(
-    prompt.includes("{{captureContext}}"),
-    "replan-slice.md should include {{captureContext}}",
-  );
-});
-
-test("dispatch: reassess prompt template includes deferredCaptures variable", () => {
-  const promptPath = join(__dirname, "..", "prompts", "reassess-roadmap.md");
-  const prompt = readFileSync(promptPath, "utf-8");
-  assert.ok(
-    prompt.includes("{{deferredCaptures}}"),
-    "reassess-roadmap.md should include {{deferredCaptures}}",
-  );
-});
-
-test("dispatch: triage prompt template exists and has classification criteria", () => {
-  const promptPath = join(__dirname, "..", "prompts", "triage-captures.md");
-  const prompt = readFileSync(promptPath, "utf-8");
-  assert.ok(prompt.includes("quick-task"), "should have quick-task classification");
-  assert.ok(prompt.includes("inject"), "should have inject classification");
-  assert.ok(prompt.includes("defer"), "should have defer classification");
-  assert.ok(prompt.includes("replan"), "should have replan classification");
-  assert.ok(prompt.includes("note"), "should have note classification");
-  assert.ok(prompt.includes("{{pendingCaptures}}"), "should have pending captures variable");
-});
-
-// ─── Dashboard integration ───────────────────────────────────────────────────
-
-test("dashboard: AutoDashboardData includes pendingCaptureCount field", () => {
-  assert.ok(
-    autoSrc.includes("pendingCaptureCount"),
-    "auto.ts should have pendingCaptureCount in AutoDashboardData",
-  );
-});
-
-test("dashboard: getAutoDashboardData computes pendingCaptureCount", () => {
-  assert.ok(
-    autoSrc.includes("pendingCaptureCount = countPendingCaptures") ||
-    autoSrc.includes("pendingCaptureCount = countPendingCaptures(basePath)"),
-    "getAutoDashboardData should compute pendingCaptureCount from countPendingCaptures (single-read)",
-  );
-});
-
-test("dashboard: overlay renders pending captures badge", () => {
-  const overlayPath = join(__dirname, "..", "dashboard-overlay.ts");
-  const overlaySrc = readFileSync(overlayPath, "utf-8");
-  assert.ok(
-    overlaySrc.includes("pendingCaptureCount"),
-    "dashboard-overlay.ts should reference pendingCaptureCount",
-  );
-  assert.ok(
-    overlaySrc.includes("pending capture"),
-    "dashboard-overlay.ts should show pending captures text",
-  );
-});
-
-test("dashboard: overlay labels triage-captures and quick-task unit types", () => {
-  const overlayPath = join(__dirname, "..", "dashboard-overlay.ts");
-  const overlaySrc = readFileSync(overlayPath, "utf-8");
-  assert.ok(
-    overlaySrc.includes('"triage-captures"'),
-    "unitLabel should handle triage-captures",
-  );
-  assert.ok(
-    overlaySrc.includes('"quick-task"'),
-    "unitLabel should handle quick-task",
-  );
-});
-
-// ─── Post-triage resolution execution ─────────────────────────────────────────
-
-test("dispatch: post-triage resolution executor fires after triage-captures unit", () => {
-  const postTriageBlock = postUnitSrc.slice(
-    postUnitSrc.indexOf("Post-triage: execute actionable resolutions"),
-  );
-  assert.ok(
-    postTriageBlock.includes('s.currentUnit.type === "triage-captures"'),
-    "should check for triage-captures unit completion",
-  );
-  assert.ok(
-    postTriageBlock.includes("executeTriageResolutions"),
-    "should call executeTriageResolutions",
-  );
-});
-
-test("dispatch: post-triage executor handles inject results", () => {
-  const postTriageBlock = postUnitSrc.slice(
-    postUnitSrc.indexOf("Post-triage: execute actionable resolutions"),
-  );
-  assert.ok(
-    postTriageBlock.includes("triageResult.injected"),
-    "should check injected count",
-  );
-});
-
-test("dispatch: post-triage executor handles replan results", () => {
-  const postTriageBlock = postUnitSrc.slice(
-    postUnitSrc.indexOf("Post-triage: execute actionable resolutions"),
-  );
-  assert.ok(
-    postTriageBlock.includes("triageResult.replanned"),
-    "should check replanned count",
-  );
-});
-
-test("dispatch: post-triage executor queues quick-tasks", () => {
-  const postTriageBlock = postUnitSrc.slice(
-    postUnitSrc.indexOf("Post-triage: execute actionable resolutions"),
-  );
-  assert.ok(
-    postTriageBlock.includes("s.pendingQuickTasks"),
-    "should push quick-tasks to s.pendingQuickTasks queue",
-  );
-});
-
-// ─── Quick-task dispatch ──────────────────────────────────────────────────────
-
-test("dispatch: quick-task dispatch block exists after triage check", () => {
-  const quickTaskBlock = postUnitSrc.indexOf("// ── Quick-task dispatch");
-  const triageBlock = postUnitSrc.indexOf("// ── Triage check");
-
-  assert.ok(quickTaskBlock > 0, "quick-task dispatch block should exist");
-  assert.ok(
-    quickTaskBlock > triageBlock,
-    "quick-task dispatch should come after triage check",
-  );
-});
-
-test("dispatch: quick-task dispatch uses buildQuickTaskPrompt", () => {
-  const quickTaskSection = postUnitSrc.slice(
-    postUnitSrc.indexOf("// ── Quick-task dispatch"),
-  );
-  assert.ok(
-    quickTaskSection.includes("buildQuickTaskPrompt"),
-    "should call buildQuickTaskPrompt for quick-task dispatch",
-  );
-});
-
-test("dispatch: quick-task dispatch marks capture as executed", () => {
-  const quickTaskSection = postUnitSrc.slice(
-    postUnitSrc.indexOf("// ── Quick-task dispatch"),
-  );
-  assert.ok(
-    quickTaskSection.includes("markCaptureExecuted"),
-    "should mark capture as executed after dispatch",
-  );
-});
-
-test("dispatch: quick-task dispatch keeps the loop in continue mode", () => {
-  const quickTaskSection = postUnitSrc.slice(
-    postUnitSrc.indexOf("// ── Quick-task dispatch"),
-    postUnitSrc.indexOf("if (s.stepMode)"),
-  );
-  assert.ok(
-    quickTaskSection.includes('return "continue"') || quickTaskSection.includes("return enqueueSidecar("),
-    "quick-task dispatch should return 'continue' after enqueuing sidecar work",
-  );
-});
-
-// ─── Post-unit hook exclusion for quick-task ──────────────────────────────────
-
-test("dispatch: quick-task excluded from post-unit hook triggering", () => {
-  assert.ok(
-    hooksSrc.includes('"quick-task"'),
-    "post-unit-hooks.ts should reference quick-task",
-  );
-});
-
-// ─── pendingQuickTasks queue lifecycle ────────────────────────────────────────
-
-test("dispatch: pendingQuickTasks queue is reset on auto-mode start/stop", () => {
-  const resetMatches = autoSrc.match(/s\.pendingQuickTasks = \[\]/g);
-  assert.ok(
-    resetMatches && resetMatches.length >= 2,
-    "s.pendingQuickTasks should be reset in start and stop paths",
-  );
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  appendCapture,
+  countPendingCaptures,
+  hasPendingCaptures,
+  loadPendingCaptures,
+  markCaptureExecuted,
+  markCaptureResolved,
+} from "../captures.ts";
+import { checkPostUnitHooks } from "../post-unit-hooks.ts";
+import {
+  _shouldDispatchQuickTaskForTest,
+  _shouldDispatchTriageForTest,
+} from "../auto-post-unit.ts";
+import {
+  buildQuickTaskPrompt,
+  loadDeferredCaptures,
+  loadReplanCaptures,
+} from "../triage-resolution.ts";
+
+function makeProject(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-triage-dispatch-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "",
+      "## Slices",
+      "- [ ] **S01: Slice** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+    "# S01 Plan\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n",
+  );
+  return base;
+}
+
+test("post-unit hooks exclude triage and quick-task units", () => {
+  assert.equal(checkPostUnitHooks("triage-captures", "M001/S01/triage", "/tmp/project"), null);
+  assert.equal(checkPostUnitHooks("quick-task", "M001/CAP-1", "/tmp/project"), null);
+});
+
+test("triage dispatch guard excludes step mode, hook units, triage units, and quick tasks", () => {
+  const normal = { stepMode: false, currentUnit: { type: "execute-task", id: "M001/S01/T01", startedAt: 1 } };
+  assert.equal(_shouldDispatchTriageForTest(normal as any), true);
+  assert.equal(_shouldDispatchTriageForTest({ ...normal, stepMode: true } as any), false);
+  assert.equal(
+    _shouldDispatchTriageForTest({ stepMode: false, currentUnit: { type: "hook/review", id: "M001/S01/T01", startedAt: 1 } } as any),
+    false,
+  );
+  assert.equal(
+    _shouldDispatchTriageForTest({ stepMode: false, currentUnit: { type: "triage-captures", id: "M001/S01/triage", startedAt: 1 } } as any),
+    false,
+  );
+  assert.equal(
+    _shouldDispatchTriageForTest({ stepMode: false, currentUnit: { type: "quick-task", id: "M001/CAP-1", startedAt: 1 } } as any),
+    false,
+  );
+});
+
+test("quick-task dispatch guard requires queued captures and avoids quick-task recursion", () => {
+  const capture = {
+    id: "CAP-test",
+    text: "Fix typo",
+    timestamp: new Date().toISOString(),
+    status: "resolved" as const,
+    classification: "quick-task" as const,
+  };
+  assert.equal(
+    _shouldDispatchQuickTaskForTest({
+      stepMode: false,
+      currentUnit: { type: "execute-task", id: "M001/S01/T01", startedAt: 1 },
+      pendingQuickTasks: [capture],
+    } as any),
+    true,
+  );
+  assert.equal(
+    _shouldDispatchQuickTaskForTest({
+      stepMode: false,
+      currentUnit: { type: "quick-task", id: "M001/CAP-test", startedAt: 1 },
+      pendingQuickTasks: [capture],
+    } as any),
+    false,
+  );
+  assert.equal(
+    _shouldDispatchQuickTaskForTest({
+      stepMode: false,
+      currentUnit: { type: "execute-task", id: "M001/S01/T01", startedAt: 1 },
+      pendingQuickTasks: [],
+    } as any),
+    false,
+  );
+});
+
+test("capture lifecycle exposes pending, replan, deferred, and executed states", () => {
+  const base = makeProject();
+  try {
+    const pendingId = appendCapture(base, "Need a quick follow-up.");
+    const replanId = appendCapture(base, "Plan needs a new task.");
+    const deferId = appendCapture(base, "Create a future milestone.");
+
+    assert.equal(hasPendingCaptures(base), true);
+    assert.equal(countPendingCaptures(base), 3);
+    assert.deepEqual(loadPendingCaptures(base).map((entry) => entry.id).sort(), [deferId, pendingId, replanId].sort());
+
+    markCaptureResolved(base, replanId, "replan", "replan slice", "Need plan update", "M001");
+    markCaptureResolved(base, deferId, "defer", "defer milestone", "Out of current scope", "M001");
+    markCaptureExecuted(base, replanId);
+
+    assert.equal(loadReplanCaptures(base).some((entry) => entry.id === replanId), true);
+    assert.equal(loadDeferredCaptures(base).some((entry) => entry.id === deferId), true);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("quick-task prompt carries capture identity and completion instruction", () => {
+  const prompt = buildQuickTaskPrompt({
+    id: "CAP-quick",
+    text: "Fix the CLI typo",
+    timestamp: new Date().toISOString(),
+    status: "resolved",
+    classification: "quick-task",
+  });
+
+  assert.match(prompt, /CAP-quick/);
+  assert.match(prompt, /Fix the CLI typo/);
+  assert.match(prompt, /Quick task complete/);
 });

package/src/resources/extensions/gsd/tests/unit-context-manifest.test.ts

@@ -2,9 +2,6 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import {
   ARTIFACT_KEYS,
@@ -17,6 +14,10 @@ import {
   type UnitContextManifest,
 } from "../unit-context-manifest.ts";
 import { ALLOWED_PLANNING_DISPATCH_AGENTS } from "../bootstrap/write-gate.ts";
+import {
+  getRequiredWorkflowToolsForAutoUnit,
+  getRequiredWorkflowToolsForGuidedUnit,
+} from "../workflow-mcp.ts";
 
 // ─── Coverage: every known unit type has a manifest ──────────────────────
 
@@ -41,29 +42,11 @@ test("#4782 phase 1: every UNIT_MANIFESTS entry corresponds to a known unit type
 
 // ─── Coverage: every unitType stringly-typed in auto-dispatch.ts is known ─
 
-test("#4782 phase 1: every unitType string in auto-dispatch.ts has a manifest", () => {
-  // Source-only coverage check — read the dispatcher and enumerate its
-  // unitType literals. This is a CI guard against manifest drift: if a
-  // new dispatch rule is added without a corresponding manifest entry,
-  // this test fails loudly. Read-only check of source text; the cheapest
-  // way to enumerate declared unit types without running the dispatcher.
-  // allow-source-grep: enumerate unitType literals for CI coverage guard
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
-  const matches = Array.from(dispatchSrc.matchAll(/unitType:\s*"([^"]+)"/g));
-  const seen = new Set<string>();
-  for (const m of matches) {
-    const t = m[1];
-    if (!t) continue;
-    seen.add(t);
-  }
-  const missing: string[] = [];
-  for (const t of seen) {
-    if (!UNIT_MANIFESTS[t as keyof typeof UNIT_MANIFESTS]) {
-      missing.push(t);
-    }
+test("#4782 phase 1: workflow tool policy maps are defined for every known unit type", () => {
+  for (const unitType of KNOWN_UNIT_TYPES) {
+    assert.ok(Array.isArray(getRequiredWorkflowToolsForAutoUnit(unitType)));
+    assert.ok(Array.isArray(getRequiredWorkflowToolsForGuidedUnit(unitType)));
   }
-  assert.deepEqual(missing, [], `unit types dispatched in auto-dispatch.ts but missing from UNIT_MANIFESTS: ${missing.join(", ")}`);
 });
 
 // ─── Shape: every manifest conforms to the schema invariants ──────────────

package/src/resources/extensions/gsd/tests/unit-dispatches.test.ts

@@ -13,7 +13,7 @@ import {
   insertSlice,
 } from "../gsd-db.ts";
 import { registerAutoWorker } from "../db/auto-workers.ts";
-import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import { claimMilestoneLease, releaseMilestoneLease } from "../db/milestone-leases.ts";
 import {
   recordDispatchClaim,
   markRunning,
@@ -105,6 +105,55 @@ test("partial unique index rejects double-claim of the same active unit", (t) =>
   }
 });
 
+test("recordDispatchClaim cancels stale active dispatch after lease takeover", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId: firstWorkerId, leaseToken: firstLeaseToken } = setup(base);
+
+  const first = recordDispatchClaim({
+    traceId: "t-first",
+    workerId: firstWorkerId,
+    milestoneLeaseToken: firstLeaseToken,
+    milestoneId: "M001",
+    sliceId: "S01",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+  });
+  assert.equal(first.ok, true);
+  if (!first.ok) return;
+  markRunning(first.dispatchId);
+
+  assert.equal(releaseMilestoneLease(firstWorkerId, "M001", firstLeaseToken), true);
+  const takeoverWorkerId = registerAutoWorker({ projectRootRealpath: base });
+  const takeoverLease = claimMilestoneLease(takeoverWorkerId, "M001");
+  assert.equal(takeoverLease.ok, true);
+  if (!takeoverLease.ok) return;
+
+  const second = recordDispatchClaim({
+    traceId: "t-takeover",
+    workerId: takeoverWorkerId,
+    milestoneLeaseToken: takeoverLease.token,
+    milestoneId: "M001",
+    sliceId: "S01",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+    attemptN: 2,
+  });
+
+  assert.equal(second.ok, true);
+  if (!second.ok) return;
+
+  const recent = getRecentForUnit("M001/S01", 5);
+  assert.equal(recent.length, 2);
+  assert.equal(recent[0].id, second.dispatchId);
+  assert.equal(recent[0].status, "claimed");
+  assert.equal(recent[0].worker_id, takeoverWorkerId);
+  assert.equal(recent[0].attempt_n, 2);
+  assert.equal(recent[1].id, first.dispatchId);
+  assert.equal(recent[1].status, "canceled");
+  assert.equal(recent[1].exit_reason, "stale-dispatch-lease-takeover");
+});
+
 test("after markCompleted, a fresh claim for the same unit succeeds", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));