agent-dealer 1.0.1 → 1.0.2

package/bundle/server/dist/adapters/linear-graphql.js

@@ -0,0 +1,165 @@
+// packages/server/src/adapters/linear-graphql.ts
+//
+// Shared Linear GraphQL POST helper (NOT-152): log HTTP failures with rate-limit
+// headers, and surface a structured error so NOT-104 can back off until reset.
+export const LINEAR_API = "https://api.linear.app/graphql";
+const BODY_SNIPPET_MAX = 300;
+/** Bounded default when Linear returns 429 without a usable reset / Retry-After. */
+export const DEFAULT_RATE_LIMIT_BACKOFF_MS = 60_000;
+export class LinearHttpError extends Error {
+    status;
+    operation;
+    rateLimit;
+    bodySnippet;
+    /** ms until the rate-limit window reopens; null when not a rate-limit / unknown. */
+    retryAfterMs;
+    constructor(init) {
+        const remaining = init.rateLimit.requestsRemaining;
+        const reset = init.rateLimit.requestsReset;
+        const parts = [
+            `Linear HTTP ${init.status}`,
+            `operation=${init.operation}`,
+            remaining != null ? `requests-remaining=${remaining}` : null,
+            reset != null ? `requests-reset=${reset}` : null,
+        ].filter(Boolean);
+        super(parts.join(" "));
+        this.name = "LinearHttpError";
+        this.status = init.status;
+        this.operation = init.operation;
+        this.rateLimit = init.rateLimit;
+        this.bodySnippet = init.bodySnippet;
+        this.retryAfterMs = init.retryAfterMs;
+    }
+}
+export function parseLinearRateLimitHeaders(headers) {
+    const out = {};
+    const set = (key, name) => {
+        const v = headers.get(name);
+        if (v != null && v !== "")
+            out[key] = v;
+    };
+    set("requestsLimit", "x-ratelimit-requests-limit");
+    set("requestsRemaining", "x-ratelimit-requests-remaining");
+    set("requestsReset", "x-ratelimit-requests-reset");
+    set("complexityLimit", "x-ratelimit-complexity-limit");
+    set("complexityRemaining", "x-ratelimit-complexity-remaining");
+    set("complexityReset", "x-ratelimit-complexity-reset");
+    set("complexity", "x-complexity");
+    set("retryAfter", "retry-after");
+    return out;
+}
+/**
+ * How long to wait before retrying a rate-limited call.
+ * Linear's `X-RateLimit-Requests-Reset` is UTC epoch **milliseconds**.
+ * Prefer that reset header when present (NOT-152); Retry-After / default are fallbacks.
+ */
+export function computeRetryAfterMs(status, rateLimit, nowMs = Date.now()) {
+    if (status !== 429 && rateLimit.requestsRemaining !== "0")
+        return null;
+    if (rateLimit.requestsReset) {
+        const resetMs = Number(rateLimit.requestsReset);
+        if (Number.isFinite(resetMs) && resetMs > 0) {
+            // Accept seconds-epoch (10 digits) in case a proxy rewrites the header.
+            const absolute = resetMs < 1e12 ? resetMs * 1000 : resetMs;
+            return Math.max(0, absolute - nowMs);
+        }
+    }
+    if (rateLimit.retryAfter) {
+        const seconds = Number(rateLimit.retryAfter);
+        if (Number.isFinite(seconds) && seconds >= 0)
+            return Math.ceil(seconds * 1000);
+    }
+    if (status === 429)
+        return DEFAULT_RATE_LIMIT_BACKOFF_MS;
+    return null;
+}
+export function formatLinearFailureLog(err) {
+    const rl = err.rateLimit;
+    const bits = [
+        `[linear] ${err.operation} failed`,
+        `status=${err.status}`,
+        rl.requestsRemaining != null ? `requests-remaining=${rl.requestsRemaining}` : null,
+        rl.requestsReset != null ? `requests-reset=${rl.requestsReset}` : null,
+        rl.requestsLimit != null ? `requests-limit=${rl.requestsLimit}` : null,
+        rl.complexityRemaining != null ? `complexity-remaining=${rl.complexityRemaining}` : null,
+        rl.complexityReset != null ? `complexity-reset=${rl.complexityReset}` : null,
+        rl.complexity != null ? `complexity=${rl.complexity}` : null,
+        err.bodySnippet ? `body=${err.bodySnippet}` : null,
+    ].filter(Boolean);
+    return bits.join(" ");
+}
+function truncateBody(text) {
+    const oneLine = text.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= BODY_SNIPPET_MAX)
+        return oneLine;
+    return `${oneLine.slice(0, BODY_SNIPPET_MAX)}…`;
+}
+function isGraphqlRateLimited(errors) {
+    return errors.some((e) => {
+        if (!e || typeof e !== "object")
+            return false;
+        const ext = e.extensions;
+        return ext?.code === "RATELIMITED";
+    });
+}
+/**
+ * POST to Linear GraphQL. On non-OK HTTP (and GraphQL RATELIMITED), logs once and throws
+ * {@link LinearHttpError}. Callers keep their own catch for user-facing 502s.
+ */
+export async function linearGraphqlRequest(opts) {
+    const key = process.env.LINEAR_API_KEY;
+    if (!key)
+        throw new Error("LINEAR_API_KEY not set");
+    const res = await fetch(LINEAR_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: key },
+        body: JSON.stringify({ query: opts.query, variables: opts.variables }),
+        ...(opts.timeoutMs ? { signal: AbortSignal.timeout(opts.timeoutMs) } : {}),
+    });
+    const rateLimit = parseLinearRateLimitHeaders(res.headers instanceof Headers ? res.headers : new Headers());
+    const rawBody = typeof res.text === "function"
+        ? await res.text()
+        : JSON.stringify(await res.json());
+    const bodySnippet = truncateBody(rawBody);
+    if (!res.ok) {
+        const err = new LinearHttpError({
+            status: res.status,
+            operation: opts.operation,
+            rateLimit,
+            bodySnippet,
+            retryAfterMs: computeRetryAfterMs(res.status, rateLimit),
+        });
+        console.error(formatLinearFailureLog(err));
+        throw err;
+    }
+    let json;
+    try {
+        json = JSON.parse(rawBody);
+    }
+    catch {
+        const err = new LinearHttpError({
+            status: res.status,
+            operation: opts.operation,
+            rateLimit,
+            bodySnippet,
+            retryAfterMs: null,
+        });
+        console.error(formatLinearFailureLog(err));
+        throw new Error(`Linear GraphQL returned non-JSON for ${opts.operation}`);
+    }
+    if (json.errors?.length) {
+        if (isGraphqlRateLimited(json.errors) || rateLimit.requestsRemaining === "0") {
+            const err = new LinearHttpError({
+                status: 429,
+                operation: opts.operation,
+                rateLimit,
+                bodySnippet,
+                retryAfterMs: computeRetryAfterMs(429, rateLimit),
+            });
+            console.error(formatLinearFailureLog(err));
+            throw err;
+        }
+        throw new Error(JSON.stringify(json.errors));
+    }
+    return json.data;
+}

