agent-dealer 1.1.6 → 1.1.8

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

@@ -716,3 +716,38 @@ test("NOT-157: soft Cursor probe timeout waits with probe-timeout reason, not lo
         setAdmissionHealthCheckerForTests(async () => ({ ok: true }));
     }
 });
+// ---------------------------------------------------------------------------
+// NOT-239: Close issue vs the admission tick — exactly one terminal outcome.
+// ---------------------------------------------------------------------------
+test("NOT-239: closing the queue head lets the next tick admit the following issue", async () => {
+    const { closeReadyIssue } = await import("./commands.js");
+    const head = readyIssue("close-head");
+    const next = readyIssue("close-next");
+    enqueueIssue(head.id);
+    enqueueIssue(next.id);
+    // Close wins the race: the head retires without ever starting.
+    assert.deepEqual(closeReadyIssue(head.id, "web"), {
+        ok: true,
+        issueStatus: "closed",
+        alreadyClosed: false,
+    });
+    const admitted = await admitNext();
+    assert.equal(admitted?.issueId, next.id, "the tick fills the freed slot with the next issue");
+    assert.equal(getIssue(next.id).status, "developing");
+    assert.equal(getIssue(head.id).status, "closed");
+    assert.equal(instanceCount(head.id), 0, "close created no workflow instance");
+    assert.equal(instanceCount(next.id), 1);
+});
+test("NOT-239: a tick that admitted first makes a late close refuse", async () => {
+    const { closeReadyIssue } = await import("./commands.js");
+    const issue = readyIssue("close-late");
+    enqueueIssue(issue.id);
+    const admitted = await admitNext();
+    assert.equal(admitted?.issueId, issue.id);
+    const late = closeReadyIssue(issue.id, "web");
+    assert.equal(late.ok, false);
+    if (late.ok)
+        throw new Error("expected the late close to refuse");
+    assert.equal(late.code, 409);
+    assert.equal(getIssue(issue.id).status, "developing");
+});

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

@@ -33,7 +33,7 @@ import { AUTO_MERGE_INTENT, finalizeAutoMerge } from "./auto-merge.js";
 import { externalMergeStateForIssue } from "./external-merge.js";
 import { detectNonConvergence, formatNonConvergenceReason, reviewHistoryFromEvents, } from "./non-convergence.js";
 import { capEscalationEvents, deferLeasedWorkItemForBaseFetch, deferLeasedWorkItemForDeckOutage, deferLeasedWorkItemForUsageCap, formatCapEscalationReason, usageCapDeferralStartedAt, } from "./usage-cap-defer.js";
-import { markQueueEntryAdmitted } from "../repository/queue-entries.js";
+import { dequeueIssue, getQueuedEntryForIssue, markQueueEntryAdmitted, } from "../repository/queue-entries.js";
 import { getWorkflow } from "./workflows/registry.js";
 import { DEV_REVIEWER_V1_VERSION } from "./workflows/dev-reviewer-v1.js";
 /** Default start template — resolved through the workflow registry (NOT-70). */
@@ -1606,10 +1606,95 @@ export function abortIssue(issueId, resolvedBy, deps = defaultAbortDeps, opts) {
     return { ok: true, issueStatus: tx.issueStatus, alreadyClosed: tx.alreadyClosed };
 }
 /**
- * NOT-196 HTTP/CLI entry for abort: same as `abortIssue`, but pre-reads the PR merge
- * state outside the transaction first so an externally-merged PR lands the issue as
- * `done`. Issues without a PR number skip the `gh` call entirely.
+ * NOT-239: intentionally retire a `ready` issue that should never run — the
+ * pre-execution counterpart to abort, never an alias for it. One transaction
+ * re-reads the issue (never trusting a pre-transaction read), then atomically:
+ * transitions `ready` → `closed`, removes any queue entry, and appends one
+ * human-authored `issue.closed` event naming who closed it and whether it was
+ * queued. No workflow instance, work item, or worker session is created — there
+ * is nothing to create: any live work (an active instance, or pending/leased
+ * items on a `ready` row) refuses with 409 and keeps Abort workflow as the only
+ * way to stop running work. Non-`ready` statuses refuse the same way, so Close
+ * can never silently end in-flight work.
+ *
+ * Idempotent like abort: a repeated call once the issue is `done`/`closed`
+ * returns that state with no new event. A `closed` issue can never be admitted
+ * afterwards — enqueue rejects it, start/execute reject the status, and the
+ * coordinator tick's housekeeping drops any stale queued row.
  */
