agent-dealer 1.2.11 → 1.2.13

package/bundle/server/dist/coordinator/commands.test.js

@@ -7,14 +7,17 @@ import path from "node:path";
 process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-cmds-"));
 const { migrate, getDb } = await import("../db/index.js");
 const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+const { createAgent } = await import("../repository/agents.js");
+const { parseProfileSnapshot } = await import("@agent-dealer/shared");
+const { randomUUID } = await import("node:crypto");
 const { createIssue, getIssue, updateIssue } = await import("../repository/issues.js");
 const { listWorkflowEventsForIssue, getActiveWorkflowInstance } = await import("../repository/workflow-events.js");
 const { createHumanAction, getHumanAction, listHumanActionsForIssue } = await import("../repository/human-actions.js");
 const { setResumeLiveHeadReaderForTests } = await import("./resume-live-head.js");
 const { listFindingsForIssue, reconcileFinding } = await import("../repository/findings.js");
 const { cancelWorkItem, claimWorkItem, listWorkItemsForIssue, getWorkItem, enqueueWorkItem } = await import("../repository/work-items.js");
-const { createWorkerSession, startSession, listWorkerSessionsForIssue } = await import("../repository/worker-sessions.js");
-const { startWorkflow, applyCompletion, resolveHumanActionAndAdvance, resolveHumanActionAndAdvanceAsync, getTaskSnapshot, canEditParkedIssue, TASK_SNAPSHOT_ARTIFACT_KIND, checkIssueReadiness, abortIssue } = await import("./commands.js");
+const { createWorkerSession, completeSession, startSession, listWorkerSessionsForIssue } = await import("../repository/worker-sessions.js");
+const { startWorkflow, applyCompletion, applyParkedEdit, capWaitForIssue, resolveHumanActionAndAdvance, resolveHumanActionAndAdvanceAsync, getTaskSnapshot, canEditParkedIssue, parkCapWait, TASK_SNAPSHOT_ARTIFACT_KIND, checkIssueReadiness, abortIssue } = await import("./commands.js");
 const { ReviewerResult } = await import("./reviewer-result.js");
 const { listArtifactsForIssue } = await import("../repository/artifacts-for-issue.js");
 const { setMergePrForTests, clearFinalizeInflightForTests } = await import("./auto-merge.js");
@@ -330,9 +333,16 @@ async function parkAtAttemptsExhausted() {
     return { issueId, actionId: action.id };
 }
 const snapshotArtifacts = (issueId) => listArtifactsForIssue(issueId).filter((a) => a.kind === TASK_SNAPSHOT_ARTIFACT_KIND);
