agent-dealer 1.2.15 → 1.3.0

package/bundle/server/dist/adapters/agent-health.js

@@ -104,6 +104,14 @@ let runCommandImpl = defaultRunCommand;
 export function setRunCommandForTests(fn) {
     runCommandImpl = fn ?? defaultRunCommand;
 }
+let runtimeIssuesUncachedForTests = null;
+/**
+ * Replace the live auth probe in coordinator tests. Pass `null` to restore the real probe.
+ * Cleared by {@link clearAgentHealthCaches}.
+ */
+export function setRuntimeIssuesUncachedForTests(fn) {
+    runtimeIssuesUncachedForTests = fn;
+}
 function runCommand(cmd, args, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS, env) {
     return runCommandImpl(cmd, args, timeoutMs, env);
 }
@@ -122,6 +130,7 @@ export function clearAgentHealthCaches() {
     githubIssueCache = null;
     cursorSoftFailStreak = 0;
     cursorLastHealthyAt = null;
+    runtimeIssuesUncachedForTests = null;
     resetMuseCapabilityStateForTests();
 }
 function isSoftCursorProbeIssue(issue) {
@@ -256,6 +265,9 @@ async function museRuntimeIssues() {
 }
 /** Exported for direct testing — bypasses the 60s cache in runtimeIssues(). */
 export async function runtimeIssuesUncached(runtime) {
+    if (runtimeIssuesUncachedForTests) {
+        return await runtimeIssuesUncachedForTests(runtime);
+    }
     const issues = [];
     if (runtime === "claude_code") {
         if (!claudeBinExists()) {
@@ -542,6 +554,15 @@ export async function healthForAgent(agent, agentDeckOnline, runtimeIssuesByRunt
     };
 }
 export async function listAgentsWithHealth(agents) {
+    // NOT-369: ensure the one-time AC sleep-timer notice is computed for the health surface
+    // (informational only — never attached as an AgentHealthIssue / never blocks admission).
+    try {
+        const { ensureSleepTimerCheckedAtStartup } = await import("../power/sleep-timer.js");
+        ensureSleepTimerCheckedAtStartup();
+    }
+    catch {
+        // Best-effort: health listing must not fail over power checks.
+    }
     const agentDeckOnline = await checkAgentDeckHealth();
     const mcpRegistration = checkAgentDeckMcpRegistration();
     const needsDeckAccess = agents.some((a) => a.deckId);

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/coordinator/auto-merge.js

@@ -32,6 +32,7 @@ import { MERGE_FAILURE_EVIDENCE_KEY, MERGE_FAILURE_RESPONSE_OPTIONS } from "./hu
 import { isMergeConflictFailure, runMergeConflictSync } from "./merge-conflict-sync.js";
 import { triggerLinearPostMerge } from "./linear-merge-verify.js";
 import { startBaseAdvancedScan } from "./base-advanced-scan.js";
+import { runHeldWork } from "../power/host-awake-lifecycle.js";
 import { OPERATOR_VERIFICATION_RESPONSE_OPTIONS, formatOperatorCriteria, getOperatorCriteriaForIssue, hasOperatorVerificationForHead, operatorVerificationRequestId, } from "./operator-criteria.js";
 const run = promisify(execFile);
 /** Bound each `gh` shell-out so a hang cannot freeze the coordinator process. */
@@ -173,6 +174,11 @@ export function isAutoMergeInFlight(issueId) {
 export function clearFinalizeInflightForTests() {
     finalizeInflight.clear();
 }
+/** Test seam: replace finalizeAutoMergeOnce inside the host-awake hold (lifecycle tests). */
+let finalizeOnceForTests = null;
+export function setFinalizeAutoMergeOnceForTests(fn) {
+    finalizeOnceForTests = fn;
+}
 /**
  * Completes an auto-merge parked in `final_review` / system ownership after reviewer
  * approve. Success → done + reflect; failure → needs_human + policy_escalation.
@@ -183,7 +189,8 @@ export function finalizeAutoMerge(issueId) {
     const existing = finalizeInflight.get(issueId);
     if (existing)
         return existing;
-    const promise = finalizeAutoMergeOnce(issueId).finally(() => {
+    // NOT-369: hold idle-sleep for the merge/publish step; release when it settles.
+    const promise = runHeldWork(() => (finalizeOnceForTests ?? finalizeAutoMergeOnce)(issueId)).finally(() => {
         if (finalizeInflight.get(issueId) === promise) {
             finalizeInflight.delete(issueId);
         }