agent-dealer 1.0.1 → 1.0.2

package/bundle/server/dist/direct-start-liveness.integration.test.js

@@ -15,12 +15,17 @@ import path from "node:path";
 import net from "node:net";
 import { fileURLToPath } from "node:url";
 import { resolveTsxBin } from "./resolve-tsx-bin.js";
+import { DirectStartLiveCleanup, sweepAbandonedDirectStartHomes, } from "./direct-start-temp-home-cleanup.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(__dirname, "..", "..", "..");
 const serverEntry = path.join(repoRoot, "packages", "server", "src", "index.ts");
 const tsxBin = resolveTsxBin(repoRoot);
 const { isServiceRunning, runMigration } = await import("./db/migrate-to-issues.js");
 const Database = (await import("better-sqlite3")).default;
+// One-time sweep of abandoned dealer-direct-start-* homes left by earlier interrupted
+// runs. Live-pid + recent-mtime guards keep this from deleting out from under a run
+// that is still in flight on this machine (NOT-140).
+sweepAbandonedDirectStartHomes(os.tmpdir());
 async function getEphemeralPort() {
     return new Promise((resolve, reject) => {
         const srv = net.createServer();
@@ -47,35 +52,40 @@ async function waitUntil(check, timeoutMs, stepMs = 150) {
         await new Promise((r) => setTimeout(r, stepMs));
     }
 }
+// Every server spawned by this file that stopServer() has not yet confirmed dead, plus
+// every temp home makeHome() still owns. A detached child sits in its own session, so it
+// no longer receives the terminal's SIGINT along with the test runner — the usual
+// "Ctrl-C reaps the whole foreground group" safety net does not cover these, and an
+// interrupted run would leak exactly what this file was leaking before. This registry is
+// that net, re-implemented explicitly — servers and homes share one reapAll so
+// process.exit(1) cannot clear one and abandon the other (NOT-140).
+const liveCleanup = new DirectStartLiveCleanup();
+function reapAllLiveCleanup() {
+    liveCleanup.reapAll(signalGroup);
+}
+process.on("exit", reapAllLiveCleanup);
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    // Registering a listener suppresses the default terminate, so exit explicitly.
+    process.on(signal, () => {
+        reapAllLiveCleanup();
+        process.exit(1);
+    });
+}
 /** A temp AGENT_DEALER_HOME that is deleted when the test ends, however it ends. Registered
  * as a test hook rather than dropped in a `finally` on purpose: teardown here asserts (that
  * the server it stopped is really dead), and an assertion that throws must not be able to
  * skip the cleanup and leave a directory behind — which is precisely how $TMPDIR filled up
  * with hundreds of these. Runs after the body's own `finally`, so servers are stopped by
- * then. */
+ * then. The interrupt path (SIGINT/SIGTERM/SIGHUP → process.exit) skips t.after, so the
+ * home is also tracked on `liveCleanup` and reaped there (NOT-140). */
 function makeHome(t, prefix) {
     const home = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-    return home;
-}
-// Every server spawned by this file that stopServer() has not yet confirmed dead. A
-// detached child sits in its own session, so it no longer receives the terminal's SIGINT
-// along with the test runner — the usual "Ctrl-C reaps the whole foreground group" safety
-// net does not cover these, and an interrupted run would leak exactly what this file was
-// leaking before. This registry is that net, re-implemented explicitly.
-const liveServers = new Set();
-function killAllServerGroups() {
-    for (const child of liveServers)
-        signalGroup(child, "SIGKILL");
-    liveServers.clear();
-}
-process.on("exit", killAllServerGroups);
-for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-    // Registering a listener suppresses the default terminate, so exit explicitly.
-    process.on(signal, () => {
-        killAllServerGroups();
-        process.exit(1);
+    liveCleanup.trackHome(home);
+    t.after(() => {
+        liveCleanup.untrackHome(home);
+        fs.rmSync(home, { recursive: true, force: true });
     });
+    return home;
 }
 function spawnServer(home, port) {
     const child = spawn(tsxBin, [serverEntry], {
@@ -94,10 +104,10 @@ function spawnServer(home, port) {
     // Every test awaits its own teardown, so this handle is never what keeps the run
     // correct — but while it is ref'd it *does* keep the runner's event loop alive, so a
     // teardown that throws before stopping a server wedges the whole file at 100% "waiting
-    // for a child that will never exit" instead of failing. unref() + killAllServerGroups()
+    // for a child that will never exit" instead of failing. unref() + reapAllLiveCleanup()
     // on exit is the pair that makes the failure path terminate and still reap.
     child.unref();
-    liveServers.add(child);
+    liveCleanup.addServer(child);
     return child;
 }
 function hasExited(child) {
@@ -182,7 +192,7 @@ async function stopServer(child, home) {
     if (recordedPid !== undefined) {
         assert.equal(isPidAlive(recordedPid), false, `the server pid recorded in server.pid (${recordedPid}) survived teardown — the tsx launcher (${child.pid}) was reaped but its server child leaked`);
     }
-    liveServers.delete(child);
+    liveCleanup.removeServer(child);
     return { exitedOnTerm, recordedPid };
 }
 async function waitForHealth(port, timeoutMs) {
@@ -348,3 +358,83 @@ test("a real running server blocks the migration end to end, and the migration s
         await stopServer(server, home);
     }
 });
+function listOrphanIndexTsPids() {
+    try {
+        const out = execFileSync("ps", ["-axo", "pid=,ppid=,command="], { encoding: "utf8" });
+        const orphans = [];
+        for (const line of out.split("\n")) {
+            const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+            if (!match)
+                continue;
+            const pid = Number(match[1]);
+            const ppid = Number(match[2]);
+            const command = match[3];
+            if (ppid === 1 && command.includes("packages/server/src/index.ts"))
+                orphans.push(pid);
+        }
+        return orphans;
+    }
+    catch {
+        return [];
+    }
+}
+test("SIGINT mid-run leaves zero dealer-direct-start homes from that run and no PPID=1 index.ts orphans", { timeout: 60000 }, async () => {
+    // Acceptance for NOT-140: the probe mirrors this file's signal handler (reapAll then
+    // process.exit(1)). process.exit skips t.after, so only the shared liveCleanup registry
+    // can remove the temp home — and it must still reap the detached server group.
+    const home = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-direct-start-sigint-"));
+    const readyFile = path.join(home, "ready.json");
+    const port = await getEphemeralPort();
+    const probe = path.join(__dirname, "direct-start-interrupt-probe.ts");
+    const orphansBefore = new Set(listOrphanIndexTsPids());
+    const probeChild = spawn(tsxBin, [probe, home, readyFile, serverEntry, String(port)], {
+        cwd: repoRoot,
+        stdio: "ignore",
+    });
+    try {
+        const ready = await waitUntil(() => fs.existsSync(readyFile), 15000);
+        assert.ok(ready, "interrupt probe should write its ready file");
+        const healthy = await waitForHealth(port, 20000);
+        assert.ok(healthy, "interrupt probe's server should become healthy before SIGINT");
+        probeChild.kill("SIGINT");
+        const exited = await waitUntil(() => probeChild.exitCode !== null || probeChild.signalCode !== null, 15000);
+        assert.ok(exited, "interrupt probe should exit after SIGINT");
+        assert.equal(fs.existsSync(home), false, "SIGINT must rmSync the tracked temp home — t.after never runs after process.exit(1)");
+        const orphansAfter = listOrphanIndexTsPids().filter((pid) => !orphansBefore.has(pid));
+        assert.deepEqual(orphansAfter, [], `SIGINT must not leave packages/server/src/index.ts reparented to init; new orphans: ${orphansAfter.join(",")}`);
+    }
+    finally {
+        // SIGKILL skips the probe's exit handler, so a stuck probe would leave its
+        // detached server group alive (often reparented to init). Prefer SIGINT so
+        // reapAll runs; only then SIGKILL the process group ourselves as a backstop.
+        if (probeChild.exitCode === null && probeChild.signalCode === null) {
+            probeChild.kill("SIGINT");
+            await waitUntil(() => probeChild.exitCode !== null || probeChild.signalCode !== null, 5000);
+        }
+        if (probeChild.exitCode === null && probeChild.signalCode === null) {
+            let launcherPid;
+            try {
+                launcherPid = JSON.parse(fs.readFileSync(readyFile, "utf8")).serverLauncherPid;
+            }
+            catch {
+                // ready file may be missing if the probe died before writing it
+            }
+            if (typeof launcherPid === "number" && Number.isFinite(launcherPid)) {
+                try {
+                    process.kill(-launcherPid, "SIGKILL");
+                }
+                catch {
+                    // ESRCH — group already gone
+                }
+            }
+            probeChild.kill("SIGKILL");
+        }
+        // If the probe failed before reaping, do not leave debris behind for the suite.
+        try {
+            fs.rmSync(home, { recursive: true, force: true });
+        }
+        catch {
+            // already gone on the success path
+        }
+    }
+});

package/bundle/server/dist/direct-start-temp-home-cleanup.js

@@ -0,0 +1,124 @@
+import fs from "node:fs";
+import path from "node:path";
+export const DIRECT_START_HOME_PREFIX = "dealer-direct-start-";
+/** Homes modified more recently than this are assumed to belong to a run in flight. */
+export const DEFAULT_RECENT_MS = 60_000;
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function readRecordedPid(home) {
+    try {
+        const recorded = JSON.parse(fs.readFileSync(path.join(home, "server.pid"), "utf8"))
+            .pid;
+        return typeof recorded === "number" && Number.isFinite(recorded) ? recorded : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * One registry for the interrupt path: every server spawnServer() still owns, and
+ * every temp home makeHome() still owns. reapAll() is the single net used by both
+ * process.on("exit") and the SIGINT/SIGTERM/SIGHUP handlers.
+ */
+export class DirectStartLiveCleanup {
+    servers = new Set();
+    homes = new Set();
+    trackHome(home) {
+        this.homes.add(home);
+    }
+    untrackHome(home) {
+        this.homes.delete(home);
+    }
+    addServer(child) {
+        this.servers.add(child);
+    }
+    removeServer(child) {
+        this.servers.delete(child);
+    }
+    /**
+     * Kill every tracked server group, then rmSync every tracked home.
+     * Order matters: never delete a home out from under a still-live server.
+     */
+    reapAll(signalGroup) {
+        for (const child of this.servers)
+            signalGroup(child, "SIGKILL");
+        this.servers.clear();
+        for (const home of this.homes) {
+            try {
+                fs.rmSync(home, { recursive: true, force: true });
+            }
+            catch {
+                // Best-effort on the interrupt path — do not throw out of a signal handler.
+            }
+        }
+        this.homes.clear();
+    }
+}
+export function shouldSweepHome(home, opts) {
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(home).mtimeMs;
+    }
+    catch {
+        return false;
+    }
+    if (opts.now - mtimeMs < opts.recentMs)
+        return false;
+    const pid = readRecordedPid(home);
+    if (pid !== undefined && opts.isPidAlive(pid))
+        return false;
+    return true;
+}
+/**
+ * One-time (or on-load) sweep of abandoned `$TMPDIR/dealer-direct-start-*` homes.
+ * Skips any home whose recorded server.pid is still alive, and any home modified
+ * within `recentMs`, so a concurrent in-flight run is never deleted out from under.
+ */
+export function sweepAbandonedDirectStartHomes(tmpDir, opts) {
+    const now = opts?.now ?? Date.now();
+    const recentMs = opts?.recentMs ?? DEFAULT_RECENT_MS;
+    const alive = opts?.isPidAlive ?? isPidAlive;
+    const prefix = opts?.prefix ?? DIRECT_START_HOME_PREFIX;
+    const removed = [];
+    const skipped = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(tmpDir);
+    }
+    catch {
+        return { removed, skipped };
+    }
+    for (const name of entries) {
+        if (!name.startsWith(prefix))
+            continue;
+        const home = path.join(tmpDir, name);
+        let st;
+        try {
+            st = fs.statSync(home);
+        }
+        catch {
+            continue;
+        }
+        if (!st.isDirectory())
+            continue;
+        if (!shouldSweepHome(home, { now, recentMs, isPidAlive: alive })) {
+            skipped.push(home);
+            continue;
+        }
+        try {
+            fs.rmSync(home, { recursive: true, force: true });
+            removed.push(home);
+        }
+        catch {
+            skipped.push(home);
+        }
+    }
+    return { removed, skipped };
+}

package/bundle/server/dist/direct-start-temp-home-cleanup.test.js

@@ -0,0 +1,92 @@
+// packages/server/src/direct-start-temp-home-cleanup.test.ts
+//
+// NOT-140: interrupt path must reap temp AGENT_DEALER_HOME dirs (process.exit skips
+// t.after), and a guarded one-time sweep must clear abandoned dealer-direct-start-* debris.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { DirectStartLiveCleanup, DEFAULT_RECENT_MS, sweepAbandonedDirectStartHomes, } from "./direct-start-temp-home-cleanup.js";
+function makeStaleHome(tmpDir, name, ageMs) {
+    const home = path.join(tmpDir, name);
+    fs.mkdirSync(home);
+    const when = new Date(Date.now() - ageMs);
+    fs.utimesSync(home, when, when);
+    return home;
+}
+test("DirectStartLiveCleanup.reapAll removes tracked homes after signalling servers", () => {
+    const cleanup = new DirectStartLiveCleanup();
+    const home = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-direct-start-reap-"));
+    cleanup.trackHome(home);
+    fs.writeFileSync(path.join(home, "marker"), "alive");
+    const signalled = [];
+    cleanup.reapAll((child, signal) => {
+        signalled.push({ child, signal });
+    });
+    assert.equal(fs.existsSync(home), false, "tracked home must be rmSync'd on reap");
+    assert.equal(cleanup.homes.size, 0);
+    assert.equal(cleanup.servers.size, 0);
+    assert.deepEqual(signalled, []);
+});
+test("sweepAbandonedDirectStartHomes removes stale homes without a live server.pid", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-sweep-root-"));
+    const stale = path.join(tmpDir, "dealer-direct-start-stale");
+    fs.mkdirSync(stale);
+    fs.writeFileSync(path.join(stale, "dealer.db"), "");
+    // utimes after writes — creating children bumps the directory mtime.
+    const when = new Date(Date.now() - (DEFAULT_RECENT_MS + 5_000));
+    fs.utimesSync(stale, when, when);
+    const result = sweepAbandonedDirectStartHomes(tmpDir, {
+        now: Date.now(),
+        recentMs: DEFAULT_RECENT_MS,
+        isPidAlive: () => false,
+    });
+    assert.equal(fs.existsSync(stale), false);
+    assert.deepEqual(result.removed, [stale]);
+    assert.deepEqual(result.skipped, []);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+test("sweepAbandonedDirectStartHomes skips a home whose server.pid names a live process", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-sweep-root-"));
+    const liveHome = path.join(tmpDir, "dealer-direct-start-live");
+    fs.mkdirSync(liveHome);
+    fs.writeFileSync(path.join(liveHome, "server.pid"), JSON.stringify({ pid: 424242 }));
+    const when = new Date(Date.now() - (DEFAULT_RECENT_MS + 5_000));
+    fs.utimesSync(liveHome, when, when);
+    const result = sweepAbandonedDirectStartHomes(tmpDir, {
+        now: Date.now(),
+        recentMs: DEFAULT_RECENT_MS,
+        isPidAlive: (pid) => pid === 424242,
+    });
+    assert.equal(fs.existsSync(liveHome), true, "must not delete out from under a live server");
+    assert.deepEqual(result.removed, []);
+    assert.deepEqual(result.skipped, [liveHome]);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+test("sweepAbandonedDirectStartHomes skips a recently-modified home", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-sweep-root-"));
+    const fresh = makeStaleHome(tmpDir, "dealer-direct-start-fresh", 1_000);
+    const result = sweepAbandonedDirectStartHomes(tmpDir, {
+        now: Date.now(),
+        recentMs: DEFAULT_RECENT_MS,
+        isPidAlive: () => false,
+    });
+    assert.equal(fs.existsSync(fresh), true, "must not delete a home still in use by a run in flight");
+    assert.deepEqual(result.removed, []);
+    assert.deepEqual(result.skipped, [fresh]);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+test("sweepAbandonedDirectStartHomes ignores directories that do not use the dealer-direct-start- prefix", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-sweep-root-"));
+    const other = makeStaleHome(tmpDir, "dealer-paths-unrelated", DEFAULT_RECENT_MS + 5_000);
+    const result = sweepAbandonedDirectStartHomes(tmpDir, {
+        now: Date.now(),
+        recentMs: DEFAULT_RECENT_MS,
+        isPidAlive: () => false,
+    });
+    assert.equal(fs.existsSync(other), true);
+    assert.deepEqual(result.removed, []);
+    assert.deepEqual(result.skipped, []);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});

package/bundle/server/dist/repository/queue-entries.js

@@ -94,24 +94,62 @@ export function enqueueIssueWithOutcome(issueId) {
     return { entry: getQueueEntry(id), created: true };
 }
 /**
- * NOT-118: move a queued entry to position 1 and renumber the rest 2..N in their current
- * order, so `position` stays a readable 1-based rank instead of drifting into negatives.
- * This is the only reorder primitive in the repo today — NOT-112's general reorder reuses
- * it rather than adding a second way to renumber the queue.
+ * Single position-computation path: write 1-based ranks for the given order.
+ * Callers must already hold a DB transaction when they need atomic reorder + lookup.
  */
-export function moveQueueEntryToTop(issueId) {
+function applyQueuedOrder(ordered) {
+    const setPosition = getDb().prepare("UPDATE queue_entries SET position = ? WHERE id = ?");
+    ordered.forEach((entry, index) => setPosition.run(index + 1, entry.id));
+}
+function buildOrderAfterMove(entry, without, to) {
+    if (to === "top")
+        return [entry, ...without];
+    if (to === "bottom")
+        return [...without, entry];
+    if ("before" in to) {
+        const idx = without.findIndex((e) => e.issueId === to.before);
+        if (idx < 0) {
+            throw Object.assign(new Error("Reference issue is not in the queue"), { code: 409 });
+        }
+        return [...without.slice(0, idx), entry, ...without.slice(idx)];
+    }
+    const idx = without.findIndex((e) => e.issueId === to.after);
+    if (idx < 0) {
+        throw Object.assign(new Error("Reference issue is not in the queue"), { code: 409 });
+    }
+    return [...without.slice(0, idx + 1), entry, ...without.slice(idx + 1)];
+}
+/**
+ * NOT-112: move a queued entry relative to the live queue (top / bottom / before / after).
+ * Only `queued` entries are orderable. Throws `{ code: 404 }` when the issue is not queued
+ * (missing or already admitted) and `{ code: 409 }` when a relative reference is gone.
+ */
+export function moveQueueEntry(issueId, to) {
     const db = getDb();
     return db.transaction(() => {
         const entry = getQueuedEntryForIssue(issueId);
-        if (!entry)
-            return null;
-        const rest = listQueuedEntries().filter((e) => e.issueId !== issueId);
-        const setPosition = db.prepare("UPDATE queue_entries SET position = ? WHERE id = ?");
-        setPosition.run(1, entry.id);
-        rest.forEach((e, index) => setPosition.run(index + 2, e.id));
+        if (!entry) {
+            throw Object.assign(new Error("Issue is not in the queue"), { code: 404 });
+        }
+        const without = listQueuedEntries().filter((e) => e.issueId !== issueId);
+        applyQueuedOrder(buildOrderAfterMove(entry, without, to));
         return getQueueEntry(entry.id);
     })();
 }
+/**
+ * NOT-118 Start: move to front. Thin wrapper over the shared renumber path — returns null
+ * when the issue is not queued (Start's enqueue step normally prevents that).
+ */
+export function moveQueueEntryToTop(issueId) {
+    try {
+        return moveQueueEntry(issueId, "top");
+    }
+    catch (err) {
+        if (err.code === 404)
+            return null;
+        throw err;
+    }
+}
 /** Operator dequeue — marks removed (keeps history row). Returns the removed entry or null. */
 export function dequeueIssue(issueId) {
     const entry = getQueuedEntryForIssue(issueId);

package/bundle/server/dist/routes/queue-reorder.integration.test.js

@@ -0,0 +1,144 @@
+// packages/server/src/routes/queue-reorder.integration.test.ts
+//
+// NOT-112 acceptance: operator can reorder queued issues via relative moves; admission
+// respects the new order; moving a missing/admitted entry fails clearly without corrupting
+// the remaining order.
+import { test, before, beforeEach, after } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import Fastify from "fastify";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not112-"));
+const { migrate, getDb } = await import("../db/index.js");
+const { createAgent } = await import("../repository/agents.js");
+const { getIssue } = await import("../repository/issues.js");
+const { listQueuedEntries, getQueuedEntryForIssue, markQueueEntryAdmitted } = await import("../repository/queue-entries.js");
+const { registerIssueRoutes } = await import("./issues.js");
+const { registerQueueRoutes } = await import("./queue.js");
+const { admitNext, setAdmissionHealthCheckerForTests, resetCapacityPolicyForTests, resetEligibilityRulesForTests, } = await import("../coordinator/admission.js");
+const { setBlockersProviderForTests, resetDependenciesForTests } = await import("../coordinator/dependencies.js");
+before(() => migrate());
+beforeEach(() => {
+    getDb().exec(`
+    DELETE FROM work_items;
+    DELETE FROM human_actions;
+    DELETE FROM workflow_events;
+    DELETE FROM worker_sessions;
+    DELETE FROM artifacts;
+    DELETE FROM workflow_instances;
+    DELETE FROM queue_entries;
+    DELETE FROM issues;
+  `);
+    setAdmissionHealthCheckerForTests(async () => ({ ok: true }));
+    setBlockersProviderForTests(async (issues) => new Map(issues.map((i) => [i.externalId, []])));
+    resetCapacityPolicyForTests();
+    resetEligibilityRulesForTests();
+});
+after(() => {
+    setAdmissionHealthCheckerForTests(null);
+    resetDependenciesForTests();
+});
+async function buildApp() {
+    const app = Fastify();
+    await registerIssueRoutes(app);
+    await registerQueueRoutes(app);
+    return app;
+}
+const repo = "acme/not112";
+const dev = createAgent({
+    name: `not112-dev-${Math.random()}`,
+    runtime: "claude_code",
+    deckId: "00000000-0000-4000-a000-000000000112",
+});
+const rev = createAgent({
+    name: `not112-rev-${Math.random()}`,
+    runtime: "claude_code",
+    deckId: "00000000-0000-4000-a000-000000000112",
+});
+async function createIssueViaApi(app, title) {
+    const res = await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: {
+            title,
+            repo,
+            baseBranch: "main",
+            developerAgentId: dev.id,
+            reviewerAgentId: rev.id,
+            acceptanceCriteria: "It works",
+        },
+    });
+    assert.equal(res.statusCode, 200);
+    return res.json().id;
+}
+async function moveViaApi(app, issueId, to) {
+    return app.inject({
+        method: "POST",
+        url: `/api/queue/${issueId}/move`,
+        payload: { to },
+    });
+}
+function queuedIds() {
+    return listQueuedEntries().map((e) => e.issueId);
+}
+test("POST /api/queue/:id/move supports top, bottom, before, and after", async () => {
+    const app = await buildApp();
+    const a = await createIssueViaApi(app, "A");
+    const b = await createIssueViaApi(app, "B");
+    const c = await createIssueViaApi(app, "C");
+    assert.deepEqual(queuedIds(), [a, b, c]);
+    let res = await moveViaApi(app, c, "top");
+    assert.equal(res.statusCode, 200);
+    assert.equal(res.json().issueId, c);
+    assert.equal(res.json().position, 1);
+    assert.deepEqual(queuedIds(), [c, a, b]);
+    res = await moveViaApi(app, c, "bottom");
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(queuedIds(), [a, b, c]);
+    res = await moveViaApi(app, c, { before: a });
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(queuedIds(), [c, a, b]);
+    res = await moveViaApi(app, c, { after: a });
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(queuedIds(), [a, c, b]);
+    await app.close();
+});
+test("next admission respects the reordered queue", async () => {
+    const app = await buildApp();
+    const a = await createIssueViaApi(app, "First");
+    const b = await createIssueViaApi(app, "Second");
+    const c = await createIssueViaApi(app, "Urgent");
+    assert.deepEqual(queuedIds(), [a, b, c]);
+    const moved = await moveViaApi(app, c, "top");
+    assert.equal(moved.statusCode, 200);
+    assert.deepEqual(queuedIds(), [c, a, b]);
+    const admitted = await admitNext();
+    assert.equal(admitted?.issueId, c);
+    assert.equal(getIssue(c).status, "developing");
+    assert.equal(getQueuedEntryForIssue(c), null);
+    assert.deepEqual(queuedIds(), [a, b]);
+    await app.close();
+});
+test("moving a missing or admitted entry returns a clear error and leaves order unchanged", async () => {
+    const app = await buildApp();
+    const a = await createIssueViaApi(app, "A");
+    const b = await createIssueViaApi(app, "B");
+    const c = await createIssueViaApi(app, "C");
+    assert.deepEqual(queuedIds(), [a, b, c]);
+    const missing = await moveViaApi(app, "00000000-0000-4000-a000-000000000099", "top");
+    assert.equal(missing.statusCode, 404);
+    assert.match(String(missing.json().error ?? ""), /not in the queue|not found/i);
+    assert.deepEqual(queuedIds(), [a, b, c]);
+    markQueueEntryAdmitted(c);
+    assert.equal(getQueuedEntryForIssue(c), null);
+    const admittedMove = await moveViaApi(app, c, "top");
+    assert.ok(admittedMove.statusCode === 404 || admittedMove.statusCode === 409);
+    assert.match(String(admittedMove.json().error ?? ""), /not in the queue|admitted/i);
+    assert.deepEqual(queuedIds(), [a, b]);
+    const relativeGone = await moveViaApi(app, a, { before: c });
+    assert.equal(relativeGone.statusCode, 409);
+    assert.match(String(relativeGone.json().error ?? ""), /not in the queue|reference/i);
+    assert.deepEqual(queuedIds(), [a, b]);
+    await app.close();
+});

package/bundle/server/dist/routes/queue.js

@@ -1,8 +1,9 @@
 // packages/server/src/routes/queue.ts
 //
 // NOT-103: operator enqueue / dequeue / list for the sequential admission queue.
-import { EnqueueIssueInput } from "@agent-dealer/shared";
-import { dequeueIssue, enqueueIssue, getQueuedEntryForIssue, } from "../repository/queue-entries.js";
+// NOT-112: relative reorder (top / bottom / before / after).
+import { EnqueueIssueInput, MoveQueueEntryInput } from "@agent-dealer/shared";
+import { dequeueIssue, enqueueIssue, getQueuedEntryForIssue, moveQueueEntry, } from "../repository/queue-entries.js";
 import { listQueuedEntriesForRead } from "../coordinator/admission.js";
 export async function registerQueueRoutes(app) {
     /** NOT-118: positions are 1-based ranks and a full system derives its own
@@ -28,6 +29,24 @@ export async function registerQueueRoutes(app) {
             throw err;
         }
     });
+    app.post("/api/queue/:issueId/move", async (req, reply) => {
+        const { issueId } = req.params;
+        const parsed = MoveQueueEntryInput.safeParse(req.body);
+        if (!parsed.success)
+            return reply.status(400).send({ error: parsed.error.message });
+        try {
+            return moveQueueEntry(issueId, parsed.data.to);
+        }
+        catch (err) {
+            const code = err.code;
+            const message = err instanceof Error ? err.message : String(err);
+            if (code === 404)
+                return reply.status(404).send({ error: message });
+            if (code === 409)
+                return reply.status(409).send({ error: message });
+            throw err;
+        }
+    });
     app.delete("/api/queue/:issueId", async (req, reply) => {
         const { issueId } = req.params;
         if (!getQueuedEntryForIssue(issueId)) {

package/bundle/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/server",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -22,7 +22,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@agent-dealer/shared": "1.0.1",
+    "@agent-dealer/shared": "1.0.2",
     "@fastify/cors": "^11.0.1",
     "@fastify/static": "^8.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0",