package/bundle/server/dist/adapters/linear-graphql.test.js

@@ -0,0 +1,129 @@
+// packages/server/src/adapters/linear-graphql.test.ts
+//
+// NOT-152: failed Linear GraphQL calls must log HTTP status + rate-limit headers,
+// and expose a structured error so NOT-104 can back off until the reset window.
+import { test, mock } from "node:test";
+import assert from "node:assert/strict";
+const { LinearHttpError, computeRetryAfterMs, linearGraphqlRequest, parseLinearRateLimitHeaders, } = await import("./linear-graphql.js");
+test("parseLinearRateLimitHeaders reads requests + complexity headers", () => {
+    const headers = new Headers({
+        "X-RateLimit-Requests-Limit": "2500",
+        "X-RateLimit-Requests-Remaining": "0",
+        "X-RateLimit-Requests-Reset": "1760000000000",
+        "X-RateLimit-Complexity-Limit": "1000000",
+        "X-RateLimit-Complexity-Remaining": "12",
+        "X-RateLimit-Complexity-Reset": "1760000000000",
+        "X-Complexity": "42",
+    });
+    assert.deepEqual(parseLinearRateLimitHeaders(headers), {
+        requestsLimit: "2500",
+        requestsRemaining: "0",
+        requestsReset: "1760000000000",
+        complexityLimit: "1000000",
+        complexityRemaining: "12",
+        complexityReset: "1760000000000",
+        complexity: "42",
+    });
+});
+test("computeRetryAfterMs uses Linear reset epoch-ms on 429", () => {
+    const now = 1_760_000_000_000;
+    const ms = computeRetryAfterMs(429, { requestsRemaining: "0", requestsReset: String(now + 45_000) }, now);
+    assert.equal(ms, 45_000);
+});
+test("computeRetryAfterMs prefers requests-reset over Retry-After when both are set", () => {
+    const now = 1_760_000_000_000;
+    const ms = computeRetryAfterMs(429, {
+        requestsRemaining: "0",
+        requestsReset: String(now + 45_000),
+        retryAfter: "5",
+    }, now);
+    assert.equal(ms, 45_000);
+});
+test("computeRetryAfterMs falls back to Retry-After seconds when reset missing", () => {
+    const ms = computeRetryAfterMs(429, { retryAfter: "30" }, 1_000);
+    assert.equal(ms, 30_000);
+});
+test("linearGraphqlRequest logs HTTP status and rate-limit headers on non-OK", async () => {
+    process.env.LINEAR_API_KEY = "lin_test";
+    const errors = [];
+    const errorMock = mock.method(console, "error", (...args) => {
+        errors.push(args);
+    });
+    const fetchMock = mock.method(globalThis, "fetch", async () => {
+        return new Response("rate limited", {
+            status: 429,
+            headers: {
+                "X-RateLimit-Requests-Remaining": "0",
+                "X-RateLimit-Requests-Reset": "1760000045000",
+                "X-RateLimit-Requests-Limit": "2500",
+            },
+        });
+    });
+    try {
+        await assert.rejects(() => linearGraphqlRequest({
+            operation: "listLinearCandidates",
+            query: "query { viewer { id } }",
+        }), (err) => {
+            assert.ok(err instanceof LinearHttpError);
+            assert.equal(err.status, 429);
+            assert.equal(err.operation, "listLinearCandidates");
+            assert.equal(err.rateLimit.requestsRemaining, "0");
+            assert.equal(err.rateLimit.requestsReset, "1760000045000");
+            assert.match(err.message, /429/);
+            return true;
+        });
+        const joined = errors.map((a) => a.map(String).join(" ")).join("\n");
+        assert.match(joined, /\[linear\]/);
+        assert.match(joined, /listLinearCandidates/);
+        assert.match(joined, /429/);
+        assert.match(joined, /requests-remaining[=:]?\s*0/i);
+        assert.match(joined, /requests-reset[=:]?\s*1760000045000/i);
+    }
+    finally {
+        errorMock.mock.restore();
+        fetchMock.mock.restore();
+    }
+});
+test("listLinearCandidates leaves a [linear] log line on HTTP 502 (intake path)", async () => {
+    // Mirrors GET /api/intake/linear: route returns String(e) to the client; dealer logs must
+    // still carry status + rate-limit headers from linearGraphqlRequest.
+    const fs = await import("node:fs");
+    const os = await import("node:os");
+    const path = await import("node:path");
+    process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not152-"));
+    process.env.LINEAR_API_KEY = "lin_test";
+    const { migrate } = await import("../db/index.js");
+    migrate();
+    const { listLinearCandidates } = await import("./linear-inbox.js");
+    const errors = [];
+    const errorMock = mock.method(console, "error", (...args) => {
+        errors.push(args);
+    });
+    const fetchMock = mock.method(globalThis, "fetch", async () => {
+        return new Response("bad gateway", {
+            status: 502,
+            headers: {
+                "X-RateLimit-Requests-Remaining": "12",
+                "X-RateLimit-Requests-Reset": "1760000099000",
+            },
+        });
+    });
+    try {
+        await assert.rejects(() => listLinearCandidates(), (err) => {
+            assert.ok(err instanceof LinearHttpError);
+            assert.equal(err.status, 502);
+            assert.equal(err.operation, "listLinearCandidates");
+            return true;
+        });
+        const joined = errors.map((a) => a.map(String).join(" ")).join("\n");
+        assert.match(joined, /\[linear\]/);
+        assert.match(joined, /listLinearCandidates/);
+        assert.match(joined, /status=502/);
+        assert.match(joined, /requests-remaining=12/);
+        assert.match(joined, /requests-reset=1760000099000/);
+    }
+    finally {
+        errorMock.mock.restore();
+        fetchMock.mock.restore();
+    }
+});

