agent-dealer 1.2.1 → 1.2.2

package/bundle/server/dist/repository/repository-mappings.js

@@ -0,0 +1,46 @@
+import { normalizeRepositoryMappings } from "@agent-dealer/shared";
+import { getDb } from "../db/index.js";
+/** Storage key inside the existing `intake_settings` table — no migration needed. */
+export const REPOSITORY_MAPPINGS_KEY = "linear.repositoryMappings";
+function readRaw() {
+    const row = getDb()
+        .prepare("SELECT value_json FROM intake_settings WHERE key = ?")
+        .get(REPOSITORY_MAPPINGS_KEY);
+    if (!row)
+        return [];
+    try {
+        return JSON.parse(row.value_json);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * NOT-260: list saved label → repository mappings. A fresh install returns
+ * `[]`; a corrupt row reads as `[]` rather than throwing.
+ */
+export function listRepositoryMappings() {
+    const raw = readRaw();
+    const rows = Array.isArray(raw) ? raw : raw?.mappings;
+    if (!Array.isArray(rows))
+        return [];
+    try {
+        return normalizeRepositoryMappings({ mappings: rows });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * NOT-260: atomically replace all mappings. Normalizes labels/repositories
+ * before writing; editing the repository for an existing unique label
+ * overwrites its prior value. Empty labels, invalid repositories, duplicate
+ * normalized labels, or >100 rows throw without changing the last valid array.
+ */
+export function replaceRepositoryMappings(input) {
+    const normalized = normalizeRepositoryMappings(input);
+    getDb()
+        .prepare("INSERT INTO intake_settings (key, value_json) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json")
+        .run(REPOSITORY_MAPPINGS_KEY, JSON.stringify(normalized));
+    return normalized;
+}

package/bundle/server/dist/repository/repository-mappings.test.js

@@ -0,0 +1,83 @@
+// NOT-260: label → repository mapping persistence — JSON under
+// `linear.repositoryMappings` in intake_settings, atomic replace, overwrite,
+// duplicate rejection without touching the last valid array.
+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-repo-mappings-"));
+const { migrate } = await import("../db/index.js");
+const { listRepositoryMappings, replaceRepositoryMappings, } = await import("./repository-mappings.js");
+before(() => {
+    migrate();
+});
+test("a fresh install returns an empty mapping array", () => {
+    assert.deepEqual(listRepositoryMappings(), []);
+});
+test("saving normalizes label and repository", () => {
+    const saved = replaceRepositoryMappings({
+        mappings: [{ label: "  agent-dealer ", repository: "not-so-fat/agent-dealer" }],
+    });
+    assert.deepEqual(saved, [
+        { label: "agent-dealer", repository: "github.com/not-so-fat/agent-dealer" },
+    ]);
+    assert.deepEqual(listRepositoryMappings(), saved);
+});
+test("editing the repository for an existing unique label overwrites it", () => {
+    replaceRepositoryMappings({
+        mappings: [{ label: "agent-dealer", repository: "not-so-fat/agent-dealer" }],
+    });
+    const saved = replaceRepositoryMappings({
+        mappings: [{ label: "agent-dealer", repository: "not-so-fat/other" }],
+    });
+    assert.deepEqual(saved, [
+        { label: "agent-dealer", repository: "github.com/not-so-fat/other" },
+    ]);
+    const listed = listRepositoryMappings();
+    assert.equal(listed.length, 1);
+    assert.deepEqual(listed[0], {
+        label: "agent-dealer",
+        repository: "github.com/not-so-fat/other",
+    });
+});
+test("duplicate normalized labels fail without changing the last valid array", () => {
+    replaceRepositoryMappings({
+        mappings: [{ label: "agent-dealer", repository: "not-so-fat/other" }],
+    });
+    assert.throws(() => replaceRepositoryMappings({
+        mappings: [
+            { label: "agent-dealer", repository: "not-so-fat/agent-dealer" },
+            { label: "  AGENT-dealer ", repository: "not-so-fat/other" },
+        ],
+    }), /Duplicate repository mapping/);
+    assert.deepEqual(listRepositoryMappings(), [
+        { label: "agent-dealer", repository: "github.com/not-so-fat/other" },
+    ]);
+});
+test("empty labels, invalid repositories, and 101 rows fail atomically", () => {
+    replaceRepositoryMappings({
+        mappings: [{ label: "agent-dealer", repository: "not-so-fat/other" }],
+    });
+    const beforeRows = listRepositoryMappings();
+    assert.throws(() => replaceRepositoryMappings({ mappings: [{ label: "   ", repository: "a/b" }] }), /must not be empty/);
+    assert.deepEqual(listRepositoryMappings(), beforeRows);
+    assert.throws(() => replaceRepositoryMappings({ mappings: [{ label: "ok", repository: "not a repo!!" }] }), /Invalid repository/);
+    assert.deepEqual(listRepositoryMappings(), beforeRows);
+    const many = Array.from({ length: 101 }, (_, i) => ({ label: `l${i}`, repository: "a/b" }));
+    assert.throws(() => replaceRepositoryMappings({ mappings: many }), /At most 100/);
+    assert.deepEqual(listRepositoryMappings(), beforeRows);
+});
+test("replacement is whole-array: omitted labels disappear, shared targets stay", () => {
+    replaceRepositoryMappings({
+        mappings: [
+            { label: "agent-dealer", repository: "not-so-fat/agent-dealer" },
+            { label: "dealer", repository: "not-so-fat/agent-dealer" },
+        ],
+    });
+    const saved = replaceRepositoryMappings({
+        mappings: [{ label: "dealer", repository: "not-so-fat/agent-dealer" }],
+    });
+    assert.deepEqual(saved, [{ label: "dealer", repository: "github.com/not-so-fat/agent-dealer" }]);
+    assert.deepEqual(listRepositoryMappings(), saved);
+});

package/bundle/server/dist/repository/runtime-capacity.js

@@ -25,6 +25,7 @@ function rowToSnapshot(row) {
         expiresAt: row.expires_at,
         source: row.source,
         unavailableReason: row.unavailable_reason,
+        criticalRole: row.critical_role,
     };
 }
 /**
@@ -37,12 +38,14 @@ export function recordCapacitySnapshots(runtime, windows) {
     INSERT INTO runtime_capacity_snapshots (
       runtime, window_key, provider_bucket, duration_minutes, display_label,
       used_value, used_unit, remaining_percent, reset_at, observed_at,
-      fresh_until, expires_at, source, unavailable_reason, evidence_ref
+      fresh_until, expires_at, source, unavailable_reason, evidence_ref,
+      critical_role
     )
     VALUES (
       @runtime, @window_key, @provider_bucket, @duration_minutes, @display_label,
       @used_value, @used_unit, @remaining_percent, @reset_at, @observed_at,
-      @fresh_until, @expires_at, @source, @unavailable_reason, @evidence_ref
+      @fresh_until, @expires_at, @source, @unavailable_reason, @evidence_ref,
+      @critical_role
     )
     ON CONFLICT(runtime, window_key) DO UPDATE SET
       provider_bucket = excluded.provider_bucket,
@@ -57,7 +60,8 @@ export function recordCapacitySnapshots(runtime, windows) {
       expires_at = excluded.expires_at,
       source = excluded.source,
       unavailable_reason = excluded.unavailable_reason,
-      evidence_ref = excluded.evidence_ref
+      evidence_ref = excluded.evidence_ref,
+      critical_role = excluded.critical_role
   `);
     const run = getDb().transaction((rows) => {
         for (const w of rows) {
@@ -77,6 +81,7 @@ export function recordCapacitySnapshots(runtime, windows) {
                 source: w.source,
                 unavailable_reason: w.unavailableReason ?? null,
                 evidence_ref: w.evidenceRef ?? null,
+                critical_role: w.criticalRole ?? null,
             });
         }
     });

package/bundle/server/dist/repository/runtime-capacity.test.js

@@ -43,6 +43,7 @@ test("upserts per (runtime, window) and keeps sibling windows on partial writes"
             resetAt: new Date(Date.now() + 1800_000).toISOString(),
             observedAt: nowIso(),
             source: "supported_protocol",
+            criticalRole: "five_hour",
         },
     ]);
     // Partial re-observation updates one window and leaves the sibling alone.
@@ -63,6 +64,9 @@ test("upserts per (runtime, window) and keeps sibling windows on partial writes"
     assert.equal(windows.length, 2);
     assert.equal(windows.find((w) => w.windowKey === "weekly")?.remainingPercent, 60);
     assert.equal(windows.find((w) => w.windowKey === "five_hour")?.remainingPercent, 50);
+    // criticalRole round-trips through the DB; a window that never set it reads null.
+    assert.equal(windows.find((w) => w.windowKey === "five_hour")?.criticalRole, "five_hour");
+    assert.equal(windows.find((w) => w.windowKey === "weekly")?.criticalRole, null);
     assert.deepEqual(capacityRuntimes(), ["claude_code"]);
     assert.equal(listAllCapacitySnapshots().length, 2);
 });

package/bundle/server/dist/routes/cursor-individual-billing.test.js

@@ -0,0 +1,80 @@
+// packages/server/src/routes/cursor-individual-billing.test.ts
+//
+// NOT-250: GET /api/cursor-individual-billing serves the experimental opt-in
+// surface — disabled reads `enabled: false` N/A with no credential or
+// dashboard access, and responses validate against the shared contract with
+// no secret material.
+import { test, beforeEach, afterEach } 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-cap-indiv-route-"));
+process.env.AGENT_DEALER_SKIP_GITHUB_HEALTH = "1";
+process.env.AGENT_DEALER_SKIP_AGENT_HEALTH = "1";
+// Never poll providers from route tests: on-demand refreshes are covered
+// against mocks in the adapter tests.
+process.env.AGENT_DEALER_CODEX_CAPACITY_REFRESH = "off";
+process.env.AGENT_DEALER_CURSOR_TEAM_CAPACITY_REFRESH = "off";
+process.env.AGENT_DEALER_CURSOR_INDIVIDUAL_REFRESH = "off";
+const { migrate } = await import("../db/index.js");
+const { registerRoutes } = await import("./index.js");
+const { CursorIndividualBilling } = await import("@agent-dealer/shared");
+const { CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV } = await import("../capacity/cursor-individual-credentials.js");
+migrate();
+let savedOptIn;
+let savedCredFile;
+beforeEach(() => {
+    savedOptIn = process.env.AGENT_DEALER_CURSOR_INDIVIDUAL_CAPACITY;
+    savedCredFile = process.env[CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV];
+    delete process.env.AGENT_DEALER_CURSOR_INDIVIDUAL_CAPACITY;
+    delete process.env[CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV];
+});
+afterEach(() => {
+    if (savedOptIn === undefined)
+        delete process.env.AGENT_DEALER_CURSOR_INDIVIDUAL_CAPACITY;
+    else
+        process.env.AGENT_DEALER_CURSOR_INDIVIDUAL_CAPACITY = savedOptIn;
+    if (savedCredFile === undefined)
+        delete process.env[CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV];
+    else
+        process.env[CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV] = savedCredFile;
+});
+async function buildApp() {
+    const app = Fastify();
+    await registerRoutes(app);
+    return app;
+}
+test("disabled reads enabled:false N/A without credential or endpoint access", async () => {
+    // A credential file exists — the disabled route must still never read it
+    // (and there is no mock HTTP anyway: any attempt would throw or hang).
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-indiv-route-creds-"));
+    try {
+        const file = path.join(dir, "auth.json");
+        fs.writeFileSync(file, JSON.stringify({ token: "route-secret-must-not-leak" }));
+        process.env[CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV] = file;
+        const app = await buildApp();
+        const res = await app.inject({ method: "GET", url: "/api/cursor-individual-billing" });
+        assert.equal(res.statusCode, 200);
+        const body = CursorIndividualBilling.parse(res.json());
+        assert.equal(body.enabled, false);
+        assert.equal(body.configured, false);
+        assert.equal(body.source, "unavailable");
+        assert.equal(body.unavailableReason, "missing");
+        assert.equal(body.remainingPercent, null);
+        assert.ok(!JSON.stringify(res.json()).includes("route-secret-must-not-leak"), "no credential material reaches the browser");
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("opt-in without stored data reads enabled N/A (missing)", async () => {
+    process.env.AGENT_DEALER_CURSOR_INDIVIDUAL_CAPACITY = "experimental";
+    const app = await buildApp();
+    const res = await app.inject({ method: "GET", url: "/api/cursor-individual-billing" });
+    assert.equal(res.statusCode, 200);
+    const body = CursorIndividualBilling.parse(res.json());
+    assert.equal(body.enabled, true);
+    assert.equal(body.unavailableReason, "missing");
+});

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

@@ -10,6 +10,7 @@ import { configuredCapacityRuntimes, getRuntimeCapacitySnapshot } from "../capac
 import { maybeRefreshMuseCapacityFromServe } from "../capacity/muse.js";
 import { refreshCodexCapacityIfStale } from "../capacity/codex-app-server.js";
 import { getCursorTeamBillingSnapshot, refreshCursorTeamBillingIfStale, } from "../capacity/cursor-team.js";
+import { getCursorIndividualBillingSnapshot, refreshCursorIndividualBillingIfStale, refreshCursorIndividualCapacityIfStale, } from "../capacity/cursor-individual.js";
 async function resolveDeckName(deckId) {
     if (!deckId)
         return null;
@@ -90,6 +91,15 @@ export async function registerRoutes(app) {
             // A refresh failure must never break the read — stored snapshots still
             // served below with their explicit N/A reasons.
         }
+        try {
+            // NOT-250: opted-in experimental Individual billing-cycle window for
+            // `cursor_local`. Disabled is a strict no-op (no credential, no HTTP);
+            // failures never break the read below.
+            await refreshCursorIndividualCapacityIfStale();
+        }
+        catch {
+            // Stored snapshots still serve below with their explicit N/A reasons.
+        }
         return getRuntimeCapacitySnapshot();
     });
     // NOT-249: team-level Cursor billing from the official Admin API — separate
@@ -110,6 +120,28 @@ export async function registerRoutes(app) {
         }
         return getCursorTeamBillingSnapshot();
     });
+    // NOT-250: monthly/billing-cycle capacity for Cursor Individual accounts
+    // via the opt-in EXPERIMENTAL dashboard adapter (undocumented endpoints,
+    // local-login credential — no supported contract, no support guarantee).
+    // Disabled by default: without `AGENT_DEALER_CURSOR_INDIVIDUAL_CAPACITY=
+    // experimental` this reads `enabled: false` with no credential or endpoint
+    // access. Normalized snapshots only; the credential never leaves the
+    // server. On-demand stale refresh mirrors the Team path: a missing/stale
+    // stored snapshot triggers one bounded dashboard poll (single-flight,
+    // never health rows, never throws); fresh snapshots serve stored data with
+    // no HTTP, and `AGENT_DEALER_CURSOR_INDIVIDUAL_REFRESH=off` disables it.
+    // The browser must surface the `experimental_api` source with the local
+    // setting that disables it (see CursorIndividualBillingCard).
+    app.get("/api/cursor-individual-billing", async () => {
+        try {
+            await refreshCursorIndividualBillingIfStale();
+        }
+        catch {
+            // A refresh failure must never break the read — the stored snapshot
+            // still serves below with its explicit N/A reason.
+        }
+        return getCursorIndividualBillingSnapshot();
+    });
     app.get("/api/agents", async () => {
         const agents = await listAgentsWithHealth(listAgents());
         return {

package/bundle/server/dist/routes/intake-linear.test.js

@@ -33,7 +33,13 @@ before(() => {
     globalThis.fetch = (async (_url, init) => {
         const body = JSON.parse(String(init?.body ?? "{}"));
         const payload = typeof body.variables?.id === "string"
-            ? { data: { issue: LIST_NODES.find((n) => n.identifier === "NOT-242") ?? null } }
+            ? {
+                data: {
+                    issue: LIST_NODES.find((n) => n.identifier === body.variables?.id) ??
+                        LIST_NODES.find((n) => n.identifier === "NOT-242") ??
+                        null,
+                },
+            }
             : {
                 data: {
                     issues: { nodes: LIST_NODES, pageInfo: { hasNextPage: false, endCursor: null } },
@@ -89,3 +95,51 @@ test("GET /api/intake/linear/lookup rejects an unparseable ref without calling L
     const res = await app.inject({ method: "GET", url: "/api/intake/linear/lookup?q=not%20a%20ticket" });
     assert.equal(res.statusCode, 400);
 });
+// NOT-260: a configured mapping prefills list candidates and direct lookups.
+test("a mapped Linear label resolves in the candidate list with repo: fallback intact", async () => {
+    const { replaceRepositoryMappings } = await import("../repository/repository-mappings.js");
+    replaceRepositoryMappings({
+        mappings: [{ label: "agent-dealer", repository: "not-so-fat/mapped" }],
+    });
+    try {
+        const app = await buildApp();
+        const res = await app.inject({ method: "GET", url: "/api/intake/linear" });
+        assert.equal(res.statusCode, 200);
+        const json = res.json();
+        // NOT-243 carries the plain `agent-dealer` label — now mapped.
+        const mapped = json.candidates.find((c) => c.identifier === "NOT-243");
+        assert.equal(mapped?.repoResolution?.status, "resolved");
+        assert.equal(mapped?.repoResolution?.repository, "github.com/not-so-fat/mapped");
+        assert.equal(mapped?.repoResolution?.sourceLabel, "agent-dealer");
+        // Raw Linear labels stay on the candidate.
+        assert.deepEqual(mapped?.labels, ["agent-dealer"]);
+        // NOT-242 has no mapping match — legacy repo: fallback still resolves.
+        const legacy = json.candidates.find((c) => c.identifier === "NOT-242");
+        assert.equal(legacy?.repoResolution?.status, "resolved");
+        assert.equal(legacy?.repoResolution?.repository, "github.com/not-so-fat/agent-dealer");
+        assert.equal(legacy?.repoResolution?.sourceLabel, "repo:github.com/not-so-fat/agent-dealer");
+    }
+    finally {
+        replaceRepositoryMappings({ mappings: [] });
+    }
+});
+test("a mapped Linear label resolves in direct lookup", async () => {
+    const { replaceRepositoryMappings } = await import("../repository/repository-mappings.js");
+    replaceRepositoryMappings({
+        mappings: [{ label: "agent-dealer", repository: "not-so-fat/mapped" }],
+    });
+    try {
+        const app = await buildApp();
+        const res = await app.inject({ method: "GET", url: "/api/intake/linear/lookup?q=NOT-243" });
+        assert.equal(res.statusCode, 200);
+        const json = res.json();
+        assert.equal(json.candidate.identifier, "NOT-243");
+        assert.equal(json.candidate.repoResolution?.status, "resolved");
+        assert.equal(json.candidate.repoResolution?.repository, "github.com/not-so-fat/mapped");
+        assert.equal(json.candidate.repoResolution?.sourceLabel, "agent-dealer");
+        assert.deepEqual(json.candidate.labels, ["agent-dealer"]);
+    }
+    finally {
+        replaceRepositoryMappings({ mappings: [] });
+    }
+});

package/bundle/server/dist/routes/repository-mappings.js

@@ -0,0 +1,22 @@
+import { listRepositoryMappings, replaceRepositoryMappings, } from "../repository/repository-mappings.js";
+/** NOT-260: label → repository mapping settings (inline editor in New issue). */
+export async function registerRepositoryMappingsRoutes(app) {
+    app.get("/api/settings/repository-mappings", async () => ({
+        mappings: listRepositoryMappings(),
+    }));
+    app.put("/api/settings/repository-mappings", async (req, reply) => {
+        const body = (req.body ?? {});
+        if (!body || !Array.isArray(body.mappings)) {
+            return reply.status(400).send({ error: "Body must be { mappings: [...] }" });
+        }
+        try {
+            const mappings = replaceRepositoryMappings({
+                mappings: body.mappings,
+            });
+            return { mappings };
+        }
+        catch (e) {
+            return reply.status(400).send({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+}

package/bundle/server/dist/routes/repository-mappings.test.js

@@ -0,0 +1,110 @@
+// NOT-260: GET/PUT /api/settings/repository-mappings — normalized round
+// trip plus HTTP 400 with a readable error that preserves the last valid array.
+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";
+import Fastify from "fastify";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-repo-mappings-routes-"));
+const { migrate } = await import("../db/index.js");
+const { registerRepositoryMappingsRoutes } = await import("./repository-mappings.js");
+before(() => {
+    migrate();
+});
+async function buildApp() {
+    const app = Fastify();
+    await registerRepositoryMappingsRoutes(app);
+    return app;
+}
+test("GET returns { mappings: [] } on a fresh install", async () => {
+    const app = await buildApp();
+    const res = await app.inject({ method: "GET", url: "/api/settings/repository-mappings" });
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.json(), { mappings: [] });
+});
+test("PUT persists and returns normalized mappings", async () => {
+    const app = await buildApp();
+    const res = await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "agent-dealer", repository: "not-so-fat/agent-dealer" }] },
+    });
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.json(), {
+        mappings: [{ label: "agent-dealer", repository: "github.com/not-so-fat/agent-dealer" }],
+    });
+    const get = await app.inject({ method: "GET", url: "/api/settings/repository-mappings" });
+    assert.deepEqual(get.json(), {
+        mappings: [{ label: "agent-dealer", repository: "github.com/not-so-fat/agent-dealer" }],
+    });
+});
+test("PUT editing the repository overwrites the label's value", async () => {
+    const app = await buildApp();
+    await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "agent-dealer", repository: "not-so-fat/agent-dealer" }] },
+    });
+    const res = await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "agent-dealer", repository: "not-so-fat/other" }] },
+    });
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.json(), {
+        mappings: [{ label: "agent-dealer", repository: "github.com/not-so-fat/other" }],
+    });
+});
+test("PUT with duplicate normalized labels returns 400 and preserves the array", async () => {
+    const app = await buildApp();
+    await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "agent-dealer", repository: "not-so-fat/other" }] },
+    });
+    const res = await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: {
+            mappings: [
+                { label: "agent-dealer", repository: "not-so-fat/agent-dealer" },
+                { label: " AGENT-DEALER ", repository: "not-so-fat/other" },
+            ],
+        },
+    });
+    assert.equal(res.statusCode, 400);
+    const body = res.json();
+    assert.ok(body.error && body.error.length > 0, "readable error");
+    const get = await app.inject({ method: "GET", url: "/api/settings/repository-mappings" });
+    assert.deepEqual(get.json(), {
+        mappings: [{ label: "agent-dealer", repository: "github.com/not-so-fat/other" }],
+    });
+});
+test("PUT with empty labels, invalid repos, or 101 rows returns 400 atomically", async () => {
+    const app = await buildApp();
+    await app.inject({
+        method: "PUT",
+        url: "/api/settings/repository-mappings",
+        payload: { mappings: [{ label: "keep", repository: "a/b" }] },
+    });
+    const lastValid = { mappings: [{ label: "keep", repository: "github.com/a/b" }] };
+    for (const payload of [
+        { mappings: [{ label: "   ", repository: "a/b" }] },
+        { mappings: [{ label: "ok", repository: "not a repo!!" }] },
+        {
+            mappings: Array.from({ length: 101 }, (_, i) => ({ label: `l${i}`, repository: "a/b" })),
+        },
+        { mappings: "nope" },
+    ]) {
+        const res = await app.inject({
+            method: "PUT",
+            url: "/api/settings/repository-mappings",
+            payload,
+        });
+        assert.equal(res.statusCode, 400);
+        assert.ok(res.json().error, "readable error");
+    }
+    const get = await app.inject({ method: "GET", url: "/api/settings/repository-mappings" });
+    assert.deepEqual(get.json(), lastValid);
+});

