agent-dealer 1.2.16 → 1.3.0

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");

package/bundle/server/dist/routes/execute-now.integration.test.js

@@ -2,8 +2,9 @@
 //
 // NOT-217 acceptance: strict direct execution bypasses queue order only. Execute now
 // admits an eligible issue immediately (queued or not) and refuses — without any
-// enqueue, move, or reorder — on capacity, repository, readiness, blocker, health, or
-// runtime-cap failure. Concurrent attempts cannot double-start or exceed capacity.
+// enqueue, move, or reorder — on capacity, readiness, blocker, health, or runtime-cap
+// failure (NOT-371: same-repository siblings admit while a global slot is free).
+// Concurrent attempts cannot double-start or exceed capacity.
 import { test, before, beforeEach, after } from "node:test";
 import assert from "node:assert/strict";
 import fs from "node:fs";
@@ -180,28 +181,48 @@ test("execute now refuses on an unmet Linear blocker without queue movement", as
     }
     await app.close();
 });
-test("execute now refuses when the same repository already has an active issue", async () => {
+test("NOT-371: execute now admits a same-repository issue when a global slot is free", async () => {
     const app = await buildApp();
     const { setMaxActiveIssues } = await import("../repository/admission-settings.js");
     try {
-        // Persisted NOT-215 limit 2: global capacity stays free so the per-repository
-        // exclusion is the reason under test.
+        // Persisted NOT-215 limit 2: the second global slot is free, so the
+        // same-repository sibling must admit — repository identity never refuses.
         setMaxActiveIssues(2);
         const active = await createIssueViaApi(app, "Active", { repo: "acme/same-repo" });
         assert.equal((await app.inject({ method: "POST", url: `/api/issues/${active}/execute` })).statusCode, 200);
-        const clash = await createIssueViaApi(app, "Clash", { repo: "acme/same-repo", enqueue: false });
-        const res = await app.inject({ method: "POST", url: `/api/issues/${clash}/execute` });
+        const sibling = await createIssueViaApi(app, "Sibling", { repo: "acme/same-repo", enqueue: false });
+        const res = await app.inject({ method: "POST", url: `/api/issues/${sibling}/execute` });
+        assert.equal(res.statusCode, 200, res.body);
+        assert.equal(res.json().state, "admitted");
+        assert.equal(getIssue(sibling).status, "developing");
+        assert.equal(getQueuedEntryForIssue(sibling), null, "success on an unqueued issue writes no queue row");
+        assert.equal(listWorkflowInstancesForIssue(sibling).length, 1);
+    }
+    finally {
+        setMaxActiveIssues(1);
+    }
+    await app.close();
+});
+test("NOT-371: execute now refuses a same-repository issue at full global capacity without queue mutation", async () => {
+    const app = await buildApp();
+    const { setMaxActiveIssues } = await import("../repository/admission-settings.js");
+    try {
+        setMaxActiveIssues(2);
+        const first = await createIssueViaApi(app, "First", { repo: "acme/same-repo" });
+        const second = await createIssueViaApi(app, "Second", { repo: "acme/same-repo", enqueue: false });
+        assert.equal((await app.inject({ method: "POST", url: `/api/issues/${first}/execute` })).statusCode, 200);
+        assert.equal((await app.inject({ method: "POST", url: `/api/issues/${second}/execute` })).statusCode, 200);
+        const q1 = await createIssueViaApi(app, "Q1", { repo: "acme/same-repo" });
+        const res = await app.inject({ method: "POST", url: `/api/issues/${q1}/execute` });
         assert.equal(res.statusCode, 409, res.body);
         const body = res.json();
         assert.equal(body.state, "refused");
-        assert.match(body.reason, /repository slot/);
-        assert.equal(body.queued, false);
-        assert.equal(getQueuedEntryForIssue(clash), null, "a refused execute never enqueues");
-        assert.equal(listWorkflowInstancesForIssue(clash).length, 0);
-        // A different repository still admits under the same free global slot.
-        const other = await createIssueViaApi(app, "Other repo", { repo: "acme/other-repo", enqueue: false });
-        const otherRes = await app.inject({ method: "POST", url: `/api/issues/${other}/execute` });
-        assert.equal(otherRes.statusCode, 200, otherRes.body);
+        assert.match(body.reason, /waiting for slot/);
+        assert.doesNotMatch(body.reason, /repository slot/);
+        assert.equal(body.queued, true);
+        assert.equal(body.position, 1);
+        assert.deepEqual(queuedIds(), [q1], "a refused execute never reorders");
+        assert.equal(listWorkflowInstancesForIssue(q1).length, 0);
     }
     finally {
         setMaxActiveIssues(1);

package/bundle/server/dist/routes/issues.test.js

@@ -877,12 +877,12 @@ test("NOT-240: PATCH repository plus agents on an unqueued ready issue succeeds,
     });
     await app.close();
 });
-test("NOT-240: PATCH repository on a queued ready issue preserves position and recomputes the repository wait reason", async () => {
+test("NOT-371: PATCH repository onto an active sibling's repo keeps position with no repository wait reason", async () => {
     const { setMaxActiveIssues } = await import("../repository/admission-settings.js");
     const app = await buildApp();
     try {
-        // Two global slots: one admitted issue never blocks on capacity, so the
-        // per-repository exclusion is the reason under test.
+        // Two global slots: one admitted issue never blocks on capacity, so the free
+        // slot proves repository identity alone never gates the queued sibling.
         setMaxActiveIssues(2);
         const mk = (title, repo) => app.inject({
             method: "POST",
@@ -901,7 +901,8 @@ test("NOT-240: PATCH repository on a queued ready issue preserves position and r
         const queuedId = (await mk("Queued mover", "acme/cold-repo")).json().id;
         assert.equal(queueStatusForIssue(queuedId)?.position, 1);
         assert.equal(queueStatusForIssue(queuedId)?.waitReason, null);
-        // Move onto the occupied repository: same position, repository-slot wait reason.
+        // Move onto the active sibling's repository: same position, still "next up" —
+        // no repository-slot wait reason is ever synthesized.
         const clash = await app.inject({
             method: "PATCH",
             url: `/api/issues/${queuedId}`,
@@ -910,8 +911,8 @@ test("NOT-240: PATCH repository on a queued ready issue preserves position and r
         assert.equal(clash.statusCode, 200, clash.body);
         assert.equal(clash.json().repo, "github.com/acme/hot-repo");
         assert.equal(queueStatusForIssue(queuedId)?.position, 1, "a repository change must not reorder");
-        assert.match(queueStatusForIssue(queuedId)?.waitReason ?? "", /repository slot/);
-        // Move off to a free repository: stale wait text is cleared, position kept.
+        assert.equal(queueStatusForIssue(queuedId)?.waitReason, null);
+        // Move off to another repository: identical read state, position kept.
         const free = await app.inject({
             method: "PATCH",
             url: `/api/issues/${queuedId}`,

package/bundle/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/server",
-  "version": "1.2.16",
+  "version": "1.3.0",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -23,7 +23,7 @@
     "test": "AGENT_DEALER_SKIP_GITHUB_HEALTH=1 AGENT_DEALER_SKIP_AGENT_HEALTH=1 npm run build -w @agent-dealer/shared && AGENT_DEALER_SKIP_GITHUB_HEALTH=1 AGENT_DEALER_SKIP_AGENT_HEALTH=1 node ../../scripts/run-workspace-tests.mjs"
   },
   "dependencies": {
-    "@agent-dealer/shared": "1.2.16",
+    "@agent-dealer/shared": "1.3.0",
     "@fastify/cors": "^11.0.1",
     "@fastify/static": "^8.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0",