agent-dealer 1.2.12 → 1.2.13

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

@@ -1,9 +1,11 @@
 import { resolveLinearRepoWithMappings } from "@agent-dealer/shared";
 import { DEFAULT_LINEAR_STATE_FILTER, getLinearIntakeConfig } from "../repository/intake-settings.js";
 import { listRepositoryMappings } from "../repository/repository-mappings.js";
-import { linearGraphqlRequest } from "./linear-graphql.js";
+import { LinearApiKeyMissingError, linearGraphqlRequest } from "./linear-graphql.js";
 export { DEFAULT_LINEAR_STATE_FILTER };
-const PAGE_SIZE = 50;
+/** NOT-361: first-page bound for the From Linear picker — never walk further cursors. */
+export const LINEAR_CANDIDATE_PAGE_SIZE = 50;
+const PAGE_SIZE = LINEAR_CANDIDATE_PAGE_SIZE;
 function hasApiKey() {
     return Boolean(process.env.LINEAR_API_KEY);
 }
@@ -81,35 +83,89 @@ export function parseLinearIssueRef(raw) {
     }
     return null;
 }
+/**
+ * NOT-361: at most one GraphQL page of candidates, most recently updated first.
+ * Does not walk `pageInfo` cursors — `hasMore` tells the UI when matches remain.
+ */
 export async function listLinearCandidates() {
     if (!hasApiKey())
-        return [];
+        return { candidates: [], hasMore: false };
     const settings = getLinearIntakeConfig();
     let viewerId;
     if (settings.assigneeMe) {
         const viewer = await getLinearViewer();
         viewerId = viewer?.id;
         if (!viewerId)
-            return [];
+            return { candidates: [], hasMore: false };
     }
     const filter = buildIssueFilter(settings, viewerId);
-    const nodes = [];
-    let after;
+    const data = (await linearQuery("listLinearCandidates", `query PollIssues($filter: IssueFilter) {
+      issues(filter: $filter, first: ${PAGE_SIZE}, orderBy: updatedAt) {
+        nodes { ${ISSUE_FIELDS} }
+        pageInfo { hasNextPage }
+      }
+    }`, { filter }));
+    // NOT-260: mappings load once per list operation, not once per candidate.
+    const mappings = listRepositoryMappings();
+    return {
+        candidates: data.issues.nodes.map((n) => nodeToCandidate(n, mappings)),
+        hasMore: Boolean(data.issues.pageInfo.hasNextPage),
+    };
+}
+/** Page size when walking Linear teams for the filter editor metadata. */
+const METADATA_TEAM_PAGE_SIZE = 50;
+/**
+ * NOT-361: teams, workflow statuses, and the authenticated Linear viewer for
+ * the inline filter editor — never ask the operator for raw UUIDs or CSV text.
+ * Teams are walked page-by-page so large workspaces are not truncated at
+ * Linear's default first page.
+ */
+export async function fetchLinearIntakeMetadata() {
+    if (!hasApiKey())
+        throw new LinearApiKeyMissingError();
+    const viewerData = (await linearQuery("fetchLinearIntakeMetadataViewer", `query IntakeMetadataViewer { viewer { id name email } }`));
+    const teams = [];
+    const workflowStates = [];
+    let after = null;
     for (;;) {
-        const data = (await linearQuery("listLinearCandidates", `query PollIssues($filter: IssueFilter, $after: String) {
-        issues(filter: $filter, first: ${PAGE_SIZE}, after: $after) {
-          nodes { ${ISSUE_FIELDS} }
+        const page = (await linearQuery("fetchLinearIntakeMetadataTeams", `query IntakeMetadataTeams($first: Int!, $after: String) {
+        teams(first: $first, after: $after) {
+          nodes {
+            id
+            name
+            key
+            states { nodes { name type } }
+          }
           pageInfo { hasNextPage endCursor }
         }
-      }`, { filter, after: after ?? null }));
-        nodes.push(...data.issues.nodes);
-        if (!data.issues.pageInfo.hasNextPage || !data.issues.pageInfo.endCursor)
+      }`, { first: METADATA_TEAM_PAGE_SIZE, after }));
+        for (const team of page.teams?.nodes ?? []) {
+            teams.push({ id: team.id, name: team.name, key: team.key });
+            for (const state of team.states?.nodes ?? []) {
+                const name = state.name?.trim();
+                if (!name)
+                    continue;
+                workflowStates.push({ name, type: state.type, teamId: team.id });
+            }
+        }
+        if (!page.teams?.pageInfo?.hasNextPage || !page.teams.pageInfo.endCursor)
             break;
-        after = data.issues.pageInfo.endCursor;
+        after = page.teams.pageInfo.endCursor;
     }
-    // NOT-260: mappings load once per list operation, not once per candidate.
-    const mappings = listRepositoryMappings();
-    return nodes.map((n) => nodeToCandidate(n, mappings));
+    // Stable team order by name; statuses keep Linear's per-team order, then
+    // unique-by-name order is left to the UI when "All teams" is selected.
+    teams.sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        teams,
+        workflowStates,
+        viewer: viewerData.viewer
+            ? {
+                id: viewerData.viewer.id,
+                name: viewerData.viewer.name,
+                email: viewerData.viewer.email,
+            }
+            : null,
+    };
 }
 export async function getLinearIssue(issueId) {
     const data = (await linearQuery("getLinearIssue", `query Issue($id: String!) {

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

@@ -1,6 +1,9 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { buildIssueFilter, nodeToCandidate, parseLinearIssueRef } from "./linear-inbox.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { buildIssueFilter, LINEAR_CANDIDATE_PAGE_SIZE, listLinearCandidates, fetchLinearIntakeMetadata, nodeToCandidate, parseLinearIssueRef, } from "./linear-inbox.js";
 test("parseLinearIssueRef accepts identifier, URL, and UUID", () => {
     assert.equal(parseLinearIssueRef("NOT-103"), "NOT-103");
     assert.equal(parseLinearIssueRef("  not-90  "), "NOT-90");
@@ -81,3 +84,182 @@ test("buildIssueFilter includes assignee when assigneeMe is true", () => {
         assignee: { id: { eq: "viewer-1" } },
     });
 });
+// NOT-361: bounded candidate fetch — AND filters, updatedAt order, first page only.
+test("listLinearCandidates requests AND filters, updatedAt order, and a single page", async () => {
+    process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-linear-inbox-"));
+    process.env.LINEAR_API_KEY = "test-key";
+    delete process.env.LINEAR_STATE_FILTER;
+    delete process.env.LINEAR_TEAM_ID;
+    const { migrate } = await import("../db/index.js");
+    migrate();
+    const { patchLinearIntakeConfig } = await import("../repository/intake-settings.js");
+    patchLinearIntakeConfig({
+        stateFilter: ["Todo", "In Progress"],
+        teamId: "team-9",
+        assigneeMe: true,
+    });
+    const requests = [];
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = (async (_url, init) => {
+        const body = JSON.parse(String(init?.body ?? "{}"));
+        requests.push({ query: body.query ?? "", variables: body.variables });
+        if ((body.query ?? "").includes("viewer {")) {
+            return {
+                ok: true,
+                status: 200,
+                headers: new Headers(),
+                text: async () => JSON.stringify({ data: { viewer: { id: "viewer-1", name: "Ada" } } }),
+            };
+        }
+        return {
+            ok: true,
+            status: 200,
+            headers: new Headers(),
+            text: async () => JSON.stringify({
+                data: {
+                    issues: {
+                        nodes: [
+                            {
+                                id: "i1",
+                                identifier: "NOT-1",
+                                title: "one",
+                                url: "https://linear.app/x/issue/NOT-1/one",
+                                state: { name: "Todo" },
+                                team: { id: "team-9" },
+                                labels: { nodes: [] },
+                            },
+                        ],
+                        pageInfo: { hasNextPage: true },
+                    },
+                },
+            }),
+        };
+    });
+    try {
+        const page = await listLinearCandidates();
+        assert.equal(page.candidates.length, 1);
+        assert.equal(page.hasMore, true);
+        // viewer (assigneeMe) + one issues page — never a second cursor page.
+        assert.equal(requests.length, 2);
+        const issuesReq = requests.find((r) => r.query.includes("issues("));
+        assert.ok(issuesReq, "issues query sent");
+        assert.match(issuesReq.query, /orderBy:\s*updatedAt/);
+        assert.match(issuesReq.query, new RegExp(`first:\\s*${LINEAR_CANDIDATE_PAGE_SIZE}`));
+        assert.ok(!issuesReq.query.includes("$after"), "no cursor variable");
+        assert.deepEqual(issuesReq.variables?.filter, {
+            state: { name: { in: ["Todo", "In Progress"] } },
+            team: { id: { eq: "team-9" } },
+            assignee: { id: { eq: "viewer-1" } },
+        });
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("fetchLinearIntakeMetadata returns teams, statuses, and viewer", async () => {
+    process.env.LINEAR_API_KEY = "test-key";
+    const realFetch = globalThis.fetch;
+    const bodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        bodies.push(JSON.parse(String(init?.body ?? "{}")));
+        const op = bodies[bodies.length - 1].query ?? "";
+        if (op.includes("IntakeMetadataViewer")) {
+            return new Response(JSON.stringify({
+                data: { viewer: { id: "v1", name: "Ada", email: "ada@example.com" } },
+            }), { status: 200, headers: { "Content-Type": "application/json" } });
+        }
+        return new Response(JSON.stringify({
+            data: {
+                teams: {
+                    nodes: [
+                        {
+                            id: "t1",
+                            name: "Core",
+                            key: "COR",
+                            states: {
+                                nodes: [
+                                    { name: "Todo", type: "unstarted" },
+                                    { name: "Done", type: "completed" },
+                                ],
+                            },
+                        },
+                    ],
+                    pageInfo: { hasNextPage: false, endCursor: null },
+                },
+            },
+        }), { status: 200, headers: { "Content-Type": "application/json" } });
+    });
+    try {
+        const meta = await fetchLinearIntakeMetadata();
+        assert.equal(meta.viewer?.name, "Ada");
+        assert.equal(meta.teams[0]?.name, "Core");
+        assert.ok(meta.workflowStates.some((s) => s.name === "Todo" && s.teamId === "t1"));
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("fetchLinearIntakeMetadata walks team pages beyond Linear's default first page", async () => {
+    process.env.LINEAR_API_KEY = "test-key";
+    const realFetch = globalThis.fetch;
+    let teamPageCalls = 0;
+    globalThis.fetch = (async (_input, init) => {
+        const body = JSON.parse(String(init?.body ?? "{}"));
+        if ((body.query ?? "").includes("IntakeMetadataViewer")) {
+            return new Response(JSON.stringify({ data: { viewer: { id: "v1", name: "Ada" } } }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        teamPageCalls += 1;
+        assert.equal(body.variables?.first, 50, "requests a bounded team page");
+        if (teamPageCalls === 1) {
+            assert.equal(body.variables?.after ?? null, null, "first page has no cursor");
+            return new Response(JSON.stringify({
+                data: {
+                    teams: {
+                        nodes: [
+                            {
+                                id: "t1",
+                                name: "Alpha",
+                                states: { nodes: [{ name: "Todo", type: "unstarted" }] },
+                            },
+                        ],
+                        pageInfo: { hasNextPage: true, endCursor: "cursor-1" },
+                    },
+                },
+            }), { status: 200, headers: { "Content-Type": "application/json" } });
+        }
+        assert.equal(body.variables?.after, "cursor-1", "follows endCursor");
+        return new Response(JSON.stringify({
+            data: {
+                teams: {
+                    nodes: [
+                        {
+                            id: "t2",
+                            name: "Zeta",
+                            states: { nodes: [{ name: "In Progress", type: "started" }] },
+                        },
+                    ],
+                    pageInfo: { hasNextPage: false, endCursor: null },
+                },
+            },
+        }), { status: 200, headers: { "Content-Type": "application/json" } });
+    });
+    try {
+        const meta = await fetchLinearIntakeMetadata();
+        assert.equal(teamPageCalls, 2, "walks a second team page");
+        assert.deepEqual(meta.teams.map((t) => t.name), ["Alpha", "Zeta"]);
+        assert.ok(meta.workflowStates.some((s) => s.name === "In Progress" && s.teamId === "t2"));
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("fetchLinearIntakeMetadata fails clearly without LINEAR_API_KEY", async () => {
+    delete process.env.LINEAR_API_KEY;
+    await assert.rejects(() => fetchLinearIntakeMetadata(), /LINEAR_API_KEY/);
+});

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

@@ -1,3 +1,4 @@
+import { normalizeLinearIntakePickerPatch } from "@agent-dealer/shared";
 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"];
@@ -14,6 +15,11 @@ 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;
@@ -23,6 +29,19 @@ 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 !== "",
+    };
+}
+function toPickerConfig(config) {
+    return {
+        stateFilter: config.stateFilter,
+        teamId: config.teamId,
+        assigneeMe: config.assigneeMe,
+    };
+}
 /** Persisted-only view of the Linear intake config (env overrides applied separately). */
 export function getPersistedLinearIntakeConfig() {
     return {
@@ -47,6 +66,37 @@ function applyEnvOverrides(config) {
 export function getLinearIntakeConfig() {
     return applyEnvOverrides(getPersistedLinearIntakeConfig());
 }
+/** NOT-361: effective picker filters + persisted values + which env vars win. */
+export function getLinearIntakeConfigView() {
+    const persistedFull = getPersistedLinearIntakeConfig();
+    const effective = applyEnvOverrides(persistedFull);
+    return {
+        ...toPickerConfig(effective),
+        persisted: toPickerConfig(persistedFull),
+        envOverrides: linearEnvOverrides(),
+    };
+}
+/**
+ * NOT-361: persist picker fields only (Team / Assignee / Status).
+ * Never touches syncEnabled or the deleted routing/default-agent rows.
+ */
+export function patchLinearIntakeConfig(patch) {
+    const normalized = normalizeLinearIntakePickerPatch(patch);
+    const current = getPersistedLinearIntakeConfig();
+    const nextPicker = {
+        stateFilter: normalized.stateFilter ?? current.stateFilter,
+        teamId: normalized.teamId !== undefined ? normalized.teamId : current.teamId,
+        assigneeMe: normalized.assigneeMe !== undefined ? normalized.assigneeMe : current.assigneeMe,
+    };
+    // Re-validate the merged picker shape (empty status list is rejected above).
+    if (nextPicker.stateFilter.length === 0) {
+        throw new Error("Select at least one workflow status");
+    }
+    setJson("linear.stateFilter", nextPicker.stateFilter);
+    setJson("linear.teamId", nextPicker.teamId);
+    setJson("linear.assigneeMe", nextPicker.assigneeMe);
+    return getLinearIntakeConfigView();
+}
 function parseEnvAgentDeckUrl() {
     const raw = process.env.AGENT_DECK_API_URL;
     if (!raw)

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

@@ -0,0 +1,72 @@
+// NOT-361: Linear picker config persistence, env-override precedence, and
+// narrow patch (Team / Assignee / Status only — no routing fields).
+import { test, before, 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";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-intake-settings-"));
+const { migrate, getDb } = await import("../db/index.js");
+const { getLinearIntakeConfigView, getPersistedLinearIntakeConfig, patchLinearIntakeConfig, DEFAULT_LINEAR_STATE_FILTER, } = await import("./intake-settings.js");
+before(() => {
+    delete process.env.LINEAR_STATE_FILTER;
+    delete process.env.LINEAR_TEAM_ID;
+    migrate();
+});
+afterEach(() => {
+    delete process.env.LINEAR_STATE_FILTER;
+    delete process.env.LINEAR_TEAM_ID;
+    // Reset picker rows to defaults between cases.
+    const db = getDb();
+    const upsert = db.prepare("INSERT INTO intake_settings (key, value_json) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json");
+    upsert.run("linear.stateFilter", JSON.stringify([...DEFAULT_LINEAR_STATE_FILTER]));
+    upsert.run("linear.teamId", JSON.stringify(null));
+    upsert.run("linear.assigneeMe", JSON.stringify(false));
+});
+test("patchLinearIntakeConfig round-trips Team, Assignee, and Status through SQLite", () => {
+    const saved = patchLinearIntakeConfig({
+        stateFilter: ["Todo", "In Progress"],
+        teamId: "team-abc",
+        assigneeMe: true,
+    });
+    assert.deepEqual(saved.persisted, {
+        stateFilter: ["Todo", "In Progress"],
+        teamId: "team-abc",
+        assigneeMe: true,
+    });
+    assert.deepEqual(saved.stateFilter, ["Todo", "In Progress"]);
+    assert.equal(saved.teamId, "team-abc");
+    assert.equal(saved.assigneeMe, true);
+    assert.equal(saved.envOverrides.stateFilter, false);
+    assert.equal(saved.envOverrides.teamId, false);
+    const again = getLinearIntakeConfigView();
+    assert.deepEqual(again.persisted, saved.persisted);
+    // syncEnabled stays untouched when patching picker fields.
+    const full = getPersistedLinearIntakeConfig();
+    assert.equal(typeof full.syncEnabled, "boolean");
+});
+test("LINEAR_TEAM_ID and LINEAR_STATE_FILTER override effective values and set flags", () => {
+    patchLinearIntakeConfig({
+        stateFilter: ["Backlog"],
+        teamId: "saved-team",
+        assigneeMe: false,
+    });
+    process.env.LINEAR_STATE_FILTER = "Todo, In Review";
+    process.env.LINEAR_TEAM_ID = "env-team";
+    const view = getLinearIntakeConfigView();
+    assert.deepEqual(view.stateFilter, ["Todo", "In Review"]);
+    assert.equal(view.teamId, "env-team");
+    assert.deepEqual(view.persisted.stateFilter, ["Backlog"]);
+    assert.equal(view.persisted.teamId, "saved-team");
+    assert.equal(view.envOverrides.stateFilter, true);
+    assert.equal(view.envOverrides.teamId, true);
+    // A save still writes persisted values; env remains authoritative on read.
+    const afterSave = patchLinearIntakeConfig({ stateFilter: ["In Progress"], teamId: "ui-team" });
+    assert.deepEqual(afterSave.persisted.stateFilter, ["In Progress"]);
+    assert.equal(afterSave.persisted.teamId, "ui-team");
+    assert.deepEqual(afterSave.stateFilter, ["Todo", "In Review"]);
+    assert.equal(afterSave.teamId, "env-team");
+});
+test("patchLinearIntakeConfig rejects an empty status list", () => {
+    assert.throws(() => patchLinearIntakeConfig({ stateFilter: ["  ", ""] }), /at least one/i);
+});

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

@@ -13,6 +13,7 @@ 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";
 import { registerVersionRoute } from "./version.js";
+import { registerIntakeLinearConfigRoutes } from "./intake-linear-config.js";
 async function resolveDeckName(deckId) {
     if (!deckId)
         return null;
@@ -35,15 +36,17 @@ export async function registerRoutes(app) {
         const { models, source } = await listRuntimeModels(parsed.data, { refresh });
         return { runtime: parsed.data, models, source };
     });
+    // NOT-361: picker config + Linear metadata for the inline New issue filter editor.
+    await registerIntakeLinearConfigRoutes(app);
     // Linear lookup for the Issues home "New issue" flow — the only intake surface left
     // after NOT-71 removed the Inbox page and its promote-to-run pipeline.
+    // NOT-361: bounded page (≤50, most recently updated) with hasMore escape hatch.
     app.get("/api/intake/linear", async (_req, reply) => {
         try {
-            const candidates = await listLinearCandidates();
-            return { candidates };
+            return await listLinearCandidates();
         }
         catch (e) {
-            return reply.status(502).send({ error: String(e), candidates: [] });
+            return reply.status(502).send({ error: String(e), candidates: [], hasMore: false });
         }
     });
     /** Free-form kick lookup: `?q=NOT-103` or a Linear issue URL. */

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

@@ -0,0 +1,31 @@
+import { LinearIntakeConfigPatch } from "@agent-dealer/shared";
+import { fetchLinearIntakeMetadata, } from "../adapters/linear-inbox.js";
+import { LinearApiKeyMissingError } from "../adapters/linear-graphql.js";
+import { getLinearIntakeConfigView, patchLinearIntakeConfig, } from "../repository/intake-settings.js";
+/**
+ * NOT-361: Linear picker config + metadata for the inline New issue filter editor.
+ * Local dealer API (same trust model as repository-mappings); Linear auth is the API key.
+ */
+export async function registerIntakeLinearConfigRoutes(app) {
+    app.get("/api/intake/linear/config", async () => getLinearIntakeConfigView());
+    app.patch("/api/intake/linear/config", async (req, reply) => {
+        try {
+            const patch = LinearIntakeConfigPatch.parse(req.body ?? {});
+            return patchLinearIntakeConfig(patch);
+        }
+        catch (e) {
+            return reply.status(400).send({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    app.get("/api/intake/linear/metadata", async (_req, reply) => {
+        try {
+            return await fetchLinearIntakeMetadata();
+        }
+        catch (e) {
+            if (e instanceof LinearApiKeyMissingError) {
+                return reply.status(503).send({ error: e.message });
+            }
+            return reply.status(502).send({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+}

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

@@ -32,19 +32,44 @@ before(() => {
     process.env.LINEAR_API_KEY = "test-key";
     globalThis.fetch = (async (_url, init) => {
         const body = JSON.parse(String(init?.body ?? "{}"));
-        const payload = typeof body.variables?.id === "string"
-            ? {
+        const query = body.query ?? "";
+        let payload;
+        if (typeof body.variables?.id === "string") {
+            payload = {
                 data: {
                     issue: LIST_NODES.find((n) => n.identifier === body.variables?.id) ??
                         LIST_NODES.find((n) => n.identifier === "NOT-242") ??
                         null,
                 },
-            }
-            : {
+            };
+        }
+        else if (query.includes("IntakeMetadata") || /query\s*\{\s*viewer\s*\{/.test(query)) {
+            payload = {
                 data: {
-                    issues: { nodes: LIST_NODES, pageInfo: { hasNextPage: false, endCursor: null } },
+                    viewer: { id: "viewer-1", name: "Ada" },
+                    teams: {
+                        nodes: [
+                            {
+                                id: "team-1",
+                                name: "Core",
+                                key: "COR",
+                                states: { nodes: [{ name: "Todo", type: "unstarted" }] },
+                            },
+                        ],
+                    },
                 },
             };
+        }
+        else {
+            payload = {
+                data: {
+                    issues: {
+                        nodes: LIST_NODES,
+                        pageInfo: { hasNextPage: listHasMoreForTest, endCursor: null },
+                    },
+                },
+            };
+        }
         return {
             ok: true,
             status: 200,
@@ -53,6 +78,8 @@ before(() => {
         };
     });
 });
+/** Flipped by hasMore route tests; default false for the existing candidate-list cases. */
+let listHasMoreForTest = false;
 after(() => {
     globalThis.fetch = realFetch;
     delete process.env.LINEAR_API_KEY;
@@ -63,11 +90,13 @@ async function buildApp() {
     return app;
 }
 test("GET /api/intake/linear returns candidates with resolved repo hints", async () => {
+    listHasMoreForTest = false;
     const app = await buildApp();
     const res = await app.inject({ method: "GET", url: "/api/intake/linear" });
     assert.equal(res.statusCode, 200);
     const json = res.json();
     assert.equal(json.candidates.length, 4);
+    assert.equal(json.hasMore, false);
     const one = json.candidates.find((c) => c.identifier === "NOT-242");
     assert.equal(one?.repoResolution?.status, "resolved");
     assert.equal(one?.repoResolution?.repository, "github.com/not-so-fat/agent-dealer");
@@ -143,3 +172,64 @@ test("a mapped Linear label resolves in direct lookup", async () => {
         replaceRepositoryMappings({ mappings: [] });
     }
 });
+// NOT-361: config / metadata / hasMore on the intake routes.
+test("GET/PATCH /api/intake/linear/config round-trips picker filters", async () => {
+    delete process.env.LINEAR_STATE_FILTER;
+    delete process.env.LINEAR_TEAM_ID;
+    const app = await buildApp();
+    const patched = await app.inject({
+        method: "PATCH",
+        url: "/api/intake/linear/config",
+        payload: { stateFilter: ["Todo"], teamId: "team-1", assigneeMe: true },
+    });
+    assert.equal(patched.statusCode, 200);
+    const body = patched.json();
+    assert.deepEqual(body.persisted, { stateFilter: ["Todo"], teamId: "team-1", assigneeMe: true });
+    const got = await app.inject({ method: "GET", url: "/api/intake/linear/config" });
+    assert.equal(got.statusCode, 200);
+    assert.deepEqual(got.json().persisted, body.persisted);
+});
+test("env overrides are visible on the config view", async () => {
+    process.env.LINEAR_STATE_FILTER = "In Review";
+    process.env.LINEAR_TEAM_ID = "env-team";
+    try {
+        const app = await buildApp();
+        const res = await app.inject({ method: "GET", url: "/api/intake/linear/config" });
+        assert.equal(res.statusCode, 200);
+        const body = res.json();
+        assert.deepEqual(body.stateFilter, ["In Review"]);
+        assert.equal(body.teamId, "env-team");
+        assert.equal(body.envOverrides.stateFilter, true);
+        assert.equal(body.envOverrides.teamId, true);
+    }
+    finally {
+        delete process.env.LINEAR_STATE_FILTER;
+        delete process.env.LINEAR_TEAM_ID;
+    }
+});
+test("GET /api/intake/linear/metadata returns teams, statuses, and viewer", async () => {
+    const app = await buildApp();
+    const res = await app.inject({ method: "GET", url: "/api/intake/linear/metadata" });
+    assert.equal(res.statusCode, 200);
+    const body = res.json();
+    assert.equal(body.teams[0]?.name, "Core");
+    assert.ok(body.workflowStates.some((s) => s.name === "Todo"));
+    assert.equal(body.viewer?.name, "Ada");
+});
+test("GET /api/intake/linear reports hasMore true and false", async () => {
+    // Ensure assigneeMe does not short-circuit the list when viewer lookup fails.
+    const app = await buildApp();
+    await app.inject({
+        method: "PATCH",
+        url: "/api/intake/linear/config",
+        payload: { assigneeMe: false },
+    });
+    listHasMoreForTest = true;
+    const more = await app.inject({ method: "GET", url: "/api/intake/linear" });
+    assert.equal(more.statusCode, 200);
+    assert.equal(more.json().hasMore, true);
+    listHasMoreForTest = false;
+    const done = await app.inject({ method: "GET", url: "/api/intake/linear" });
+    assert.equal(done.statusCode, 200);
+    assert.equal(done.json().hasMore, false);
+});

package/bundle/server/package.json

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