package/bundle/server/dist/routes/runtime-capacity.test.js

@@ -17,12 +17,14 @@ process.env.AGENT_DEALER_SKIP_AGENT_HEALTH = "1";
 process.env.AGENT_DEALER_CODEX_CAPACITY_REFRESH = "off";
 const { migrate } = await import("../db/index.js");
 const { createAgent } = await import("../repository/agents.js");
-const { clearAllCapacitySnapshots, listCapacitySnapshots } = await import("../repository/runtime-capacity.js");
-const { fixtureMultiWindowAdapter } = await import("../capacity/adapter.js");
+const { clearAllCapacitySnapshots, listCapacitySnapshots, recordCapacitySnapshots } = await import("../repository/runtime-capacity.js");
+const { fixtureMultiWindowAdapter, normalizeAdapterWindow } = await import("../capacity/adapter.js");
 const { refreshCapacityFromAdapters } = await import("../capacity/service.js");
 const { resetMuseCapacityRefreshState } = await import("../capacity/muse.js");
+const { refreshCodexCapacityFromAppServer } = await import("../capacity/codex-app-server.js");
 const { registerRoutes } = await import("./index.js");
 const { RuntimeCapacityResponse } = await import("@agent-dealer/shared");
+const FAKE_CODEX = new URL("../capacity/fixtures/fake-codex-app-server.mjs", import.meta.url).pathname;
 migrate();
 async function buildApp() {
     const app = Fastify();
@@ -104,6 +106,74 @@ test("GET triggers the Muse refresh when muse_code is configured", async () => {
         resetMuseCapacityRefreshState();
     }
 });
