agent-dealer 0.2.0 → 1.0.0

package/bundle/server/dist/repository/intake-settings.js

@@ -1,4 +1,6 @@
 import { getDb } from "../db/index.js";
+/** Open workflow states — exclude terminal Done / Canceled. Shared with linear-inbox seed. */
+export const DEFAULT_LINEAR_STATE_FILTER = ["Backlog", "Todo", "In Progress", "In Review"];
 function getJson(key, fallback) {
     const row = getDb()
         .prepare("SELECT value_json FROM intake_settings WHERE key = ?")
@@ -12,11 +14,6 @@ function getJson(key, fallback) {
         return fallback;
     }
 }
-function setJson(key, value) {
-    getDb()
-        .prepare("INSERT INTO intake_settings (key, value_json) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json")
-        .run(key, JSON.stringify(value));
-}
 function parseStateFilterEnv(raw) {
     if (!raw?.trim())
         return null;
@@ -26,21 +23,13 @@ function parseStateFilterEnv(raw) {
         .filter(Boolean);
     return parts.length > 0 ? parts : null;
 }
-function linearEnvOverrides() {
-    return {
-        stateFilter: parseStateFilterEnv(process.env.LINEAR_STATE_FILTER) !== null,
-        teamId: process.env.LINEAR_TEAM_ID !== undefined && process.env.LINEAR_TEAM_ID !== "",
-    };
-}
-/** SQLite only — used when saving UI / PATCH. */
+/** Persisted-only view of the Linear intake config (env overrides applied separately). */
 export function getPersistedLinearIntakeConfig() {
     return {
-        stateFilter: getJson("linear.stateFilter", ["Todo"]),
+        stateFilter: getJson("linear.stateFilter", [...DEFAULT_LINEAR_STATE_FILTER]),
         teamId: getJson("linear.teamId", null),
-        assigneeMe: getJson("linear.assigneeMe", true),
-        defaultAgentId: getJson("linear.defaultAgentId", null),
+        assigneeMe: getJson("linear.assigneeMe", false),
         syncEnabled: getJson("linear.syncEnabled", true),
-        routingRules: getJson("linear.routingRules", []),
     };
 }
 function applyEnvOverrides(config) {
@@ -58,32 +47,6 @@ function applyEnvOverrides(config) {
 export function getLinearIntakeConfig() {
     return applyEnvOverrides(getPersistedLinearIntakeConfig());
 }
-export function getLinearIntakeConfigView() {
-    const persisted = getPersistedLinearIntakeConfig();
-    return {
-        ...applyEnvOverrides(persisted),
-        persisted,
-        envOverrides: linearEnvOverrides(),
-    };
-}
-export function patchLinearIntakeConfig(patch) {
-    const current = getPersistedLinearIntakeConfig();
-    const next = {
-        stateFilter: patch.stateFilter ?? current.stateFilter,
-        teamId: patch.teamId !== undefined ? patch.teamId : current.teamId,
-        assigneeMe: patch.assigneeMe ?? current.assigneeMe,
-        defaultAgentId: patch.defaultAgentId !== undefined ? patch.defaultAgentId : current.defaultAgentId,
-        syncEnabled: patch.syncEnabled ?? current.syncEnabled,
-        routingRules: patch.routingRules ?? current.routingRules,
-    };
-    setJson("linear.stateFilter", next.stateFilter);
-    setJson("linear.teamId", next.teamId);
-    setJson("linear.assigneeMe", next.assigneeMe);
-    setJson("linear.defaultAgentId", next.defaultAgentId);
-    setJson("linear.syncEnabled", next.syncEnabled);
-    setJson("linear.routingRules", next.routingRules);
-    return getLinearIntakeConfigView();
-}
 function parseEnvAgentDeckUrl() {
     const raw = process.env.AGENT_DECK_API_URL;
     if (!raw)
@@ -105,20 +68,3 @@ export function getAgentDeckConfig() {
         envOverride: Boolean(process.env.AGENT_DECK_API_URL),
     };
 }
-export function patchAgentDeckConfig(patch) {
-    if (process.env.AGENT_DECK_API_URL) {
-        throw new Error("AGENT_DECK_API_URL is set in env — remove it to configure port in the UI");
-    }
-    const current = getAgentDeckConfig();
-    const next = {
-        host: patch.host?.trim() || current.host,
-        port: patch.port ?? current.port,
-        envOverride: false,
-    };
-    if (next.port < 1 || next.port > 65535) {
-        throw new Error("Port must be between 1 and 65535");
-    }
-    setJson("agentDeck.host", next.host);
-    setJson("agentDeck.port", next.port);
-    return next;
-}

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

@@ -0,0 +1,305 @@
+import { canTransitionIssue, CreateIssueInput, looksLikeLocalRepoPath, parseGitHubRepoInput, TERMINAL_ISSUE_STATUSES, } from "@agent-dealer/shared";
+import { v4 as uuid } from "uuid";
+import { getDb } from "../db/index.js";
+function rowToIssue(row) {
+    return {
+        id: row.id,
+        source: row.source,
+        externalId: row.external_id,
+        externalLabel: row.external_label,
+        externalUrl: row.external_url,
+        title: row.title,
+        description: row.description,
+        acceptanceCriteria: row.acceptance_criteria,
+        repo: row.repo,
+        baseBranch: row.base_branch,
+        status: row.status,
+        currentOwner: row.current_owner,
+        currentIntent: row.current_intent,
+        developerAgentId: row.developer_agent_id,
+        reviewerAgentId: row.reviewer_agent_id,
+        maxReviewRounds: row.max_review_rounds,
+        currentRound: row.current_round,
+        maxInfraAttempts: row.max_infra_attempts,
+        infraAttempts: row.infra_attempts,
+        branch: row.branch,
+        baseSha: row.base_sha,
+        headSha: row.head_sha,
+        prNumber: row.pr_number,
+        prUrl: row.pr_url,
+        autoMerge: row.auto_merge !== 0,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Persistable `issues.repo` value (NOT-149):
+ * - GitHub URL / owner/repo → canonical `github.com/owner/repo`
+ * - Local filesystem path → kept as-is for in-flight recovery / tests (existence is
+ *   checked at checkout resolve time via classifyIssueRepo — never guess a remote)
+ */
+export function normalizeStoredIssueRepo(repoRaw) {
+    const trimmed = repoRaw.trim();
+    if (looksLikeLocalRepoPath(trimmed)) {
+        return trimmed;
+    }
+    return parseGitHubRepoInput(trimmed).identity;
+}
+export function createIssue(raw) {
+    const { repo: repoRaw, ...rest } = raw;
+    const input = CreateIssueInput.omit({ repo: true }).parse(rest);
+    const repo = normalizeStoredIssueRepo(repoRaw);
+    const db = getDb();
+    const now = new Date().toISOString();
+    const id = uuid();
+    const row = {
+        id,
+        source: input.source,
+        external_id: input.externalId ?? null,
+        external_label: input.externalLabel ?? null,
+        external_url: input.externalUrl ?? null,
+        title: input.title,
+        description: input.description ?? null,
+        acceptance_criteria: input.acceptanceCriteria ?? null,
+        repo,
+        base_branch: input.baseBranch,
+        status: "ready",
+        current_owner: "system",
+        current_intent: null,
+        developer_agent_id: input.developerAgentId,
+        reviewer_agent_id: input.reviewerAgentId,
+        max_review_rounds: input.maxReviewRounds,
+        current_round: 1,
+        max_infra_attempts: input.maxInfraAttempts,
+        infra_attempts: 0,
+        branch: null,
+        base_sha: null,
+        head_sha: null,
+        pr_number: null,
+        pr_url: null,
+        auto_merge: input.autoMerge ? 1 : 0,
+        created_at: now,
+        updated_at: now,
+    };
+    db.prepare(`
+    INSERT INTO issues (
+      id, source, external_id, external_label, external_url, title, description,
+      acceptance_criteria, repo, base_branch, status, current_owner, current_intent,
+      developer_agent_id, reviewer_agent_id, max_review_rounds, current_round,
+      max_infra_attempts, infra_attempts,
+      branch, base_sha, head_sha, pr_number, pr_url, auto_merge, created_at, updated_at
+    ) VALUES (
+      @id, @source, @external_id, @external_label, @external_url, @title, @description,
+      @acceptance_criteria, @repo, @base_branch, @status, @current_owner, @current_intent,
+      @developer_agent_id, @reviewer_agent_id, @max_review_rounds, @current_round,
+      @max_infra_attempts, @infra_attempts,
+      @branch, @base_sha, @head_sha, @pr_number, @pr_url, @auto_merge, @created_at, @updated_at
+    )
+  `).run(row);
+    return rowToIssue(row);
+}
+export function getIssue(id) {
+    const row = getDb().prepare("SELECT * FROM issues WHERE id = ?").get(id);
+    return row ? rowToIssue(row) : null;
+}
+export function listIssues(status) {
+    const db = getDb();
+    if (!status) {
+        const rows = db.prepare("SELECT * FROM issues ORDER BY updated_at DESC").all();
+        return rows.map(rowToIssue);
+    }
+    const statuses = Array.isArray(status) ? status : [status];
+    const placeholders = statuses.map(() => "?").join(",");
+    const rows = db
+        .prepare(`SELECT * FROM issues WHERE status IN (${placeholders}) ORDER BY updated_at DESC`)
+        .all(...statuses);
+    return rows.map(rowToIssue);
+}
+/**
+ * Every issue ever imported for this external id, newest first. `(source, external_id)` is
+ * deliberately non-unique (`idx_issues_external` is a plain index): one ticket may need a
+ * second pass after the first ended terminally (NOT-141).
+ */
+export function listIssuesByExternalId(source, externalId) {
+    const rows = getDb()
+        .prepare("SELECT * FROM issues WHERE source = ? AND external_id = ? ORDER BY created_at DESC, rowid DESC")
+        .all(source, externalId);
+    return rows.map(rowToIssue);
+}
+/**
+ * NOT-141: the import guard — the issues-model analog of runs' `findActiveByExternalId`.
+ * It exists to stop two live workflows racing on one ticket, not to make a ticket
+ * single-use: a `done`/`closed` row no longer matches, so a re-import after a terminal pass
+ * creates a new issue instead of silently returning the old one.
+ */
+export function findActiveIssueByExternalId(source, externalId) {
+    const placeholders = TERMINAL_ISSUE_STATUSES.map(() => "?").join(",");
+    const row = getDb()
+        .prepare(`SELECT * FROM issues
+       WHERE source = ? AND external_id = ? AND status NOT IN (${placeholders})
+       ORDER BY created_at DESC, rowid DESC
+       LIMIT 1`)
+        .get(source, externalId, ...TERMINAL_ISSUE_STATUSES);
+    return row ? rowToIssue(row) : null;
+}
+export function transitionIssue(id, to, patch) {
+    const current = getIssue(id);
+    if (!current)
+        throw new Error(`Issue not found: ${id}`);
+    if (!canTransitionIssue(current.status, to)) {
+        throw new Error(`Invalid transition: ${current.status} → ${to}`);
+    }
+    const now = new Date().toISOString();
+    getDb()
+        .prepare(`
+      UPDATE issues SET
+        status = @status,
+        current_owner = @current_owner,
+        current_intent = @current_intent,
+        branch = @branch,
+        base_sha = @base_sha,
+        head_sha = @head_sha,
+        pr_number = @pr_number,
+        pr_url = @pr_url,
+        updated_at = @updated_at
+      WHERE id = @id
+    `)
+        .run({
+        id,
+        status: to,
+        current_owner: patch?.currentOwner ?? current.currentOwner,
+        current_intent: patch?.currentIntent !== undefined ? patch.currentIntent : current.currentIntent,
+        branch: patch?.branch !== undefined ? patch.branch : current.branch,
+        base_sha: patch?.baseSha !== undefined ? patch.baseSha : current.baseSha,
+        head_sha: patch?.headSha !== undefined ? patch.headSha : current.headSha,
+        pr_number: patch?.prNumber !== undefined ? patch.prNumber : current.prNumber,
+        pr_url: patch?.prUrl !== undefined ? patch.prUrl : current.prUrl,
+        updated_at: now,
+    });
+    const updated = getIssue(id);
+    if (!updated)
+        throw new Error(`Issue vanished: ${id}`);
+    return updated;
+}
+/** Pre-start (or parked-on-`needs_human`) edits only — the route enforces no active
+ * workflow instance. Never touches status/owner/intent/branch/SHA/PR fields, which are
+ * coordinator-owned (see transitionIssue). */
+export function updateIssue(id, patch) {
+    const current = getIssue(id);
+    if (!current)
+        throw new Error(`Issue not found: ${id}`);
+    const now = new Date().toISOString();
+    getDb()
+        .prepare(`
+      UPDATE issues SET
+        title = @title,
+        description = @description,
+        acceptance_criteria = @acceptance_criteria,
+        repo = @repo,
+        base_branch = @base_branch,
+        developer_agent_id = @developer_agent_id,
+        reviewer_agent_id = @reviewer_agent_id,
+        max_review_rounds = @max_review_rounds,
+        max_infra_attempts = @max_infra_attempts,
+        auto_merge = @auto_merge,
+        updated_at = @updated_at
+      WHERE id = @id
+    `)
+        .run({
+        id,
+        title: patch.title ?? current.title,
+        description: patch.description !== undefined ? patch.description : current.description,
+        acceptance_criteria: patch.acceptanceCriteria !== undefined ? patch.acceptanceCriteria : current.acceptanceCriteria,
+        repo: patch.repo !== undefined ? normalizeStoredIssueRepo(patch.repo) : current.repo,
+        base_branch: patch.baseBranch ?? current.baseBranch,
+        developer_agent_id: patch.developerAgentId ?? current.developerAgentId,
+        reviewer_agent_id: patch.reviewerAgentId ?? current.reviewerAgentId,
+        max_review_rounds: patch.maxReviewRounds ?? current.maxReviewRounds,
+        max_infra_attempts: patch.maxInfraAttempts ?? current.maxInfraAttempts,
+        auto_merge: (patch.autoMerge !== undefined ? patch.autoMerge : current.autoMerge) ? 1 : 0,
+        updated_at: now,
+    });
+    const updated = getIssue(id);
+    if (!updated)
+        throw new Error(`Issue vanished: ${id}`);
+    return updated;
+}
+/** Distinct portable GitHub repo identities from prior issues, most recently used first.
+ * Legacy local filesystem rows are excluded from create/recent surfaces (NOT-149) —
+ * recovery for those issues remains at checkout time only. */
+export function listRecentRepos(limit = 20) {
+    const rows = getDb()
+        .prepare(`SELECT repo, MAX(updated_at) AS last_used
+       FROM issues
+       WHERE repo IS NOT NULL AND TRIM(repo) != ''
+       GROUP BY repo
+       ORDER BY last_used DESC
+       LIMIT ?`)
+        .all(Math.max(limit * 4, 40));
+    const out = [];
+    for (const r of rows) {
+        if (looksLikeLocalRepoPath(r.repo))
+            continue;
+        out.push(r.repo);
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+export function incrementIssueRound(id) {
+    const current = getIssue(id);
+    if (!current)
+        throw new Error(`Issue not found: ${id}`);
+    const now = new Date().toISOString();
+    getDb()
+        .prepare("UPDATE issues SET current_round = current_round + 1, updated_at = ? WHERE id = ?")
+        .run(now, id);
+    const updated = getIssue(id);
+    if (!updated)
+        throw new Error(`Issue vanished: ${id}`);
+    return updated;
+}
+/** Spends one infra attempt — a session/git/gh/Agent Deck/publish failure that is being
+ * retried automatically, never a reviewer's `changes_requested`. See incrementIssueRound. */
+export function incrementIssueInfraAttempts(id) {
+    const current = getIssue(id);
+    if (!current)
+        throw new Error(`Issue not found: ${id}`);
+    const now = new Date().toISOString();
+    getDb()
+        .prepare("UPDATE issues SET infra_attempts = infra_attempts + 1, updated_at = ? WHERE id = ?")
+        .run(now, id);
+    const updated = getIssue(id);
+    if (!updated)
+        throw new Error(`Issue vanished: ${id}`);
+    return updated;
+}
+/** A human resuming past a `policy_escalation` gets a fresh infra-attempt budget. */
+export function resetIssueInfraAttempts(id) {
+    const current = getIssue(id);
+    if (!current)
+        throw new Error(`Issue not found: ${id}`);
+    const now = new Date().toISOString();
+    getDb()
+        .prepare("UPDATE issues SET infra_attempts = 0, updated_at = ? WHERE id = ?")
+        .run(now, id);
+    const updated = getIssue(id);
+    if (!updated)
+        throw new Error(`Issue vanished: ${id}`);
+    return updated;
+}
+/** `attempts_exhausted:retry` grants one more review round instead of instantly
+ * re-exhausting: bumps current_round AND max_review_rounds together. */
+export function grantReviewRetry(id) {
+    const current = getIssue(id);
+    if (!current)
+        throw new Error(`Issue not found: ${id}`);
+    const now = new Date().toISOString();
+    getDb()
+        .prepare("UPDATE issues SET current_round = current_round + 1, max_review_rounds = max_review_rounds + 1, updated_at = ? WHERE id = ?")
+        .run(now, id);
+    const updated = getIssue(id);
+    if (!updated)
+        throw new Error(`Issue vanished: ${id}`);
+    return updated;
+}

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

@@ -0,0 +1,69 @@
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-issues-"));
+const { migrate } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+const { createIssue, getIssue, listIssues, transitionIssue, incrementIssueRound, findActiveIssueByExternalId, listIssuesByExternalId } = await import("./issues.js");
+before(() => {
+    migrate();
+});
+function makeInput(title) {
+    return {
+        title,
+        repo: "acme/app",
+        developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+        reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        baseBranch: "main",
+        maxReviewRounds: 3,
+        maxInfraAttempts: 3,
+        source: "manual"
+    };
+}
+test("creates an issue with defaults", () => {
+    const issue = createIssue(makeInput("Fix login bug"));
+    assert.equal(issue.status, "ready");
+    assert.equal(issue.currentOwner, "system");
+    assert.equal(issue.currentRound, 1);
+    assert.deepStrictEqual(getIssue(issue.id), issue);
+});
+test("lists issues filtered by status", () => {
+    const issue = createIssue(makeInput("Filterable issue"));
+    assert.ok(listIssues("ready").some((i) => i.id === issue.id));
+    assert.equal(listIssues("done").some((i) => i.id === issue.id), false);
+});
+test("transitions an issue and rejects an invalid transition", () => {
+    const issue = createIssue(makeInput("Transition me"));
+    const developing = transitionIssue(issue.id, "developing", { currentOwner: "developer" });
+    assert.equal(developing.status, "developing");
+    assert.equal(developing.currentOwner, "developer");
+    assert.throws(() => transitionIssue(issue.id, "final_review"), /Invalid transition/);
+});
+test("increments the round counter", () => {
+    const issue = createIssue(makeInput("Round me"));
+    const bumped = incrementIssueRound(issue.id);
+    assert.equal(bumped.currentRound, 2);
+});
+test("NOT-141: the active-by-external-id lookup ignores terminal rows; the list keeps every pass", () => {
+    const linear = { ...makeInput("Linear pass 1"), source: "linear", externalId: "NOT-999" };
+    const first = createIssue(linear);
+    assert.equal(findActiveIssueByExternalId("linear", "NOT-999")?.id, first.id);
+    transitionIssue(first.id, "closed");
+    assert.equal(findActiveIssueByExternalId("linear", "NOT-999"), null, "a closed pass is not in flight");
+    // The terminal pass is still on record — dependency verdicts read every pass.
+    assert.deepEqual(listIssuesByExternalId("linear", "NOT-999").map((i) => i.id), [first.id]);
+    // (source, external_id) is deliberately non-unique: a second pass is a second row.
+    const second = createIssue({ ...linear, title: "Linear pass 2" });
+    assert.notEqual(second.id, first.id);
+    assert.equal(findActiveIssueByExternalId("linear", "NOT-999")?.id, second.id);
+    // Newest first, so callers that want one answer get the current pass.
+    assert.deepEqual(listIssuesByExternalId("linear", "NOT-999").map((i) => i.id), [second.id, first.id]);
+});
+test("terminal-scoped lookup is per (source, externalId) pair", () => {
+    createIssue({ ...makeInput("Other source"), source: "agent", externalId: "SHARED-1" });
+    const linear = createIssue({ ...makeInput("Linear side"), source: "linear", externalId: "SHARED-1" });
+    assert.equal(findActiveIssueByExternalId("linear", "SHARED-1")?.id, linear.id);
+    assert.equal(findActiveIssueByExternalId("manual", "SHARED-1"), null);
+});

package/bundle/server/dist/repository/outbound-drafts.js

@@ -85,6 +85,34 @@ export function revertOutboundDraftToPending(artifactId) {
         .run(JSON.stringify(next), artifactId, row.content_json);
     return result.changes === 1;
 }
+/** Atomic increment of the draft's delivery-attempt counter — feeds the execution authority
+ * idempotency key (`${draftArtifactId}:${deliveryAttempts}`, NOT-95). Returns the new count,
+ * or null if the artifact/content is missing. Safe to call before the draft's status has
+ * settled (claim happens separately via `markOutboundDraftSent`); a CAS retry loop guards
+ * against a lost update if something else touches the row concurrently. */
+export function incrementOutboundDeliveryAttempt(artifactId) {
+    for (let attempt = 0; attempt < 5; attempt++) {
+        const db = getDb();
+        const row = db.prepare("SELECT content_json FROM artifacts WHERE id = ?").get(artifactId);
+        if (!row?.content_json)
+            return null;
+        let content;
+        try {
+            content = JSON.parse(row.content_json);
+        }
+        catch {
+            return null;
+        }
+        const nextCount = (content.deliveryAttempts ?? 0) + 1;
+        const next = { ...content, deliveryAttempts: nextCount };
+        const result = db
+            .prepare("UPDATE artifacts SET content_json = ? WHERE id = ? AND content_json = ?")
+            .run(JSON.stringify(next), artifactId, row.content_json);
+        if (result.changes === 1)
+            return nextCount;
+    }
+    return null;
+}
 /** Atomic pending → sent transition. Returns false if not pending. */
 export function markOutboundDraftSent(artifactId) {
     const db = getDb();

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

@@ -0,0 +1,162 @@
+// packages/server/src/repository/queue-entries.ts
+//
+// NOT-103: durable operator-owned issue admission queue (order + wait_reason).
+import { v4 as uuid } from "uuid";
+import { getDb } from "../db/index.js";
+import { getActiveWorkflowInstance } from "./workflow-events.js";
+import { getIssue } from "./issues.js";
+function rowToEntry(row) {
+    return {
+        id: row.id,
+        issueId: row.issue_id,
+        position: row.position,
+        enqueuedAt: row.enqueued_at,
+        state: row.state,
+        waitReason: row.wait_reason,
+        waitReasonAt: row.wait_reason_at,
+        ...(row.issue_title !== undefined
+            ? { title: row.issue_title ?? null, issueStatus: row.issue_status ?? null }
+            : {}),
+    };
+}
+export function getQueueEntry(id) {
+    const row = getDb().prepare("SELECT * FROM queue_entries WHERE id = ?").get(id);
+    return row ? rowToEntry(row) : null;
+}
+export function getQueuedEntryForIssue(issueId) {
+    const row = getDb()
+        .prepare("SELECT * FROM queue_entries WHERE issue_id = ? AND state = 'queued'")
+        .get(issueId);
+    return row ? rowToEntry(row) : null;
+}
+/** Ordered live queue (state=queued only), with issue title/status for display. */
+export function listQueuedEntries() {
+    const rows = getDb()
+        .prepare(`
+      SELECT q.*, i.title AS issue_title, i.status AS issue_status
+      FROM queue_entries q
+      LEFT JOIN issues i ON i.id = q.issue_id
+      WHERE q.state = 'queued'
+      ORDER BY q.position ASC, q.enqueued_at ASC
+    `)
+        .all();
+    return rows.map(rowToEntry);
+}
+/**
+ * Append at the end. Rejects terminal issues, active workflows, and duplicate queued rows.
+ * Partial unique index: ON CONFLICT must repeat the WHERE predicate.
+ */
+export function enqueueIssue(issueId) {
+    return enqueueIssueWithOutcome(issueId).entry;
+}
+/**
+ * The same append, reporting whether it actually wrote a row. Enqueue is idempotent, so the
+ * caller cannot infer a mutation from a returned entry — a re-import of an already-queued
+ * issue gets the same `QueueEntry` back with nothing changed. Callers that *report* to a
+ * human (NOT-141: `POST /api/issues`, and the CLI hint it feeds) must use this one, or they
+ * announce a queue action that did not happen.
+ */
+export function enqueueIssueWithOutcome(issueId) {
+    const issue = getIssue(issueId);
+    if (!issue)
+        throw Object.assign(new Error("Issue not found"), { code: 404 });
+    if (issue.status === "done" || issue.status === "closed") {
+        throw Object.assign(new Error(`Issue is ${issue.status} — cannot enqueue`), { code: 409 });
+    }
+    if (getActiveWorkflowInstance(issueId)) {
+        throw Object.assign(new Error("Issue already has an active workflow — cannot enqueue"), {
+            code: 409,
+        });
+    }
+    const existing = getQueuedEntryForIssue(issueId);
+    if (existing)
+        return { entry: existing, created: false };
+    const now = new Date().toISOString();
+    const maxPos = getDb()
+        .prepare("SELECT COALESCE(MAX(position), 0) AS m FROM queue_entries WHERE state = 'queued'")
+        .get();
+    const id = uuid();
+    const position = maxPos.m + 1;
+    // Partial unique index requires the WHERE predicate on ON CONFLICT (SQLite).
+    const info = getDb()
+        .prepare(`
+      INSERT INTO queue_entries (id, issue_id, position, enqueued_at, state, wait_reason, wait_reason_at)
+      VALUES (?, ?, ?, ?, 'queued', NULL, NULL)
+      ON CONFLICT(issue_id) WHERE state = 'queued' DO NOTHING
+    `)
+        .run(id, issueId, position, now);
+    if (info.changes === 0) {
+        const raced = getQueuedEntryForIssue(issueId);
+        if (raced)
+            return { entry: raced, created: false };
+        throw new Error("enqueue failed without creating a row");
+    }
+    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.
+ */
+export function moveQueueEntryToTop(issueId) {
+    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));
+        return getQueueEntry(entry.id);
+    })();
+}
+/** Operator dequeue — marks removed (keeps history row). Returns the removed entry or null. */
+export function dequeueIssue(issueId) {
+    const entry = getQueuedEntryForIssue(issueId);
+    if (!entry)
+        return null;
+    getDb()
+        .prepare("UPDATE queue_entries SET state = 'removed', wait_reason = NULL, wait_reason_at = NULL WHERE id = ?")
+        .run(entry.id);
+    return getQueueEntry(entry.id);
+}
+/** Force-admit / successful admit — no-op when not queued. */
+export function markQueueEntryAdmitted(issueId) {
+    const entry = getQueuedEntryForIssue(issueId);
+    if (!entry)
+        return null;
+    getDb()
+        .prepare(`
+      UPDATE queue_entries
+      SET state = 'admitted', wait_reason = NULL, wait_reason_at = NULL
+      WHERE issue_id = ? AND state = 'queued'
+    `)
+        .run(issueId);
+    return getQueueEntry(entry.id);
+}
+/** Issue closed / done while still queued. */
+export function markQueueEntryRemoved(issueId) {
+    getDb()
+        .prepare("UPDATE queue_entries SET state = 'removed' WHERE issue_id = ? AND state = 'queued'")
+        .run(issueId);
+}
+/**
+ * Persist wait_reason only when it changes (avoids write churn every coordinator tick).
+ * Returns true when a write occurred.
+ */
+export function setQueueWaitReason(entryId, reason) {
+    const row = getDb()
+        .prepare("SELECT wait_reason FROM queue_entries WHERE id = ? AND state = 'queued'")
+        .get(entryId);
+    if (!row)
+        return false;
+    if (row.wait_reason === reason)
+        return false;
+    const now = new Date().toISOString();
+    getDb()
+        .prepare("UPDATE queue_entries SET wait_reason = ?, wait_reason_at = ? WHERE id = ?")
+        .run(reason, reason !== null ? now : null, entryId);
+    return true;
+}