agent-dealer 1.2.0 → 1.2.2

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

@@ -389,6 +389,11 @@ export function migrate() {
         ON runtime_capacity_snapshots(runtime);
     `);
     }
+    // NOT-264 repair: critical_role on a table that predates it.
+    const capacityCols = db.prepare("PRAGMA table_info(runtime_capacity_snapshots)").all();
+    if (!capacityCols.some((c) => c.name === "critical_role")) {
+        db.exec("ALTER TABLE runtime_capacity_snapshots ADD COLUMN critical_role TEXT");
+    }
     // NOT-249: normalized Cursor-team billing snapshot for databases created
     // before schema.sql declared the table (same upgrade-path pattern as
     // runtime_capacity_snapshots above).
@@ -433,6 +438,31 @@ export function migrate() {
             db.exec("ALTER TABLE cursor_team_billing_snapshots ADD COLUMN member_limit_override_count REAL");
         }
     }
+    // NOT-250: normalized Cursor-individual billing snapshot for databases
+    // created before schema.sql declared the table (same upgrade-path pattern
+    // as cursor_team_billing_snapshots above).
+    const cursorIndividualBilling = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'cursor_individual_billing_snapshots'")
+        .get();
+    if (!cursorIndividualBilling) {
+        db.exec(`
+      CREATE TABLE cursor_individual_billing_snapshots (
+        id INTEGER NOT NULL PRIMARY KEY CHECK (id = 1),
+        cycle_label TEXT,
+        cycle_start TEXT,
+        cycle_end TEXT,
+        usage_value REAL,
+        usage_unit TEXT,
+        remaining_percent REAL,
+        source TEXT NOT NULL,
+        unavailable_reason TEXT,
+        observed_at TEXT NOT NULL,
+        fresh_until TEXT,
+        expires_at TEXT,
+        evidence_ref TEXT
+      );
+    `);
+    }
     // NOT-103: sequential issue admission queue.
     const queueEntries = db
         .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'queue_entries'")

package/bundle/server/dist/db/schema.sql

@@ -400,6 +400,12 @@ CREATE TABLE IF NOT EXISTS runtime_capacity_snapshots (
   source TEXT NOT NULL,
   unavailable_reason TEXT,
   evidence_ref TEXT,
+  -- NOT-264 repair: which account-wide critical window this is ('five_hour'
+  -- / 'weekly'), set once by the adapter that knows the provider's own
+  -- identity (e.g. Codex's rateLimits aggregate, or the detailed limit pair
+  -- it collapsed into) — never re-derived client-side from a window key or
+  -- label, which cannot disambiguate multiple same-duration buckets.
+  critical_role TEXT,
   PRIMARY KEY (runtime, window_key)
 );
 
@@ -431,6 +437,27 @@ CREATE TABLE IF NOT EXISTS cursor_team_billing_snapshots (
   evidence_ref TEXT
 );
 
+-- NOT-250: normalized Cursor-individual billing snapshot (single row, id = 1).
+-- Experimental dashboard billing-cycle state, not per-runtime quota windows:
+-- independent of both runtime_capacity_snapshots and runtime_availability
+-- (NOT-111 health). Carries normalized values plus a static evidence pointer
+-- only — never credential material.
+CREATE TABLE IF NOT EXISTS cursor_individual_billing_snapshots (
+  id INTEGER NOT NULL PRIMARY KEY CHECK (id = 1),
+  cycle_label TEXT,
+  cycle_start TEXT,
+  cycle_end TEXT,
+  usage_value REAL,
+  usage_unit TEXT,
+  remaining_percent REAL,
+  source TEXT NOT NULL,
+  unavailable_reason TEXT,
+  observed_at TEXT NOT NULL,
+  fresh_until TEXT,
+  expires_at TEXT,
+  evidence_ref TEXT
+);
+
 -- NOT-111: account-level runtime usage caps (keyed per runtime, not per agent profile).
 CREATE TABLE IF NOT EXISTS runtime_availability (
   runtime TEXT PRIMARY KEY,

package/bundle/server/dist/index.js

@@ -10,6 +10,7 @@ import { registerQueueRoutes } from "./routes/queue.js";
 import { registerHumanActionRoutes } from "./routes/human-actions.js";
 import { registerExecutionAnalysisRoutes } from "./routes/execution-analysis.js";
 import { registerExecutionReportRoutes } from "./routes/execution-report.js";
+import { registerRepositoryMappingsRoutes } from "./routes/repository-mappings.js";
 import { recoverCoordinator } from "./coordinator/recovery.js";
 import { startCoordinatorLoop } from "./coordinator/worker-loop.js";
 import { startLinearUsageSummary } from "./adapters/linear-graphql.js";
@@ -64,6 +65,7 @@ async function main() {
     await registerHumanActionRoutes(app);
     await registerExecutionAnalysisRoutes(app);
     await registerExecutionReportRoutes(app);
+    await registerRepositoryMappingsRoutes(app);
     const uiDist = await registerStaticUi(app);
     // Without this, getEffectHandler() falls back to the always-session_failed placeholders
     // (effect-registry.ts) and every started issue would burn its infra retries and

package/bundle/server/dist/repository/cursor-individual-billing.js

@@ -0,0 +1,84 @@
+// packages/server/src/repository/cursor-individual-billing.ts
+//
+// NOT-250: durable normalized Cursor-individual billing snapshot. Single-row
+// table (`id = 1`): the experimental dashboard adapter reports one
+// billing-cycle state, not per-window readings. Independent of
+// `runtime_availability` (NOT-111 connection health) and written alongside
+// (never instead of) `runtime_capacity_snapshots` — nothing here reads or
+// writes either table.
+//
+// Credential hygiene: this table carries normalized billing values and a
+// static evidence pointer only. The raw local-login token must never be
+// written here — the adapter never passes it to this module, and tests scan
+// stored rows for fixture secrets.
+import { getDb } from "../db/index.js";
+function rowToSnapshot(row) {
+    return {
+        cycleLabel: row.cycle_label,
+        cycleStart: row.cycle_start,
+        cycleEnd: row.cycle_end,
+        usageValue: row.usage_value,
+        usageUnit: row.usage_unit,
+        remainingPercent: row.remaining_percent,
+        source: row.source,
+        unavailableReason: row.unavailable_reason,
+        observedAt: row.observed_at,
+        freshUntil: row.fresh_until,
+        expiresAt: row.expires_at,
+        evidenceRef: row.evidence_ref,
+    };
+}
+/** Upsert the latest normalized individual billing observation (single row). */
+export function writeCursorIndividualBillingRow(input) {
+    getDb()
+        .prepare(`
+    INSERT INTO cursor_individual_billing_snapshots (
+      id, cycle_label, cycle_start, cycle_end, usage_value, usage_unit,
+      remaining_percent, source, unavailable_reason,
+      observed_at, fresh_until, expires_at, evidence_ref
+    )
+    VALUES (
+      1, @cycle_label, @cycle_start, @cycle_end, @usage_value, @usage_unit,
+      @remaining_percent, @source, @unavailable_reason,
+      @observed_at, @fresh_until, @expires_at, @evidence_ref
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      cycle_label = excluded.cycle_label,
+      cycle_end = excluded.cycle_end,
+      cycle_start = excluded.cycle_start,
+      usage_value = excluded.usage_value,
+      usage_unit = excluded.usage_unit,
+      remaining_percent = excluded.remaining_percent,
+      source = excluded.source,
+      unavailable_reason = excluded.unavailable_reason,
+      observed_at = excluded.observed_at,
+      fresh_until = excluded.fresh_until,
+      expires_at = excluded.expires_at,
+      evidence_ref = excluded.evidence_ref
+  `)
+        .run({
+        cycle_label: input.cycleLabel,
+        cycle_start: input.cycleStart,
+        cycle_end: input.cycleEnd,
+        usage_value: input.usageValue,
+        usage_unit: input.usageUnit,
+        remaining_percent: input.remainingPercent,
+        source: input.source,
+        unavailable_reason: input.unavailableReason,
+        observed_at: input.observedAt,
+        fresh_until: input.freshUntil,
+        expires_at: input.expiresAt,
+        evidence_ref: input.evidenceRef,
+    });
+}
+/** The latest normalized individual billing observation, if any. */
+export function readCursorIndividualBillingRow() {
+    const row = getDb()
+        .prepare("SELECT * FROM cursor_individual_billing_snapshots WHERE id = 1")
+        .get();
+    return row ? rowToSnapshot(row) : null;
+}
+/** Test helper — clear the individual billing snapshot (leaves all other tables alone). */
+export function clearCursorIndividualBilling() {
+    getDb().exec("DELETE FROM cursor_individual_billing_snapshots");
+}

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) });
+        }
+    });
+}