+test("GET serves one logical Codex pair after a dedup refresh of legacy duplicates", async () => {
+    // NOT-263: databases written by older versions hold both the aggregate
+    // aliases (`codex_rate_limit_primary/secondary`) and the detailed rows for
+    // the same logical pair. One refresh against a mirroring payload must
+    // delete the aliases, and GET must serve each logical window once.
+    clearAllCapacitySnapshots();
+    createAgent({
+        name: "route-codex-dedup",
+        runtime: "codex_local",
+        deckId: "55555555-5555-4555-8555-555555555555",
+    });
+    const seedNow = Date.now();
+    const seedObserved = new Date(seedNow).toISOString();
+    const seed = (windowKey, providerBucket, durationMinutes) => normalizeAdapterWindow("codex_local", {
+        windowKey,
+        providerBucket,
+        durationMinutes,
+        providerLabel: providerBucket,
+        usedValue: 9,
+        usedUnit: "percent",
+        usedPercent: 9,
+        resetAt: new Date(seedNow + 2 * 3600_000).toISOString(),
+        observedAt: seedObserved,
+        source: "supported_protocol",
+    }, seedNow);
+    recordCapacitySnapshots("codex_local", [
+        seed("codex_rate_limit_primary", "primary", 300),
+        seed("codex_rate_limit_secondary", "secondary", 10080),
+        seed("codex_limit_main_primary", "main/primary", 300),
+        seed("codex_limit_main_secondary", "main/secondary", 10080),
+    ]);
+    assert.equal(listCapacitySnapshots("codex_local").length, 4);
+    const now = Date.now();
+    await refreshCodexCapacityFromAppServer({
+        command: process.execPath,
+        args: [FAKE_CODEX],
+        env: { FAKE_CODEX_MODE: "mirror", FAKE_CODEX_NOW_MS: String(now) },
+        timeoutMs: 10_000,
+        nowMs: now,
+    });
+    const app = await buildApp();
+    try {
+        const res = await app.inject({ method: "GET", url: "/api/runtime-capacity" });
+        assert.equal(res.statusCode, 200);
+        const body = RuntimeCapacityResponse.parse(res.json());
+        const codex = body.runtimes.find((r) => r.runtime === "codex_local");
+        assert.ok(codex, "codex_local entry served");
+        assert.equal(codex.unavailableReason, null);
+        const keys = codex.windows.map((w) => w.windowKey);
+        assert.ok(!keys.some((k) => k.startsWith("codex_rate_limit_")), `no aggregate aliases, got ${keys}`);
+        // Mirrored `main` pair renders once (5H + weekly); the genuinely
+        // distinct `extra` bucket renders as its own pair.
+        assert.deepEqual([...keys].sort(), [
+            "codex_limit_extra_primary",
+            "codex_limit_extra_secondary",
+            "codex_limit_main_primary",
+            "codex_limit_main_secondary",
+        ]);
+        const mainPrimary = codex.windows.find((w) => w.windowKey === "codex_limit_main_primary");
+        assert.equal(mainPrimary.displayLabel, "5H");
+        assert.equal(mainPrimary.remainingPercent, 30);
+        const raw = JSON.stringify(res.json());
+        assert.ok(!raw.includes("evidence"), "no evidence pointers leak to the browser");
+    }
+    finally {
+        await app.close();
+    }
+});
 test("GET /api/runtime-capacity serves a configured Codex account without spawning", async () => {
     clearAllCapacitySnapshots();
     createAgent({

package/bundle/server/package.json

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