+export function closeReadyIssue(issueId, closedBy) {
+    if (!getIssue(issueId))
+        return { ok: false, code: 404, error: "Issue not found" };
+    const coded = (code, error) => {
+        throw Object.assign(new Error(error), { code });
+    };
+    let out;
+    try {
+        out = getDb().transaction(() => {
+            const issue = getIssue(issueId);
+            if (!issue)
+                coded(404, "Issue not found");
+            const fresh = issue;
+            if (fresh.status === "done" || fresh.status === "closed") {
+                return { alreadyClosed: true, issueStatus: fresh.status };
+            }
+            if (fresh.status !== "ready") {
+                coded(409, `Only a ready issue can be closed — issue is ${fresh.status}; use Abort workflow for in-flight work`);
+            }
+            if (getActiveWorkflowInstance(issueId)) {
+                coded(409, "Issue has an active workflow — use Abort workflow instead of Close issue");
+            }
+            for (const item of listWorkItemsForIssue(issueId)) {
+                if (item.status === "pending" || item.status === "leased") {
+                    coded(409, "Issue has pending work — use Abort workflow instead of Close issue");
+                }
+            }
+            const wasQueued = getQueuedEntryForIssue(issueId) != null;
+            // Nesting-safe (better-sqlite3 savepoints, same as the admit path): the
+            // removal joins this transaction, so dequeue + transition + event commit
+            // together — a coordinator tick racing this close either started first
+            // (the guards above refuse) or loses (its start preconditions fail).
+            if (wasQueued)
+                dequeueIssue(issueId);
+            // A dormant open action (e.g. on an unready `ready` row) must not outlive
+            // the issue as still-actionable work — resolve it as closed, not resumed.
+            let resolvedActions = 0;
+            for (const action of listHumanActionsForIssue(issueId)) {
+                if (action.status === "open") {
+                    resolveHumanAction(action.id, closedBy, { reason: "closed_by_operator" });
+                    resolvedActions += 1;
+                }
+            }
+            transitionIssue(issueId, "closed", {
+                currentOwner: "system",
+                currentIntent: "Closed by operator — will not execute",
+            });
+            appendWorkflowEvent({
+                issueId,
+                type: "issue.closed",
+                actorType: "human",
+                actorRef: closedBy,
+                stage: "closed",
+                payload: {
+                    reason: "closed_by_operator",
+                    closedBy,
+                    closedAt: new Date().toISOString(),
+                    wasQueued,
+                    resolvedActions,
+                },
+            });
+            return { alreadyClosed: false, issueStatus: "closed" };
+        })();
+    }
+    catch (err) {
+        const code = err.code;
+        const message = err instanceof Error ? err.message : String(err);
+        if (code === 404 || code === 409)
+            return { ok: false, code, error: message };
+        throw err;
+    }
+    return { ok: true, ...out };
+}
 export async function abortIssueAsync(issueId, resolvedBy, deps = defaultAbortDeps) {
     let externalMergeState;
     try {

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

@@ -1,6 +1,6 @@
 // packages/server/src/routes/issues.ts
 import fs from "node:fs";
-import { CreateIssueInput, UpdateIssueInput, } from "@agent-dealer/shared";
+import { CreateIssueInput, IssueStatus, UpdateIssueInput, } from "@agent-dealer/shared";
 import { getDb } from "../db/index.js";
 import { createIssue, getIssue, listIssues, findActiveIssueByExternalId, listIssuesByExternalId, queryIssues, updateIssue, listRecentRepos } from "../repository/issues.js";
 import { listWorkerSessionsForIssue, getActiveWorkerSessionForIssue } from "../repository/worker-sessions.js";
@@ -9,7 +9,7 @@ import { listUsageEventsForIssue, summarizeIssueUsage } from "../repository/usag
 import { listWorkflowEventsForIssue, appendWorkflowEvent, listWorkflowInstancesForIssue, getActiveWorkflowInstance, } from "../repository/workflow-events.js";
 import { listHumanActionsForIssue, listOpenHumanActions } from "../repository/human-actions.js";
 import { listFindingsForIssue } from "../repository/findings.js";
-import { abortIssueAsync, canEditParkedIssue, checkIssueReadiness } from "../coordinator/commands.js";
+import { abortIssueAsync, canEditParkedIssue, checkIssueReadiness, closeReadyIssue } from "../coordinator/commands.js";
 import { executeIssueNow, isStartable, queueStatusForIssue, refreshQueueWaitReasonForIssue, startIssueViaQueue, } from "../coordinator/admission.js";
 import { computeHumanWaitMs } from "../coordinator/metrics.js";
 import { enqueueIssue, enqueueIssueWithOutcome, getQueuedEntryForIssue } from "../repository/queue-entries.js";
@@ -66,9 +66,16 @@ export async function registerIssueRoutes(app) {
         // plus `{ page, limit, total, totalPages }`. Legacy callers (notably the
         // CLI status query) omit both and keep the existing unpaginated array.
         if (query.page !== undefined || query.limit !== undefined) {
-            const statuses = query.status
+            // NOT-239: the default Issues view is the *active* list — `closed` work
+            // leaves it and is found through an explicit status filter (`closed` or a
+            // list naming it) or the direct issue URL, never by hard delete. `done`
+            // stays in the default view (done semantics are unchanged).
+            const requested = query.status
                 ? query.status.split(",").map((s) => s.trim()).filter(Boolean)
-                : undefined;
+                : [];
+            const statuses = requested.length > 0
+                ? requested
+                : IssueStatus.options.filter((s) => s !== "closed");
             const result = queryIssues({
                 search: query.q,
                 status: statuses,
@@ -286,9 +293,13 @@ export async function registerIssueRoutes(app) {
                 if (conflict)
                     throw Object.assign(new Error(conflict), { code: 409 });
                 const next = updateIssue(id, parsed.data);
-                // NOT-217: durable reassignment audit — only when an assignment actually changed,
-                // comparing against the freshly read row so a concurrent edit is attributed exactly.
-                if (fresh.developerAgentId !== next.developerAgentId ||
+                // NOT-217/NOT-240: durable configuration audit — only when an execution input
+                // actually changed, comparing against the freshly read row so a concurrent edit
+                // is attributed exactly. Repository changes ride the same `issue.reassigned`
+                // event (extended with from/to repo) rather than silently changing where the
+                // issue will run.
+                if (fresh.repo !== next.repo ||
+                    fresh.developerAgentId !== next.developerAgentId ||
                     fresh.reviewerAgentId !== next.reviewerAgentId) {
                     appendWorkflowEvent({
                         issueId: id,
@@ -296,6 +307,8 @@ export async function registerIssueRoutes(app) {
                         actorType: "human",
                         stage: next.status,
                         payload: {
+                            fromRepo: fresh.repo,
+                            toRepo: next.repo,
                             fromDeveloperAgentId: fresh.developerAgentId,
                             toDeveloperAgentId: next.developerAgentId,
                             fromReviewerAgentId: fresh.reviewerAgentId,
@@ -368,6 +381,23 @@ export async function registerIssueRoutes(app) {
             return reply.status(result.code).send({ error: result.error });
         return { issueStatus: result.issueStatus, alreadyClosed: result.alreadyClosed };
     });
+    /**
+     * NOT-239: intentionally retire a `ready` issue that should never run — the
+     * pre-execution counterpart to abort, never an alias for it. Only `ready`
+     * with no active workflow may close (anything else answers 409 and keeps
+     * Abort workflow as the stop for running work). Atomically transitions to
+     * `closed`, removes any queue entry, and appends one human-authored
+     * `issue.closed` event. Idempotent: repeating on `done`/`closed` answers
+     * 200 with `alreadyClosed: true` and writes nothing.
+     */
+    app.post("/api/issues/:id/close", async (req, reply) => {
+        const { id } = req.params;
+        const body = req.body;
+        const result = closeReadyIssue(id, body?.closedBy?.trim() || "human");
+        if (!result.ok)
+            return reply.status(result.code).send({ error: result.error });
+        return { issueStatus: result.issueStatus, alreadyClosed: result.alreadyClosed };
+    });
     app.post("/api/issues/:id/guidance", async (req, reply) => {
         const { id } = req.params;
         const issue = getIssue(id);

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

@@ -23,7 +23,10 @@ const { listHumanActionsForIssue } = await import("../repository/human-actions.j
 const { applyCompletion, resolveHumanActionAndAdvance, getTaskSnapshot } = await import("../coordinator/commands.js");
 const { ReviewerResult } = await import("../coordinator/reviewer-result.js");
 const { getQueuedEntryForIssue, listQueuedEntries } = await import("../repository/queue-entries.js");
-const { setAdmissionHealthCheckerForTests, queueStatusForIssue } = await import("../coordinator/admission.js");
+const { admitNext, setAdmissionHealthCheckerForTests, queueStatusForIssue } = await import("../coordinator/admission.js");
+const { listWorkflowInstancesForIssue } = await import("../repository/workflow-events.js");
+const { listWorkItemsForIssue } = await import("../repository/work-items.js");
+const { listWorkerSessionsForIssue } = await import("../repository/worker-sessions.js");
 const { createAgent } = await import("../repository/agents.js");
 const { listWorkflowEventsForIssue } = await import("../repository/workflow-events.js");
 before(() => {
@@ -637,6 +640,8 @@ test("NOT-217: PATCH agent assignments on a queued issue preserves position, ref
         const events = listWorkflowEventsForIssue(a).filter((e) => e.type === "issue.reassigned");
         assert.equal(events.length, 1);
         assert.deepEqual(JSON.parse(events[0].payloadJson), {
+            fromRepo: "github.com/acme/app",
+            toRepo: "github.com/acme/app",
             fromDeveloperAgentId: BUILTIN_AGENT_CURSOR_ID,
             toDeveloperAgentId: BUILTIN_AGENT_CLAUDE_ID,
             fromReviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
@@ -755,6 +760,8 @@ test("NOT-217: PATCH reviewer-only edit records before/after reviewers without t
     const events = listWorkflowEventsForIssue(created.id).filter((e) => e.type === "issue.reassigned");
     assert.equal(events.length, 1);
     assert.deepEqual(JSON.parse(events[0].payloadJson), {
+        fromRepo: "github.com/acme/app",
+        toRepo: "github.com/acme/app",
         fromDeveloperAgentId: BUILTIN_AGENT_CURSOR_ID,
         toDeveloperAgentId: BUILTIN_AGENT_CURSOR_ID,
         fromReviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
@@ -826,3 +833,328 @@ test("NOT-217: PATCH that races admission answers 409 and never mutates the froz
     assert.equal(listWorkflowEventsForIssue(created.id).filter((e) => e.type === "issue.reassigned").length, 0, "a conflicted edit leaves no audit event");
     await app.close();
 });
+test("NOT-240: PATCH repository plus agents on an unqueued ready issue succeeds, stays unqueued, and audits before/after", async () => {
+    const app = await buildApp();
+    const created = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: {
+            title: "Unqueued reconfig",
+            repo: "acme/old-repo",
+            baseBranch: "main",
+            developerAgentId: BUILTIN_AGENT_CURSOR_ID,
+            reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+            acceptanceCriteria: "It works",
+            enqueue: false,
+        },
+    })).json();
+    assert.equal(getQueuedEntryForIssue(created.id), null);
+    const res = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${created.id}`,
+        payload: {
+            repo: "https://github.com/acme/new-repo.git",
+            developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+            reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        },
+    });
+    assert.equal(res.statusCode, 200, res.body);
+    const body = res.json();
+    assert.equal(body.repo, "github.com/acme/new-repo", "repo is normalized like issue creation");
+    assert.equal(body.developerAgentId, BUILTIN_AGENT_CLAUDE_ID);
+    assert.equal(body.reviewerAgentId, BUILTIN_AGENT_CURSOR_ID);
+    assert.equal(getQueuedEntryForIssue(created.id), null, "an unqueued save stays unqueued");
+    const events = listWorkflowEventsForIssue(created.id).filter((e) => e.type === "issue.reassigned");
+    assert.equal(events.length, 1);
+    assert.deepEqual(JSON.parse(events[0].payloadJson), {
+        fromRepo: "github.com/acme/old-repo",
+        toRepo: "github.com/acme/new-repo",
+        fromDeveloperAgentId: BUILTIN_AGENT_CURSOR_ID,
+        toDeveloperAgentId: BUILTIN_AGENT_CLAUDE_ID,
+        fromReviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        toReviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+    });
+    await app.close();
+});
+test("NOT-240: PATCH repository on a queued ready issue preserves position and recomputes the 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.
+        setMaxActiveIssues(2);
+        const mk = (title, repo) => app.inject({
+            method: "POST",
+            url: "/api/issues",
+            payload: {
+                title,
+                repo,
+                baseBranch: "main",
+                developerAgentId: BUILTIN_AGENT_CURSOR_ID,
+                reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+                acceptanceCriteria: "It works",
+            },
+        });
+        const holderId = (await mk("Repo holder", "acme/hot-repo")).json().id;
+        assert.equal((await app.inject({ method: "POST", url: `/api/issues/${holderId}/execute` })).statusCode, 200);
+        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.
+        const clash = await app.inject({
+            method: "PATCH",
+            url: `/api/issues/${queuedId}`,
+            payload: { repo: "acme/hot-repo" },
+        });
+        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.
+        const free = await app.inject({
+            method: "PATCH",
+            url: `/api/issues/${queuedId}`,
+            payload: { repo: "acme/free-repo" },
+        });
+        assert.equal(free.statusCode, 200, free.body);
+        assert.equal(queueStatusForIssue(queuedId)?.position, 1);
+        assert.equal(queueStatusForIssue(queuedId)?.waitReason, null);
+        const events = listWorkflowEventsForIssue(queuedId).filter((e) => e.type === "issue.reassigned");
+        assert.equal(events.length, 2, "each repository change is its own audit event");
+        assert.deepEqual(JSON.parse(events[0].payloadJson), {
+            fromRepo: "github.com/acme/cold-repo",
+            toRepo: "github.com/acme/hot-repo",
+            fromDeveloperAgentId: BUILTIN_AGENT_CURSOR_ID,
+            toDeveloperAgentId: BUILTIN_AGENT_CURSOR_ID,
+            fromReviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+            toReviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        });
+    }
+    finally {
+        setMaxActiveIssues(1);
+    }
+    await app.close();
+});
+test("NOT-240: PATCH rejects an invalid repository and leaves the row and audit untouched", async () => {
+    const app = await buildApp();
+    const created = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: {
+            title: "Repo validation",
+            repo: "acme/app",
+            baseBranch: "main",
+            developerAgentId: BUILTIN_AGENT_CURSOR_ID,
+            reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+            acceptanceCriteria: "It works",
+            enqueue: false,
+        },
+    })).json();
+    const bad = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${created.id}`,
+        payload: { repo: "/tmp/local-path" },
+    });
+    assert.equal(bad.statusCode, 400);
+    assert.equal(getIssue(created.id).repo, "github.com/acme/app");
+    assert.equal(listWorkflowEventsForIssue(created.id).filter((e) => e.type === "issue.reassigned").length, 0);
+    // A same-value repository rewrite is a no-op: 200 with no audit event.
+    const same = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${created.id}`,
+        payload: { repo: "acme/app" },
+    });
+    assert.equal(same.statusCode, 200, same.body);
+    assert.equal(listWorkflowEventsForIssue(created.id).filter((e) => e.type === "issue.reassigned").length, 0);
+    await app.close();
+});
+test("NOT-240: PATCH repository that races admission answers 409 and never mutates the frozen snapshot", async () => {
+    const app = await buildApp();
+    const created = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: {
+            title: "Raced repo edit",
+            repo: "acme/app",
+            baseBranch: "main",
+            developerAgentId: BUILTIN_AGENT_CURSOR_ID,
+            reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+            acceptanceCriteria: "It works",
+        },
+    })).json();
+    assert.equal((await app.inject({ method: "POST", url: `/api/issues/${created.id}/start` })).statusCode, 200);
+    const save = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${created.id}`,
+        payload: { repo: "acme/other", developerAgentId: BUILTIN_AGENT_CLAUDE_ID },
+    });
+    assert.equal(save.statusCode, 409);
+    assert.match(String(save.json().error), /developing|active workflow/);
+    const issue = getIssue(created.id);
+    assert.equal(issue.repo, "github.com/acme/app", "frozen repository untouched");
+    assert.equal(issue.developerAgentId, BUILTIN_AGENT_CURSOR_ID, "frozen assignment untouched");
+    assert.equal(listWorkflowEventsForIssue(created.id).filter((e) => e.type === "issue.reassigned").length, 0, "a conflicted edit leaves no audit event");
+    await app.close();
+});
+// ---------------------------------------------------------------------------
+// NOT-239: Close issue — retire a `ready` issue that should never run.
+// ---------------------------------------------------------------------------
+/** A startable `ready` issue through the same HTTP create the UI uses. */
+async function createClosableIssue(app, title, extra = {}) {
+    const res = await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: {
+            title,
+            repo: "acme/app",
+            baseBranch: "main",
+            developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+            reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+            acceptanceCriteria: "It works",
+            ...extra,
+        },
+    });
+    assert.equal(res.statusCode, 200, res.body);
+    return res.json().id;
+}
+function closeEvents(issueId) {
+    return listWorkflowEventsForIssue(issueId).filter((e) => e.type === "issue.closed");
+}
+test("NOT-239: close retires an unqueued ready issue with no execution records", async () => {
+    const app = await buildApp();
+    const id = await createClosableIssue(app, "Obsolete draft", { enqueue: false });
+    const before = getIssue(id);
+    const res = await app.inject({
+        method: "POST",
+        url: `/api/issues/${id}/close`,
+        payload: { closedBy: "yusuke" },
+    });
+    assert.equal(res.statusCode, 200, res.body);
+    assert.deepEqual(res.json(), { issueStatus: "closed", alreadyClosed: false });
+    const detail = (await app.inject({ method: "GET", url: `/api/issues/${id}` })).json();
+    assert.equal(detail.issue.status, "closed");
+    assert.equal(detail.issue.branch, before.branch, "close creates no branch");
+    assert.equal(detail.issue.prNumber, null, "close creates no PR");
+    assert.equal(detail.queued, false);
+    assert.equal(detail.queueEntry, null);
+    // Exactly one durable human-authored close event naming who closed and when.
+    const closed = detail.timeline.filter((e) => e.type === "issue.closed");
+    assert.equal(closed.length, 1);
+    assert.equal(closed[0].actorType, "human");
+    assert.equal(closed[0].actorRef, "yusuke");
+    assert.ok(closed[0].ts, "close event carries its timestamp");
+    const payload = JSON.parse(closed[0].payloadJson);
+    assert.equal(payload.reason, "closed_by_operator");
+    assert.equal(payload.closedBy, "yusuke");
+    assert.equal(typeof payload.closedAt, "string");
+    assert.equal(payload.wasQueued, false);
+    assert.equal(payload.resolvedActions, 0);
+    // No execution records of any kind.
+    assert.equal(listWorkflowInstancesForIssue(id).length, 0);
+    assert.equal(listWorkItemsForIssue(id).length, 0);
+    assert.equal(listWorkerSessionsForIssue(id).length, 0);
+    await app.close();
+});
+test("NOT-239: close on a queued ready issue atomically removes the entry and advances the next issue", async () => {
+    const app = await buildApp();
+    const first = await createClosableIssue(app, "First in line");
+    const second = await createClosableIssue(app, "Second in line");
+    assert.equal(queueStatusForIssue(first)?.position, 1);
+    assert.equal(queueStatusForIssue(second)?.position, 2);
+    const res = await app.inject({ method: "POST", url: `/api/issues/${first}/close` });
+    assert.equal(res.statusCode, 200, res.body);
+    assert.deepEqual(res.json(), { issueStatus: "closed", alreadyClosed: false });
+    assert.equal(getIssue(first).status, "closed");
+    assert.equal(getQueuedEntryForIssue(first), null, "queue entry removed with the close");
+    assert.equal(queueStatusForIssue(second)?.position, 1, "next issue advances normally");
+    const payload = JSON.parse(closeEvents(first)[0].payloadJson);
+    assert.equal(payload.wasQueued, true);
+    await app.close();
+});
+test("NOT-239: close is idempotent — a repeat on closed writes no new event", async () => {
+    const app = await buildApp();
+    const id = await createClosableIssue(app, "Twice closed", { enqueue: false });
+    assert.equal((await app.inject({ method: "POST", url: `/api/issues/${id}/close` })).statusCode, 200);
+    const second = await app.inject({ method: "POST", url: `/api/issues/${id}/close` });
+    assert.equal(second.statusCode, 200);
+    assert.deepEqual(second.json(), { issueStatus: "closed", alreadyClosed: true });
+    assert.equal(closeEvents(id).length, 1, "a repeated close must not append another event");
+    await app.close();
+});
+test("NOT-239: close 404s for an unknown issue", async () => {
+    const app = await buildApp();
+    const res = await app.inject({ method: "POST", url: "/api/issues/does-not-exist/close" });
+    assert.equal(res.statusCode, 404);
+    await app.close();
+});
+test("NOT-239: close refuses once execution started — exactly one terminal outcome, Abort stays the stop", async () => {
+    const app = await buildApp();
+    const id = await createClosableIssue(app, "Already running");
+    const started = await app.inject({ method: "POST", url: `/api/issues/${id}/start` });
+    assert.equal(started.statusCode, 200);
+    assert.equal(started.json().state, "admitted");
+    const res = await app.inject({ method: "POST", url: `/api/issues/${id}/close` });
+    assert.equal(res.statusCode, 409);
+    assert.match(res.json().error, /active workflow|Abort/);
+    // Execution won: still developing, one instance, and no close event.
+    assert.equal(getIssue(id).status, "developing");
+    assert.equal(listWorkflowInstancesForIssue(id).length, 1);
+    assert.equal(closeEvents(id).length, 0);
+    await app.close();
+});
+test("NOT-239: close needs no readiness — an underspecified ready issue still closes", async () => {
+    const app = await buildApp();
+    // No acceptance criteria: unstartable, still `ready`, queued with a wait reason.
+    const id = await createClosableIssue(app, "Misconfigured", { acceptanceCriteria: undefined });
+    const cleared = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${id}`,
+        payload: { acceptanceCriteria: null },
+    });
+    assert.equal(cleared.statusCode, 200, cleared.body);
+    assert.ok(getQueuedEntryForIssue(id), "still queued before close");
+    const res = await app.inject({ method: "POST", url: `/api/issues/${id}/close` });
+    assert.equal(res.statusCode, 200, res.body);
+    assert.equal(getIssue(id).status, "closed");
+    assert.equal(getQueuedEntryForIssue(id), null);
+    await app.close();
+});
+test("NOT-239: a closed issue can never be admitted afterwards", async () => {
+    const app = await buildApp();
+    const id = await createClosableIssue(app, "Never run");
+    assert.equal((await app.inject({ method: "POST", url: `/api/issues/${id}/close` })).statusCode, 200);
+    const start = await app.inject({ method: "POST", url: `/api/issues/${id}/start` });
+    assert.equal(start.statusCode, 409);
+    const execute = await app.inject({ method: "POST", url: `/api/issues/${id}/execute` });
+    assert.equal(execute.statusCode, 409);
+    // (The queue router is not mounted on this issues-only app — enqueue is
+    // asserted at the repository level, which is what the route calls.)
+    const { enqueueIssue } = await import("../repository/queue-entries.js");
+    assert.throws(() => enqueueIssue(id), (err) => {
+        assert.equal(err.code, 409);
+        assert.match(err instanceof Error ? err.message : String(err), /cannot enqueue/);
+        return true;
+    });
+    // A coordinator tick racing the close finds nothing to start.
+    assert.equal(await admitNext(), null);
+    assert.equal(listWorkflowInstancesForIssue(id).length, 0);
+    await app.close();
+});
+test("NOT-239: closed issues leave the default paginated list but stay findable by status filter and direct URL", async () => {
+    const app = await buildApp();
+    const closedId = await createClosableIssue(app, "Retired work");
+    const activeId = await createClosableIssue(app, "Live work");
+    assert.equal((await app.inject({ method: "POST", url: `/api/issues/${closedId}/close` })).statusCode, 200);
+    const def = (await app.inject({ method: "GET", url: "/api/issues?page=1" })).json();
+    assert.ok(def.issues.some((i) => i.id === activeId), "active issue stays in the default view");
+    assert.ok(!def.issues.some((i) => i.id === closedId), "closed issue leaves the default view");
+    const filtered = (await app.inject({ method: "GET", url: "/api/issues?status=closed&page=1" })).json();
+    assert.ok(filtered.issues.some((i) => i.id === closedId), "status filter still finds closed work");
+    const direct = await app.inject({ method: "GET", url: `/api/issues/${closedId}` });
+    assert.equal(direct.statusCode, 200);
+    assert.equal(direct.json().issue.status, "closed");
+    // Legacy unpaginated list (CLI contract) is untouched.
+    const legacy = (await app.inject({ method: "GET", url: "/api/issues" })).json();
+    assert.ok(legacy.some((i) => i.id === closedId));
+    await app.close();
+});

package/bundle/server/package.json

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