-test("NOT-185: canEditParkedIssue is true only at an open attempts_exhausted with nothing pending or leased", async () => {
+test("NOT-185/NOT-358: canEditParkedIssue is true only at an open attempts_exhausted or policy_escalation with nothing pending or leased", async () => {
     const { issueId } = await parkAtAttemptsExhausted();
     assert.equal(canEditParkedIssue(getIssue(issueId)), true);
+    // NOT-358: a policy_escalation park (e.g. after a developer budget failure) is
+    // editable the same way, so the owner can swap agents and resume in place.
+    const cappedId = newIssue({ maxInfraAttempts: 0 });
+    startWorkflow(cappedId);
+    await complete(cappedId, { kind: "session_failed" });
+    assert.equal(listHumanActionsForIssue(cappedId).find((a) => a.status === "open").actionType, "policy_escalation");
+    assert.equal(canEditParkedIssue(getIssue(cappedId)), true);
     const instance = getActiveWorkflowInstance(issueId);
     const item = enqueueWorkItem({
         issueId,
@@ -940,3 +950,278 @@ test("NOT-184: resolving the escalation with resume continues without re-trigger
     assert.equal(getIssue(issueId).status, "needs_human");
     assert.match(openNonConvergence(issueId).reason, /rounds 4, 5, 6/);
 });
+/** Swap-target profiles with runtimes distinct from the builtins the issue starts on. */
+function n358Agents() {
+    const deckId = "00000000-0000-4000-a000-000000000358";
+    const dev = createAgent({ name: `n358-dev-${Math.random()}`, runtime: "codex_local", deckId });
+    const rev = createAgent({ name: `n358-rev-${Math.random()}`, runtime: "cursor_local", deckId });
+    return { dev, rev };
+}
+function reassignedEvents(issueId) {
+    return listWorkflowEventsForIssue(issueId).filter((e) => e.type === "issue.reassigned");
+}
+/** The frozen profile snapshot a resumed round carries — what the next session spawns from. */
+function pendingSnapshot(issueId, kind) {
+    const item = listWorkItemsForIssue(issueId).find((i) => i.status === "pending" && i.kind === kind);
+    assert.ok(item, `expected a pending ${kind} work item`);
+    const payload = JSON.parse(item.payloadJson);
+    const snapshot = parseProfileSnapshot(payload.profileSnapshot);
+    assert.ok(snapshot, "the resumed round carries a frozen profile snapshot");
+    return snapshot;
+}
+test("NOT-358: applyParkedEdit swaps each role alone and both, keeping worktree, branch and rounds, one reassigned event per swap", async () => {
+    const { dev, rev } = n358Agents();
+    const { issueId, actionId } = await parkAtAttemptsExhausted();
+    const before = getIssue(issueId);
+    assert.equal(before.branch, "issue-1");
+    const devSwap = applyParkedEdit(issueId, { developerAgentId: dev.id });
+    assert.equal(devSwap.ok, true);
+    if (devSwap.ok !== true)
+        return;
+    assert.equal(devSwap.issue.developerAgentId, dev.id);
+    assert.equal(devSwap.issue.reviewerAgentId, before.reviewerAgentId);
+    assert.equal(devSwap.issue.branch, before.branch);
+    assert.deepEqual([devSwap.issue.currentRound, devSwap.issue.maxReviewRounds], [before.currentRound, before.maxReviewRounds]);
+    assert.equal(reassignedEvents(issueId).length, 1);
+    assert.deepEqual(JSON.parse(reassignedEvents(issueId)[0].payloadJson), {
+        fromRepo: before.repo,
+        toRepo: before.repo,
+        fromDeveloperAgentId: before.developerAgentId,
+        toDeveloperAgentId: dev.id,
+        fromReviewerAgentId: before.reviewerAgentId,
+        toReviewerAgentId: before.reviewerAgentId,
+    });
+    const revSwap = applyParkedEdit(issueId, { reviewerAgentId: rev.id });
+    assert.equal(revSwap.ok, true);
+    if (revSwap.ok !== true)
+        return;
+    assert.equal(revSwap.issue.reviewerAgentId, rev.id);
+    assert.equal(revSwap.issue.branch, before.branch);
+    assert.deepEqual([revSwap.issue.currentRound, revSwap.issue.maxReviewRounds], [before.currentRound, before.maxReviewRounds]);
+    assert.equal(reassignedEvents(issueId).length, 2);
+    // Both roles in one call: a single event carrying both changes.
+    const both = await parkAtAttemptsExhausted();
+    const bothSwap = applyParkedEdit(both.issueId, { developerAgentId: dev.id, reviewerAgentId: rev.id });
+    assert.equal(bothSwap.ok, true);
+    if (bothSwap.ok !== true)
+        return;
+    assert.equal(bothSwap.issue.developerAgentId, dev.id);
+    assert.equal(bothSwap.issue.reviewerAgentId, rev.id);
+    assert.equal(reassignedEvents(both.issueId).length, 1);
+    // Resume freezes the NEW developer profile into the next round's payload — the
+    // worker loop builds the spawned session's runtime from exactly this snapshot.
+    const resolved = resolveHumanActionAndAdvance(actionId, "yusuke", "retry");
+    assert.equal(resolved.ok, true);
+    const snapshot = pendingSnapshot(issueId, "developer");
+    assert.equal(snapshot.agentId, dev.id);
+    assert.equal(snapshot.runtime, "codex_local");
+    assert.equal(snapshot.role, "developer");
+});
+test("NOT-358: applyParkedEdit rejects unknown agents (400), locked fields, pending items and running sessions (409)", async () => {
+    const { dev } = n358Agents();
+    const { issueId } = await parkAtAttemptsExhausted();
+    const before = getIssue(issueId);
+    const reassignedBefore = reassignedEvents(issueId).length;
+    const unknown = applyParkedEdit(issueId, { developerAgentId: randomUUID() });
+    assert.equal(unknown.ok, false);
+    if (unknown.ok !== false)
+        return;
+    assert.equal(unknown.code, 400);
+    assert.match(unknown.error, /Unknown agent profile/);
+    const unknownRev = applyParkedEdit(issueId, { reviewerAgentId: randomUUID() });
+    assert.equal(unknownRev.ok, false);
+    if (unknownRev.ok !== false)
+        return;
+    assert.equal(unknownRev.code, 400);
+    assert.equal(getIssue(issueId).developerAgentId, before.developerAgentId);
+    assert.equal(getIssue(issueId).reviewerAgentId, before.reviewerAgentId);
+    assert.equal(reassignedEvents(issueId).length, reassignedBefore);
+    for (const patch of [{ repo: "acme/other" }, { maxReviewRounds: 5 }, { autoMerge: true }]) {
+        const blocked = applyParkedEdit(issueId, patch);
+        assert.equal(blocked.ok, false, JSON.stringify(patch));
+        if (blocked.ok !== false)
+            return;
+        assert.equal(blocked.code, 409);
+    }
+    assert.equal(getIssue(issueId).maxReviewRounds, before.maxReviewRounds);
+    // A pending work item blocks the swap; cancelling it re-opens the surface.
+    const instance = getActiveWorkflowInstance(issueId);
+    const item = enqueueWorkItem({
+        issueId,
+        workflowInstanceId: instance.id,
+        kind: "developer",
+        round: 1,
+        payload: {},
+        idempotencyKey: `${instance.id}:test:n358-pending`,
+    });
+    const queued = applyParkedEdit(issueId, { developerAgentId: dev.id });
+    assert.equal(queued.ok, false);
+    if (queued.ok !== false)
+        return;
+    assert.equal(queued.code, 409);
+    cancelWorkItem(item.id);
+    const afterCancel = applyParkedEdit(issueId, { developerAgentId: dev.id });
+    assert.equal(afterCancel.ok, true);
+    // An actively running session blocks the swap even with nothing pending/leased.
+    const session = createWorkerSession({
+        issueId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: "claude_code",
+    });
+    startSession(session.id);
+    const running = applyParkedEdit(issueId, { reviewerAgentId: BUILTIN_AGENT_CLAUDE_ID });
+    assert.equal(running.ok, false);
+    if (running.ok !== false)
+        return;
+    assert.equal(running.code, 409);
+    assert.match(running.error, /running session/);
+    completeSession(session.id, { status: "done" });
+    const afterSession = applyParkedEdit(issueId, { title: "Renamed at park" });
+    assert.equal(afterSession.ok, true);
+});
+test("NOT-358: parkCapWait parks a usage-cap wait for a human; swap + resume continue in the same worktree", async () => {
+    const { dev } = n358Agents();
+    const issueId = newIssue();
+    startWorkflow(issueId);
+    const until = new Date(Date.now() + 300_000).toISOString();
+    const capReason = "claude_code usage capped — five_hour limit rejected";
+    await complete(issueId, { kind: "usage_capped", until, reason: capReason });
+    const wait = capWaitForIssue(issueId);
+    assert.deepEqual(wait, { kind: "usage_capped", until, reason: capReason });
+    // The attempt's session and branch predate the park — both must survive it.
+    const session = createWorkerSession({
+        issueId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: "claude_code",
+    });
+    startSession(session.id);
+    completeSession(session.id, { status: "done", worktreePath: "/tmp/n358-worktree" });
+    const { transitionIssue } = await import("../repository/issues.js");
+    transitionIssue(issueId, "developing", { branch: "dealer/n358-park" });
+    const parked = parkCapWait(issueId, "op");
+    assert.equal(parked.ok, true);
+    if (parked.ok !== true)
+        return;
+    assert.equal(parked.issueStatus, "needs_human");
+    const issue = getIssue(issueId);
+    assert.equal(issue.currentOwner, "human");
+    assert.match(issue.currentIntent ?? "", /five_hour/);
+    assert.match(issue.currentIntent ?? "", new RegExp(until.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+    assert.equal(issue.branch, "dealer/n358-park");
+    assert.deepEqual([issue.currentRound, issue.maxReviewRounds], [1, 3]);
+    const open = listHumanActionsForIssue(issueId).filter((a) => a.status === "open");
+    assert.equal(open.length, 1);
+    assert.equal(open[0].actionType, "policy_escalation");
+    assert.match(open[0].reason, /five_hour/);
+    assert.match(open[0].reason, /wait until/);
+    assert.equal(capWaitForIssue(issueId), null, "the wait is cancelled, not deferred again");
+    assert.deepEqual(listWorkItemsForIssue(issueId).map((i) => i.status), ["cancelled"], "the deferred wait is cancelled");
+    const keptSession = listWorkerSessionsForIssue(issueId).find((s) => s.id === session.id);
+    assert.equal(keptSession.worktreePath, "/tmp/n358-worktree");
+    // Swap while parked, then resume — the next developer round carries the new profile.
+    const swapped = applyParkedEdit(issueId, { developerAgentId: dev.id });
+    assert.equal(swapped.ok, true);
+    const resolved = resolveHumanActionAndAdvance(open[0].id, "op", "resume");
+    assert.equal(resolved.ok, true);
+    if (resolved.ok !== true)
+        return;
+    assert.equal(resolved.issueStatus, "developing");
+    assert.equal(getIssue(issueId).branch, "dealer/n358-park");
+    const snapshot = pendingSnapshot(issueId, "developer");
+    assert.equal(snapshot.agentId, dev.id);
+    assert.equal(snapshot.runtime, "codex_local");
+});
+test("NOT-358: parkCapWait parks a deck-outage wait, and a reviewer wait resumes as reviewer", async () => {
+    const deckId = newIssue();
+    startWorkflow(deckId);
+    await complete(deckId, { kind: "deck_unavailable", reason: "Agent Deck unreachable — connection refused" });
+    assert.equal(capWaitForIssue(deckId)?.kind, "deck_unavailable");
+    const parked = parkCapWait(deckId, "op");
+    assert.equal(parked.ok, true);
+    const open = listHumanActionsForIssue(deckId).filter((a) => a.status === "open");
+    assert.equal(open.length, 1);
+    assert.match(open[0].reason, /Agent Deck outage/);
+    assert.match(open[0].reason, /connection refused/);
+    const resumed = resolveHumanActionAndAdvance(open[0].id, "op", "resume");
+    assert.equal(resumed.ok, true);
+    if (resumed.ok !== true)
+        return;
+    assert.equal(resumed.issueStatus, "developing");
+    // The resume above enqueued a fresh developer item — cancel it so the reviewer flow
+    // below claims its own item (`claim` takes the oldest pending item across issues).
+    for (const item of listWorkItemsForIssue(deckId)) {
+        if (item.status === "pending")
+            cancelWorkItem(item.id);
+    }
+    // A reviewer-role wait tags the continuation so resume re-queues a reviewer at the
+    // pinned head instead of an unrelated developer round.
+    const revId = newIssue();
+    startWorkflow(revId);
+    await complete(revId, cleanHandoff);
+    await complete(revId, { kind: "deck_unavailable", reason: "Agent Deck unreachable — reset by peer" });
+    assert.equal(capWaitForIssue(revId)?.kind, "deck_unavailable");
+    const revParked = parkCapWait(revId, "op");
+    assert.equal(revParked.ok, true);
+    const revOpen = listHumanActionsForIssue(revId).filter((a) => a.status === "open");
+    assert.equal(revOpen.length, 1);
+    const revResumed = resolveHumanActionAndAdvance(revOpen[0].id, "op", "resume");
+    assert.equal(revResumed.ok, true);
+    if (revResumed.ok !== true)
+        return;
+    assert.equal(revResumed.issueStatus, "reviewing");
+    const pending = listWorkItemsForIssue(revId).filter((i) => i.status === "pending");
+    assert.deepEqual(pending.map((i) => i.kind), ["reviewer"]);
+    const payload = JSON.parse(pending[0].payloadJson);
+    assert.equal(payload.inputSha, "abc123");
+});
+test("NOT-358: parkCapWait rejects without a wait, with leased work, or with a running session", async () => {
+    const readyId = newIssue();
+    const noInstance = parkCapWait(readyId, "op");
+    assert.equal(noInstance.ok, false);
+    if (noInstance.ok !== false)
+        return;
+    assert.equal(noInstance.code, 409);
+    const plainId = newIssue();
+    startWorkflow(plainId);
+    const noWait = parkCapWait(plainId, "op");
+    assert.equal(noWait.ok, false);
+    if (noWait.ok !== false)
+        return;
+    assert.equal(noWait.code, 409);
+    assert.match(noWait.error, /usage-cap or deck-outage/);
+    const leased = claim(plainId);
+    const leasedPark = parkCapWait(plainId, "op");
+    assert.equal(leasedPark.ok, false);
+    if (leasedPark.ok !== false)
+        return;
+    assert.equal(leasedPark.code, 409);
+    // The failed park changes nothing: the lease is intact and the issue still develops.
+    assert.equal(getIssue(plainId).status, "developing");
+    assert.equal(getWorkItem(leased.id).status, "leased");
+    const until = new Date(Date.now() + 300_000).toISOString();
+    await applyCompletion(leased.id, leased.leaseToken, {
+        kind: "usage_capped",
+        until,
+        reason: "claude_code usage capped — test",
+    });
+    const running = createWorkerSession({
+        issueId: plainId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: "claude_code",
+    });
+    startSession(running.id);
+    const runningPark = parkCapWait(plainId, "op");
+    assert.equal(runningPark.ok, false);
+    if (runningPark.ok !== false)
+        return;
+    assert.equal(runningPark.code, 409);
+    assert.match(runningPark.error, /running session/);
+    assert.equal(getIssue(plainId).status, "developing");
+    assert.ok(capWaitForIssue(plainId), "the wait survives the rejected park");
+});

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