package/bundle/server/dist/adapters/linear-inbox.js

@@ -1,26 +1,17 @@
 import { DEFAULT_LINEAR_STATE_FILTER, getLinearIntakeConfig } from "../repository/intake-settings.js";
+import { linearGraphqlRequest } from "./linear-graphql.js";
 export { DEFAULT_LINEAR_STATE_FILTER };
-const LINEAR_API = "https://api.linear.app/graphql";
 const PAGE_SIZE = 50;
 function hasApiKey() {
     return Boolean(process.env.LINEAR_API_KEY);
 }
-async function linearQuery(query, variables, opts) {
-    const key = process.env.LINEAR_API_KEY;
-    if (!key)
-        throw new Error("LINEAR_API_KEY not set");
-    const res = await fetch(LINEAR_API, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: key },
-        body: JSON.stringify({ query, variables }),
-        ...(opts?.timeoutMs ? { signal: AbortSignal.timeout(opts.timeoutMs) } : {}),
+async function linearQuery(operation, query, variables, opts) {
+    return linearGraphqlRequest({
+        operation,
+        query,
+        variables,
+        timeoutMs: opts?.timeoutMs,
     });
-    if (!res.ok)
-        throw new Error(`Linear HTTP ${res.status}: ${await res.text()}`);
-    const json = (await res.json());
-    if (json.errors?.length)
-        throw new Error(JSON.stringify(json.errors));
-    return json.data;
 }
 function nodeToCandidate(n) {
     return {
@@ -47,7 +38,7 @@ const ISSUE_FIELDS = `
 export async function getLinearViewer() {
     if (!hasApiKey())
         return null;
-    const data = (await linearQuery(`query { viewer { id name email } }`));
+    const data = (await linearQuery("getLinearViewer", `query { viewer { id name email } }`));
     return data.viewer;
 }
 export function buildIssueFilter(settings, viewerId) {
@@ -95,7 +86,7 @@ export async function listLinearCandidates() {
     const nodes = [];
     let after;
     for (;;) {
-        const data = (await linearQuery(`query PollIssues($filter: IssueFilter, $after: String) {
+        const data = (await linearQuery("listLinearCandidates", `query PollIssues($filter: IssueFilter, $after: String) {
         issues(filter: $filter, first: ${PAGE_SIZE}, after: $after) {
           nodes { ${ISSUE_FIELDS} }
           pageInfo { hasNextPage endCursor }
@@ -109,7 +100,7 @@ export async function listLinearCandidates() {
     return nodes.map(nodeToCandidate);
 }
 export async function getLinearIssue(issueId) {
-    const data = (await linearQuery(`query Issue($id: String!) {
+    const data = (await linearQuery("getLinearIssue", `query Issue($id: String!) {
       issue(id: $id) { ${ISSUE_FIELDS} }
     }`, { id: issueId }));
     if (!data.issue)
@@ -172,7 +163,7 @@ export async function fetchLinearBlockers(issueIds, opts = {}) {
     let paging = [];
     let after;
     for (;;) {
-        const data = (await linearQuery(`query BlockingRelations($ids: [ID!], $after: String) {
+        const data = (await linearQuery("fetchLinearBlockers", `query BlockingRelations($ids: [ID!], $after: String) {
         issues(filter: { id: { in: $ids } }, first: ${PAGE_SIZE}, after: $after, includeArchived: true) {
           nodes {
             id
@@ -263,7 +254,7 @@ async function fetchInverseRelationRound(pending, remaining) {
         variables[`ids${i}`] = [entry.id];
         variables[`after${i}`] = entry.after;
     });
-    const data = (await linearQuery(`query BlockingRelationsPage(${varDefs.join(", ")}) {\n${selections.join("\n")}\n}`, variables, { timeoutMs: remaining() }));
+    const data = (await linearQuery("fetchLinearBlockersPage", `query BlockingRelationsPage(${varDefs.join(", ")}) {\n${selections.join("\n")}\n}`, variables, { timeoutMs: remaining() }));
     const out = new Map();
     pending.forEach((entry, i) => {
         const page = data[`r${i}`]?.nodes?.find((n) => n.id === entry.id)?.inverseRelations;

package/bundle/server/dist/adapters/linear-sync.js

@@ -1,7 +1,7 @@
 import { addArtifact } from "../repository/runs.js";
 import { getLinearIntakeConfig } from "../repository/intake-settings.js";
 import { getLinearIssue } from "./linear-inbox.js";
-const LINEAR_API = "https://api.linear.app/graphql";
+import { linearGraphqlRequest } from "./linear-graphql.js";
 const STATE_BY_EVENT = {
     // TODO(P2): configurable per team — see docs/LINEAR_INTEGRATION.md
     done: "Done",
@@ -10,27 +10,14 @@ const workflowStateCache = new Map();
 function webBaseUrl() {
     return process.env.AGENT_DEALER_WEB_URL ?? "http://localhost:2222";
 }
-async function linearMutate(query, variables) {
-    const key = process.env.LINEAR_API_KEY;
-    if (!key)
-        throw new Error("LINEAR_API_KEY not set");
-    const res = await fetch(LINEAR_API, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: key },
-        body: JSON.stringify({ query, variables }),
-    });
-    if (!res.ok)
-        throw new Error(`Linear HTTP ${res.status}: ${await res.text()}`);
-    const json = (await res.json());
-    if (json.errors?.length)
-        throw new Error(JSON.stringify(json.errors));
-    return json.data;
+async function linearMutate(operation, query, variables) {
+    return linearGraphqlRequest({ operation, query, variables });
 }
 async function getWorkflowStates(teamId) {
     const cached = workflowStateCache.get(teamId);
     if (cached)
         return cached;
-    const data = (await linearMutate(`query TeamStates($teamId: String!) {
+    const data = (await linearMutate("getWorkflowStates", `query TeamStates($teamId: String!) {
       team(id: $teamId) {
         states { nodes { id name } }
       }
@@ -43,12 +30,12 @@ async function getWorkflowStates(teamId) {
     return map;
 }
 async function commentCreate(issueId, body) {
-    await linearMutate(`mutation Comment($issueId: String!, $body: String!) {
+    await linearMutate("commentCreate", `mutation Comment($issueId: String!, $body: String!) {
       commentCreate(input: { issueId: $issueId, body: $body }) { success }
     }`, { issueId, body });
 }
 async function issueUpdateState(issueId, stateId) {
-    await linearMutate(`mutation UpdateIssue($issueId: String!, $stateId: String!) {
+    await linearMutate("issueUpdateState", `mutation UpdateIssue($issueId: String!, $stateId: String!) {
       issueUpdate(id: $issueId, input: { stateId: $stateId }) { success }
     }`, { issueId, stateId });
 }

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

@@ -16,6 +16,7 @@
 // A persisted table can replace the provider later without touching the rule.
 import { isTerminalIssueStatus } from "@agent-dealer/shared";
 import { fetchLinearBlockers } from "../adapters/linear-inbox.js";
+import { LinearHttpError } from "../adapters/linear-graphql.js";
 import { listIssuesByExternalId } from "../repository/issues.js";
 const EMPTY_SNAPSHOT = new Map();
 const DEFAULT_CACHE_TTL_MS = 60_000;
@@ -124,7 +125,10 @@ export async function blockersFor(issues) {
         fetched = await pending;
     }
     catch (err) {
-        backoffUntil = Date.now() + failureBackoffMs;
+        // NOT-152: a 429 / exhausted budget must wait for Linear's reset window, not only the
+        // short FAILURE_BACKOFF_MS — otherwise admission re-hammers once that window lapses.
+        const rateLimitMs = err instanceof LinearHttpError && err.retryAfterMs != null ? err.retryAfterMs : 0;
+        backoffUntil = Date.now() + Math.max(failureBackoffMs, rateLimitMs);
         throw err;
     }
     finally {

package/bundle/server/dist/coordinator/dependency-readiness.integration.test.js

@@ -322,6 +322,35 @@ test("a failing Linear is asked once per backoff window, not once per tick", asy
     setLinearBlockerFetcherForTests(async (ids) => new Map(ids.map((id) => [id, []])));
     assert.equal((await admitNext())?.issueId, issue.id);
 });
+test("HTTP 429 backs off until Linear's reset header, not only the short failure window", async () => {
+    // NOT-152: a rate-limit must outlive FAILURE_BACKOFF_MS when X-RateLimit-Requests-Reset says so.
+    const { LinearHttpError } = await import("../adapters/linear-graphql.js");
+    const issue = seedIssue({ source: "linear", externalId: "lin-a" });
+    let fetches = 0;
+    setBlockerFailureBackoffForTests(50);
+    setLinearBlockerFetcherForTests(async () => {
+        fetches++;
+        throw new LinearHttpError({
+            status: 429,
+            operation: "fetchLinearBlockers",
+            rateLimit: {
+                requestsRemaining: "0",
+                requestsReset: String(Date.now() + 60_000),
+            },
+            bodySnippet: "rate limited",
+            retryAfterMs: 60_000,
+        });
+    });
+    await assert.rejects(() => blockersFor([issue]), (err) => {
+        assert.ok(err instanceof LinearHttpError);
+        assert.equal(err.status, 429);
+        return true;
+    });
+    assert.equal(fetches, 1);
+    await new Promise((r) => setTimeout(r, 80));
+    await assert.rejects(() => blockersFor([issue]), /backing off/);
+    assert.equal(fetches, 1, "must not re-hit Linear while the rate-limit window is open");
+});
 test("overlapping ticks share one fetch: the second parks instead of opening a second call", async () => {
     const issue = seedIssue({ source: "linear", externalId: "lin-a" });
     let release = () => { };
@@ -371,7 +400,10 @@ function stubLinearIssues(batch, rounds = []) {
         else {
             data = { issues: { nodes: batch, pageInfo: { hasNextPage: false, endCursor: null } } };
         }
-        return { ok: true, json: async () => ({ data }) };
+        return new Response(JSON.stringify({ data }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        });
     });
     return {
         requests,

package/bundle/server/dist/db/index.js

@@ -459,6 +459,12 @@ function seedIntakeSettings(db) {
     }
 }
 function seedBuiltinAgents(db) {
+    // Only seed an empty agents table (fresh install). If the operator deleted the
+    // default Claude/Cursor/Codex rows after creating their own profiles, do not
+    // resurrect them on every migrate — INSERT OR IGNORE would bring the fixed IDs back.
+    const existing = db.prepare("SELECT COUNT(*) AS c FROM agents").get();
+    if (existing.c > 0)
+        return;
     const now = new Date().toISOString();
     const insert = db.prepare(`
     INSERT OR IGNORE INTO agents (id, name, runtime, deck_id, deck_name, playbook_id, is_builtin, created_at, updated_at)

package/bundle/server/dist/direct-start-interrupt-probe.js

@@ -0,0 +1,58 @@
+// packages/server/src/direct-start-interrupt-probe.ts
+//
+// Spawned by direct-start-liveness.integration.test.ts to prove the SIGINT path
+// reaps both the detached server group and the tracked temp home (NOT-140).
+// Args: <home> <readyFile> <serverEntry> <port>
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { DirectStartLiveCleanup } from "./direct-start-temp-home-cleanup.js";
+import { resolveTsxBin } from "./resolve-tsx-bin.js";
+const [home, readyFile, serverEntry, portStr] = process.argv.slice(2);
+if (!home || !readyFile || !serverEntry || !portStr) {
+    console.error("usage: direct-start-interrupt-probe <home> <readyFile> <serverEntry> <port>");
+    process.exit(2);
+}
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..", "..", "..");
+const tsxBin = resolveTsxBin(repoRoot);
+const liveCleanup = new DirectStartLiveCleanup();
+function signalGroup(child, signal) {
+    if (child.pid === undefined)
+        return;
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch {
+        // ESRCH — already gone
+    }
+}
+function reapAllLiveCleanup() {
+    liveCleanup.reapAll(signalGroup);
+}
+liveCleanup.trackHome(home);
+const child = spawn(tsxBin, [serverEntry], {
+    cwd: repoRoot,
+    env: {
+        ...process.env,
+        AGENT_DEALER_HOME: home,
+        AGENT_DEALER_ENV: "development",
+        PORT: portStr,
+    },
+    stdio: "ignore",
+    detached: true,
+});
+child.unref();
+liveCleanup.addServer(child);
+process.on("exit", reapAllLiveCleanup);
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(signal, () => {
+        reapAllLiveCleanup();
+        process.exit(1);
+    });
+}
+// Stay alive until the parent interrupts us. The ready file tells the parent the
+// home path and that the signal handlers are registered.
+fs.writeFileSync(readyFile, JSON.stringify({ home, pid: process.pid, serverLauncherPid: child.pid }));
+setInterval(() => { }, 60_000);