agent-dealer 1.2.16 → 1.3.1

package/bundle/server/dist/coordinator/admission.js

@@ -72,19 +72,6 @@ export function countOccupyingIssues() {
 function listOccupyingIssues() {
     return listIssues([...occupyingStatuses]).map((i) => ({ id: i.id, status: i.status, repo: i.repo }));
 }
-/** Occupying repos with the active issue's id/title, for the per-repo exclusion reason. */
-function occupyingRepoSlots() {
-    const slots = new Map();
-    for (const issue of listIssues([...occupyingStatuses])) {
-        if (issue.repo)
-            slots.set(issue.repo, { issueId: issue.id, title: issue.title });
-    }
-    return slots;
-}
-/** NOT-215: concrete same-repository wait reason naming the active conflict. */
-export function repositorySlotReason(repo, activeTitle) {
-    return `waiting for repository slot — ${repo} already active (${activeTitle})`;
-}
 /**
  * NOT-215 read model for the Admission queue header: truthful active / waiting /
  * limit counts, the persisted setting, the worker/spawn ceiling, the offerable
@@ -303,8 +290,6 @@ export async function admitNext() {
         blockersUnavailableReason: blockerUnavailableReason(),
     };
     const admitted = [];
-    // Repos taken by occupying issues, plus issues admitted earlier in this tick.
-    const repoSlots = occupyingRepoSlots();
     for (const entry of remaining) {
         // Slots filled mid-walk — stop. The read-time slot overlay
         // (listQueuedEntriesForRead) already reports the full state; persisting a slot
@@ -316,15 +301,6 @@ export async function admitNext() {
             markQueueEntryRemoved(entry.issueId);
             continue;
         }
-        // Same-repository exclusion first (cheap, deterministic): never burn async
-        // eligibility work on an entry that cannot take a slot anyway.
-        if (issue.repo) {
-            const slot = repoSlots.get(issue.repo);
-            if (slot && slot.issueId !== issue.id) {
-                setQueueWaitReason(entry.id, repositorySlotReason(issue.repo, slot.title));
-                continue;
-            }
-        }
         const eligibility = await evaluateEligibility(issue, ctx);
         if (!eligibility.ok) {
             setQueueWaitReason(entry.id, eligibility.reason);
@@ -342,29 +318,10 @@ export async function admitNext() {
                 if (capacityPolicy(listOccupyingIssues()) <= 0) {
                     throw new StartPreconditionError(409, "no free admission slots");
                 }
-                // Re-check the repo slot inside the txn for the same race.
-                if (issue.repo) {
-                    const fresh = occupyingRepoSlots();
-                    for (const a of admitted) {
-                        const admittedIssue = getIssue(a.issueId);
-                        if (admittedIssue?.repo) {
-                            fresh.set(admittedIssue.repo, {
-                                issueId: admittedIssue.id,
-                                title: admittedIssue.title,
-                            });
-                        }
-                    }
-                    const conflict = fresh.get(issue.repo);
-                    if (conflict && conflict.issueId !== issue.id) {
-                        throw new StartPreconditionError(409, repositorySlotReason(issue.repo, conflict.title));
-                    }
-                }
                 // Force-admit lives inside startWorkflowCore — single owner for start-path-queue-sync.
                 return startWorkflowCore(entry.issueId);
             })();
             admitted.push({ issueId: entry.issueId, ...started });
-            if (issue.repo)
-                repoSlots.set(issue.repo, { issueId: issue.id, title: issue.title });
         }
         catch (err) {
             const message = err instanceof StartPreconditionError
@@ -395,6 +352,13 @@ export function slotWaitReason() {
     const titles = running.map((i) => i.title).join(", ");
     return titles ? `waiting for slot — running: ${titles}` : "waiting for slot";
 }
+/**
+ * NOT-371: rows persisted under the removed NOT-215 per-repository exclusion still
+ * carry `waiting for repository slot` text until a tick or refresh overwrites them.
+ * The read model never emits that dead reason — it clears to "next up" (or the live
+ * capacity overlay) so operators never see a gate that no longer exists.
+ */
+const staleRepositorySlotReason = /waiting for repository slot/;
 /**
  * The queue as operators read it: 1-based positions (rank, not the raw stored column, which
  * legacy rows may have left sparse) and the current blocker per entry. While capacity is
@@ -407,7 +371,10 @@ export function listQueuedEntriesForRead() {
     return listQueuedEntries().map((entry, index) => ({
         ...entry,
         position: index + 1,
-        waitReason: slotReason ?? entry.waitReason,
+        waitReason: slotReason ??
+            (entry.waitReason && staleRepositorySlotReason.test(entry.waitReason)
+                ? null
+                : entry.waitReason),
     }));
 }
 export function queueStatusForIssue(issueId) {
@@ -466,8 +433,9 @@ export async function startIssueViaQueue(issueId) {
 /**
  * NOT-217 strict direct execution: attempt immediate admission for one issue without
  * touching the queue — no enqueue, no move-to-front, no reorder. It bypasses queue
- * *order* only: capacity (global + per-repository), readiness, Linear blockers, agent
- * health, runtime caps, and the active-workflow/frozen-snapshot guard all still refuse.
+ * *order* only: global capacity, readiness, Linear blockers, agent health, runtime
+ * caps, and the active-workflow/frozen-snapshot guard all still refuse (NOT-371:
+ * same-repository siblings never refuse — only a full global limit does).
  *
  * The eligibility + capacity checks are the same ones `admitNext` walks (same rules,
  * same policy, same persisted NOT-215 limit); the check, workflow start, and
@@ -489,18 +457,12 @@ export async function executeIssueNow(issueId) {
     if (!startableStatuses.has(issue.status)) {
         return { state: "error", code: 409, error: `Issue is ${issue.status} — not startable` };
     }
-    // Fail-closed pre-checks, same order as the admitNext walk: global capacity, then the
-    // per-repository exclusion, then the shared eligibility rules. Read-only — the queue
-    // is never written on any path below except startWorkflowCore's own force-admit.
+    // Fail-closed pre-checks, same order as the admitNext walk: global capacity, then
+    // the shared eligibility rules. Read-only — the queue is never written on any path
+    // below except startWorkflowCore's own force-admit.
     if (capacityPolicy(listOccupyingIssues()) <= 0) {
         return { state: "refused", reason: slotWaitReason() ?? "waiting for slot" };
     }
-    if (issue.repo) {
-        const slot = occupyingRepoSlots().get(issue.repo);
-        if (slot && slot.issueId !== issue.id) {
-            return { state: "refused", reason: repositorySlotReason(issue.repo, slot.title) };
-        }
-    }
     const [deckOnline, blockers] = await Promise.all([
         checkAgentDeckHealth(),
         blockerSnapshotFor([issue]),
@@ -514,8 +476,8 @@ export async function executeIssueNow(issueId) {
         return { state: "refused", reason: eligibility.reason };
     // Atomic check + start + queue transition. Async eligibility above cannot run inside
     // the sync transaction, so re-verify everything a concurrent start could have changed
-    // (occupancy, repo slot, active workflow, readiness via startWorkflowCore) before
-    // writing. A refusal here rolls the transaction back — still no queue mutation.
+    // (occupancy, active workflow, readiness via startWorkflowCore) before writing.
+    // A refusal here rolls the transaction back — still no queue mutation.
     try {
         const started = getDb().transaction(() => {
             const fresh = getIssue(issueId);
@@ -527,12 +489,6 @@ export async function executeIssueNow(issueId) {
             if (capacityPolicy(listOccupyingIssues()) <= 0) {
                 throw new StartPreconditionError(409, slotWaitReason() ?? "waiting for slot");
             }
-            if (fresh.repo) {
-                const slot = occupyingRepoSlots().get(fresh.repo);
-                if (slot && slot.issueId !== fresh.id) {
-                    throw new StartPreconditionError(409, repositorySlotReason(fresh.repo, slot.title));
-                }
-            }
             return startWorkflowCore(issueId);
         })();
         return { state: "admitted", ...started };
@@ -551,8 +507,10 @@ export async function executeIssueNow(issueId) {
 /**
  * NOT-217: re-derive one queued entry's persisted wait reason after an operator edit
  * changed what admission sees (e.g. a new developer agent). Same rule order as the
- * admitNext walk — capacity, repository slot, shared eligibility — cleared (null) when
- * the issue is currently admittable so the row reads "next up". No reorder, no admit.
+ * admitNext walk — capacity, shared eligibility — cleared (null) when the issue is
+ * currently admittable so the row reads "next up". No reorder, no admit.
+ * NOT-371: a stale `waiting for repository slot` row is overwritten here with the
+ * current real reason (or cleared), since repository identity no longer gates.
  */
 export async function refreshQueueWaitReasonForIssue(issueId) {
     const entry = getQueuedEntryForIssue(issueId);
@@ -567,13 +525,6 @@ export async function refreshQueueWaitReasonForIssue(issueId) {
             setQueueWaitReason(entry.id, slotReason);
         return queueStatusForIssue(issueId);
     }
-    if (issue.repo) {
-        const slot = occupyingRepoSlots().get(issue.repo);
-        if (slot && slot.issueId !== issue.id) {
-            setQueueWaitReason(entry.id, repositorySlotReason(issue.repo, slot.title));
-            return queueStatusForIssue(issueId);
-        }
-    }
     const [deckOnline, blockers] = await Promise.all([
         checkAgentDeckHealth(),
         blockerSnapshotFor([issue]),

package/bundle/server/dist/coordinator/admission.test.js

@@ -15,9 +15,9 @@ const { createIssue, getIssue, updateIssue } = await import("../repository/issue
 const { listHumanActionsForIssue } = await import("../repository/human-actions.js");
 const { getActiveWorkflowInstance } = await import("../repository/workflow-events.js");
 const { recordRuntimeAvailability, clearAllRuntimeAvailability } = await import("../repository/runtime-availability.js");
-const { enqueueIssue, enqueueIssueWithOutcome, dequeueIssue, listQueuedEntries, getQueuedEntryForIssue } = await import("../repository/queue-entries.js");
+const { enqueueIssue, enqueueIssueWithOutcome, dequeueIssue, listQueuedEntries, getQueuedEntryForIssue, setQueueWaitReason } = await import("../repository/queue-entries.js");
 const { startWorkflow } = await import("./commands.js");
-const { sequentialCapacityPolicy, occupyingStatuses, countOccupyingIssues, admitNext, checkRoleAgentHealthy, getAdmissionStatus, setAdmissionHealthCheckerForTests, setCapacityPolicyForTests, resetCapacityPolicyForTests, resetEligibilityRulesForTests } = await import("./admission.js");
+const { sequentialCapacityPolicy, occupyingStatuses, countOccupyingIssues, admitNext, checkRoleAgentHealthy, getAdmissionStatus, listQueuedEntriesForRead, queueStatusForIssue, refreshQueueWaitReasonForIssue, setAdmissionHealthCheckerForTests, setCapacityPolicyForTests, resetCapacityPolicyForTests, resetEligibilityRulesForTests } = await import("./admission.js");
 const { getMaxActiveIssues, setMaxActiveIssues, getEffectiveMaxActiveIssues, admissionLimitOptions, workerSpawnCeiling, } = await import("../repository/admission-settings.js");
 const { setBlockersProviderForTests, resetDependenciesForTests } = await import("./dependencies.js");
 before(() => migrate());
@@ -771,6 +771,24 @@ function linearIssue(suffix, externalId, runtimes = { dev: "codex_local", rev: "
         externalLabel: `NOT-${suffix}`
     });
 }
+/** NOT-371: a Linear-tracked issue pinned to a shared repository (blocker tests). */
+function linearIssueInRepo(suffix, externalId, repo) {
+    const { dev, rev } = seedAgents(`linrepo-${suffix}`);
+    return createIssue({
+        title: `Linear ${suffix}`,
+        description: "d",
+        acceptanceCriteria: "It works",
+        repo,
+        baseBranch: "main",
+        developerAgentId: dev.id,
+        reviewerAgentId: rev.id,
+        maxReviewRounds: 2,
+        maxInfraAttempts: 2,
+        source: "linear",
+        externalId,
+        externalLabel: `NOT-${suffix}`
+    });
+}
 function instanceCount(issueId) {
     return getDb().prepare("SELECT COUNT(*) AS n FROM workflow_instances WHERE issue_id = ?").get(issueId).n;
 }
@@ -820,28 +838,94 @@ test("NOT-215: fixed capacity 2 admits two eligible different-repository issues
         overCap: false,
     });
 });
-test("NOT-215: same-repository issues never run concurrently; the waiter names the conflict", async () => {
+test("NOT-371: fixed capacity 2 admits two independent same-repository issues in one tick", async () => {
     setMaxActiveIssues(2);
     const repo = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-admit-samerepo-"));
     const a = readyIssueInRepo("same-a", repo);
     const b = readyIssueInRepo("same-b", repo);
     enqueueIssue(a.id);
     enqueueIssue(b.id);
-    assert.equal((await admitNext())?.issueId, a.id);
+    const first = await admitNext();
+    assert.equal(first?.issueId, a.id);
     assert.equal(getIssue(a.id).status, "developing");
-    assert.equal(getIssue(b.id).status, "ready");
-    assert.equal(getActiveWorkflowInstance(b.id), null);
-    assert.equal(instanceCount(b.id), 0);
-    const entry = getQueuedEntryForIssue(b.id);
+    assert.equal(getIssue(b.id).status, "developing");
+    assert.equal(listQueuedEntries().length, 0);
+    assert.equal(instanceCount(a.id), 1);
+    assert.equal(instanceCount(b.id), 1);
+    assert.notEqual(getActiveWorkflowInstance(a.id).id, getActiveWorkflowInstance(b.id).id, "each issue gets its own active workflow instance");
+    // No repository-slot wait reason anywhere — neither persisted nor on read.
+    for (const read of listQueuedEntriesForRead()) {
+        assert.doesNotMatch(read.waitReason ?? "", /repository slot/);
+    }
+    // Second tick admits nothing new and duplicates nothing.
+    assert.equal(await admitNext(), null);
+    assert.equal(instanceCount(a.id), 1);
+    assert.equal(instanceCount(b.id), 1);
+});
+test("NOT-371: an explicitly blocked same-repository issue waits while a later independent sibling skips ahead", async () => {
+    setMaxActiveIssues(2);
+    const repo = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-admit-blockedrepo-"));
+    const blocked = linearIssueInRepo("blk", "lin-371-blk", repo);
+    const free = readyIssueInRepo("free", repo);
+    setBlockersProviderForTests(async (issues) => new Map(issues.map((i) => [
+        i.externalId,
+        i.externalId === "lin-371-blk"
+            ? [{ id: "", identifier: "NOT-1", stateName: "In Progress", stateType: "started" }]
+            : [],
+    ])));
+    enqueueIssue(blocked.id);
+    enqueueIssue(free.id);
+    // The free slot goes to the later independent sibling, not the blocked head.
+    assert.equal((await admitNext())?.issueId, free.id);
+    assert.equal(getIssue(free.id).status, "developing");
+    assert.equal(getIssue(blocked.id).status, "ready");
+    assert.equal(getActiveWorkflowInstance(blocked.id), null);
+    assert.equal(instanceCount(blocked.id), 0);
+    const entry = getQueuedEntryForIssue(blocked.id);
     assert.equal(entry.state, "queued");
-    assert.match(entry.waitReason ?? "", /repository slot/);
-    assert.ok((entry.waitReason ?? "").includes(repo), `reason names the conflicting repo: ${entry.waitReason}`);
-    assert.ok((entry.waitReason ?? "").includes(a.title), `reason names the active issue: ${entry.waitReason}`);
-    // The repo slot frees when the first issue leaves occupying states — then the waiter admits.
-    releaseToNeedsHuman(a.id);
-    assert.equal((await admitNext())?.issueId, b.id);
+    assert.match(entry.waitReason ?? "", /waiting on NOT-1/);
+    assert.doesNotMatch(entry.waitReason ?? "", /repository slot/);
+    // The declared blocker is satisfied and a slot frees — the next tick admits the waiter.
+    setBlockersProviderForTests(async (issues) => new Map(issues.map((i) => [i.externalId, []])));
+    releaseToNeedsHuman(free.id);
+    assert.equal((await admitNext())?.issueId, blocked.id);
+    assert.equal(getIssue(blocked.id).status, "developing");
+});
+test("NOT-371: a stale persisted repository-slot reason never surfaces and clears on refresh", async () => {
+    setMaxActiveIssues(2);
+    const repo = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-admit-stalerepo-"));
+    const a = readyIssueInRepo("stale-a", repo);
+    const b = readyIssueInRepo("stale-b", repo);
+    enqueueIssue(a.id);
+    enqueueIssue(b.id);
+    // Simulate a row persisted under the removed NOT-215 exclusion.
+    const stale = `waiting for repository slot — ${repo} already active (Issue stale-a)`;
+    setQueueWaitReason(getQueuedEntryForIssue(b.id).id, stale);
+    // Read model: the dead reason clears to "next up" while a slot is free.
+    assert.equal(queueStatusForIssue(b.id)?.waitReason, null);
+    assert.equal(listQueuedEntriesForRead().find((e) => e.issueId === b.id)?.waitReason, null);
+    // Refresh: the persisted row is overwritten with the current real reason (none — admittable).
+    const refreshed = await refreshQueueWaitReasonForIssue(b.id);
+    assert.equal(refreshed?.waitReason, null);
+    assert.equal(refreshed?.position, 2);
+    assert.equal(getQueuedEntryForIssue(b.id)?.waitReason, null);
+    // And the issue itself admits alongside its same-repo sibling.
+    assert.equal((await admitNext())?.issueId, a.id);
     assert.equal(getIssue(b.id).status, "developing");
 });
+test("NOT-371: a stale repository-slot row under a full system reads as the live capacity reason", async () => {
+    const a = readyIssue("stalefull-a");
+    const b = readyIssue("stalefull-b");
+    enqueueIssue(a.id);
+    enqueueIssue(b.id);
+    await admitNext();
+    assert.equal(getIssue(a.id).status, "developing");
+    // Default limit 1: the system is full; overwrite b's persisted reason with the dead text.
+    setQueueWaitReason(getQueuedEntryForIssue(b.id).id, "waiting for repository slot — acme/old already active (Issue stalefull-a)");
+    const read = queueStatusForIssue(b.id)?.waitReason ?? "";
+    assert.match(read, /waiting for slot/);
+    assert.doesNotMatch(read, /repository slot/);
+});
 test("NOT-215: blocked/capped entries stay queued while later eligible different-repo entries fill both slots", async () => {
     setMaxActiveIssues(2);
     const blocked = linearIssue("blk", "lin-blk");
@@ -901,6 +985,121 @@ test("NOT-215: lowering 2 → 1 never preempts; admission pauses until occupancy
     assert.equal((await admitNext())?.issueId, c.id);
     assert.equal(getIssue(c.id).status, "developing");
 });
+test("NOT-378: limit 5 fills all five slots in one tick across same and different repositories; a sixth waits on global capacity", async () => {
+    setMaxActiveIssues(5);
+    const repo = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-admit-five-"));
+    const same1 = readyIssueInRepo("five-s1", repo);
+    const same2 = readyIssueInRepo("five-s2", repo);
+    const same3 = readyIssueInRepo("five-s3", repo);
+    const diff1 = readyIssue("five-d1");
+    const diff2 = readyIssue("five-d2");
+    const sixth = readyIssue("five-d3");
+    enqueueIssue(same1.id);
+    enqueueIssue(same2.id);
+    enqueueIssue(same3.id);
+    enqueueIssue(diff1.id);
+    enqueueIssue(diff2.id);
+    enqueueIssue(sixth.id);
+    const first = await admitNext();
+    assert.equal(first?.issueId, same1.id);
+    for (const issue of [same1, same2, same3, diff1, diff2]) {
+        assert.equal(getIssue(issue.id).status, "developing");
+        assert.equal(instanceCount(issue.id), 1);
+    }
+    const instanceIds = new Set([same1, same2, same3, diff1, diff2].map((issue) => getActiveWorkflowInstance(issue.id).id));
+    assert.equal(instanceIds.size, 5, "each issue gets its own active workflow instance");
+    assert.equal(getIssue(sixth.id).status, "ready");
+    assert.equal(getActiveWorkflowInstance(sixth.id), null);
+    assert.equal(instanceCount(sixth.id), 0);
+    // Live global wait reason on read — never a repository-slot reason anywhere.
+    const live = queueStatusForIssue(sixth.id)?.waitReason ?? "";
+    assert.match(live, /waiting for slot/);
+    assert.doesNotMatch(live, /repository slot/);
+    for (const read of listQueuedEntriesForRead()) {
+        assert.doesNotMatch(read.waitReason ?? "", /repository slot/);
+    }
+    // A second tick persists the slot reason and admits nothing new.
+    assert.equal(await admitNext(), null);
+    assert.match(getQueuedEntryForIssue(sixth.id)?.waitReason ?? "", /waiting for slot/);
+    assert.equal(instanceCount(sixth.id), 0);
+});
+test("NOT-378: declared blockers skip ahead correctly with five slots; the waiter admits once its blocker clears", async () => {
+    setMaxActiveIssues(5);
+    const repo = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-admit-fiveblk-"));
+    const blocked = linearIssueInRepo("fblk", "lin-378-blk", repo);
+    setBlockersProviderForTests(async (issues) => new Map(issues.map((i) => [
+        i.externalId,
+        i.externalId === "lin-378-blk"
+            ? [{ id: "", identifier: "NOT-1", stateName: "In Progress", stateType: "started" }]
+            : [],
+    ])));
+    const free = [
+        readyIssueInRepo("fblk-f1", repo),
+        readyIssueInRepo("fblk-f2", repo),
+        readyIssue("fblk-f3"),
+        readyIssue("fblk-f4"),
+        readyIssue("fblk-f5"),
+    ];
+    enqueueIssue(blocked.id);
+    for (const issue of free)
+        enqueueIssue(issue.id);
+    assert.equal((await admitNext())?.issueId, free[0].id);
+    for (const issue of free) {
+        assert.equal(getIssue(issue.id).status, "developing");
+        assert.equal(instanceCount(issue.id), 1);
+    }
+    assert.equal(getIssue(blocked.id).status, "ready");
+    assert.equal(getActiveWorkflowInstance(blocked.id), null);
+    assert.equal(instanceCount(blocked.id), 0);
+    const entry = getQueuedEntryForIssue(blocked.id);
+    assert.equal(entry.state, "queued");
+    assert.match(entry.waitReason ?? "", /waiting on NOT-1/);
+    assert.doesNotMatch(entry.waitReason ?? "", /repository slot/);
+    // The declared blocker is satisfied and a slot frees — the next tick admits the waiter.
+    setBlockersProviderForTests(async (issues) => new Map(issues.map((i) => [i.externalId, []])));
+    releaseToNeedsHuman(free[0].id);
+    assert.equal((await admitNext())?.issueId, blocked.id);
+    assert.equal(getIssue(blocked.id).status, "developing");
+});
+test("NOT-378: lowering 5 → 2 never preempts; admission pauses until occupancy drops below 2", async () => {
+    setMaxActiveIssues(5);
+    const active = [
+        readyIssue("low5-a"),
+        readyIssue("low5-b"),
+        readyIssue("low5-c"),
+        readyIssue("low5-d"),
+        readyIssue("low5-e"),
+    ];
+    for (const issue of active)
+        enqueueIssue(issue.id);
+    await admitNext();
+    for (const issue of active) {
+        assert.equal(getIssue(issue.id).status, "developing");
+    }
+    setMaxActiveIssues(2);
+    const waiter = readyIssue("low5-w");
+    enqueueIssue(waiter.id);
+    assert.equal(await admitNext(), null);
+    for (const issue of active) {
+        assert.equal(getIssue(issue.id).status, "developing", "lowering never stops running work");
+    }
+    assert.equal(getIssue(waiter.id).status, "ready");
+    assert.match(getQueuedEntryForIssue(waiter.id)?.waitReason ?? "", /waiting for slot/);
+    const over = getAdmissionStatus();
+    assert.equal(over.active, 5);
+    assert.equal(over.limit, 2);
+    assert.equal(over.overCap, true);
+    // Occupancy at the new limit is still not enough — it must fall *below* 2.
+    releaseToNeedsHuman(active[0].id);
+    releaseToNeedsHuman(active[1].id);
+    releaseToNeedsHuman(active[2].id);
+    assert.equal(await admitNext(), null);
+    assert.equal(getIssue(waiter.id).status, "ready");
+    assert.equal(getAdmissionStatus().overCap, false);
+    releaseToNeedsHuman(active[3].id);
+    assert.equal((await admitNext())?.issueId, waiter.id);
+    assert.equal(getIssue(waiter.id).status, "developing");
+});
 test("NOT-215: restart recovery observes the persisted setting without duplicate admission", async () => {
     setMaxActiveIssues(2);
     const a = readyIssue("rs-a");