Add Linear issue dropdown to lane creation

Surface a searchable Linear issue picker in the new-lane dialog so users
can attach a Linear issue at lane creation time instead of pasting an
identifier. Adds the supporting Linear browser, CLI plumbing, and doc
updates for the workflow.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: arul28

apps/ade-cli/README.md

@@ -55,11 +55,15 @@ ade auth status
 ade doctor
 ade lanes list --text
 ade lanes create "fix-checkout-flow" --parent main
+ade lanes create "lin-123" --linear-issue-json '{"id":"...","identifier":"LIN-123","title":"...","projectId":"...","projectSlug":"...","teamId":"...","teamKey":"...","stateId":"...","stateName":"Todo","stateType":"unstarted","priority":2,"priorityLabel":"high","labels":[],"assigneeId":null,"assigneeName":null,"createdAt":"...","updatedAt":"..."}'
+ade --role cto linear quick-view --text
+ade --role cto linear search-issues --query "auth" --state-type started,unstarted --first 50
 ade git commit --lane lane-id
 ade git push --lane lane-id
 ade git branches --lane lane-id --text
 ade git user-identity --lane lane-id --text
 ade prs create --lane lane-id --base main --title "Fix checkout flow"
+ade prs create --lane lane-id --base main --close-linear-issue-on-merge
 ade prs list-open --text
 ade prs path-to-merge --pr pr-id --model gpt-5.5 --max-rounds 3 --no-auto-merge
 ade prs path-to-merge --pr pr-id --model gpt-5.5 --conflict-strategy auto --force-finalize conditional

apps/ade-cli/src/adeRpcServer.test.ts

@@ -750,6 +750,13 @@ function createRuntime() {
       createComment: vi.fn(async () => ({ id: "comment-1" })),
       fetchWorkflowStates: vi.fn(async () => [{ id: "state-done", name: "Done" }]),
       updateIssueState: vi.fn(async () => {}),
+      listProjects: vi.fn(async () => [{ id: "proj-1", name: "ADE", slug: "ade", teamName: "ADE", teamKey: "ADE" }]),
+      listUsers: vi.fn(async () => [{ id: "user-1", name: "Arul", displayName: "Arul" }]),
+      listWorkflowStates: vi.fn(async () => [{ id: "state-1", name: "Todo", type: "unstarted", teamId: "team-1", teamKey: "ADE" }]),
+      searchIssues: vi.fn(async (query: any) => ({
+        issues: [{ id: "issue-1", identifier: "ADE-123", title: "Test", _query: query }],
+        pageInfo: { hasNextPage: false, endCursor: null },
+      })),
     } as any,
     linearSyncService: {
       getDashboard: vi.fn(() => ({ enabled: true, running: false, ingressMode: "webhook-first", reconciliationIntervalSec: 60, lastPollAt: null, lastSuccessAt: null, lastError: null, queue: { queued: 1, blocked: 0, failed: 0 }, workflowRuns: { active: 1, waiting: 0 }, recentIssues: [] })),
@@ -1360,6 +1367,55 @@ describe("adeRpcServer", () => {
     );
   });
 
+  it("returns the Linear issue picker data for cto callers", async () => {
+    const { runtime } = createRuntime();
+    const handler = createAdeRpcRequestHandler({ runtime, serverVersion: "test" });
+
+    await initialize(handler, { callerId: "cto-1", role: "cto" });
+    const result = await callTool(handler, "getLinearIssuePickerData", {});
+
+    expect((runtime.linearIssueTracker as any).listProjects).toHaveBeenCalled();
+    expect((runtime.linearIssueTracker as any).listUsers).toHaveBeenCalled();
+    expect((runtime.linearIssueTracker as any).listWorkflowStates).toHaveBeenCalled();
+    expect(result.structuredContent).toEqual(
+      expect.objectContaining({
+        projects: expect.any(Array),
+        users: expect.any(Array),
+        states: expect.any(Array),
+      }),
+    );
+  });
+
+  it("forwards search filters when calling searchLinearIssues", async () => {
+    const { runtime } = createRuntime();
+    const handler = createAdeRpcRequestHandler({ runtime, serverVersion: "test" });
+
+    await initialize(handler, { callerId: "cto-1", role: "cto" });
+    const result = await callTool(handler, "searchLinearIssues", {
+      projectId: "proj-1",
+      stateTypes: ["started", "unstarted"],
+      query: "auth",
+      first: 25,
+      includeArchived: true,
+    });
+
+    expect((runtime.linearIssueTracker as any).searchIssues).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId: "proj-1",
+        stateTypes: ["started", "unstarted"],
+        query: "auth",
+        first: 25,
+        includeArchived: true,
+      }),
+    );
+    expect(result.structuredContent).toEqual(
+      expect.objectContaining({
+        issues: expect.any(Array),
+        pageInfo: expect.objectContaining({ hasNextPage: false }),
+      }),
+    );
+  });
+
   it("forwards employeeOverride and laneId when resuming a Linear sync queue item", async () => {
     const { runtime } = createRuntime();
     const handler = createAdeRpcRequestHandler({ runtime, serverVersion: "test" });

apps/ade-cli/src/adeRpcServer.ts

@@ -1737,6 +1737,31 @@ const CTO_LINEAR_SYNC_TOOL_SPECS: ToolSpec[] = [
     description: "Read a compact Linear workspace, project, and issue quick view through the connected Linear SDK account.",
     inputSchema: { type: "object", additionalProperties: false, properties: {} }
   },
+  {
+    name: "getLinearIssuePickerData",
+    description: "Read the projects, users, and workflow states needed to populate the Linear issue picker for lane creation.",
+    inputSchema: { type: "object", additionalProperties: false, properties: {} }
+  },
+  {
+    name: "searchLinearIssues",
+    description: "Search Linear issues for the lane Linear-issue picker, filtered by project, team, state, assignee, priority, or text query.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        projectId: { anyOf: [{ type: "string" }, { type: "null" }] },
+        projectSlug: { anyOf: [{ type: "string" }, { type: "null" }] },
+        teamKey: { anyOf: [{ type: "string" }, { type: "null" }] },
+        stateTypes: { type: "array", items: { type: "string" } },
+        assigneeId: { anyOf: [{ type: "string" }, { type: "null" }] },
+        priority: { anyOf: [{ type: "number" }, { type: "null" }] },
+        query: { anyOf: [{ type: "string" }, { type: "null" }] },
+        first: { type: "number", minimum: 1, maximum: 200 },
+        after: { anyOf: [{ type: "string" }, { type: "null" }] },
+        includeArchived: { type: "boolean" }
+      }
+    }
+  },
   {
     name: "getLinearSyncDashboard",
     description: "Read the ADE Linear sync dashboard.",
@@ -1961,6 +1986,8 @@ const READ_ONLY_TOOLS = new Set([
   "getChatStatus",
   "readChatTranscript",
   "getLinearQuickView",
+  "getLinearIssuePickerData",
+  "searchLinearIssues",
   "listLinearWorkflows",
   "getLinearRunStatus",
   "getLinearSyncDashboard",
@@ -4352,6 +4379,35 @@ async function runTool(args: {
       }
     }
 
+    if (name === "getLinearIssuePickerData") {
+      const tracker = requireLinearIssueTracker(runtime);
+      const [projects, users, states] = await Promise.all([
+        tracker.listProjects().catch(() => []),
+        tracker.listUsers().catch(() => []),
+        tracker.listWorkflowStates().catch(() => []),
+      ]);
+      return { projects, users, states };
+    }
+
+    if (name === "searchLinearIssues") {
+      const tracker = requireLinearIssueTracker(runtime);
+      const stateTypes = Array.isArray(toolArgs.stateTypes)
+        ? assertStringArray(toolArgs.stateTypes, "stateTypes")
+        : [];
+      return await tracker.searchIssues({
+        projectId: assertOptionalStringOrNull(toolArgs.projectId ?? null, "projectId"),
+        projectSlug: assertOptionalStringOrNull(toolArgs.projectSlug ?? null, "projectSlug"),
+        teamKey: assertOptionalStringOrNull(toolArgs.teamKey ?? null, "teamKey"),
+        stateTypes,
+        assigneeId: assertOptionalStringOrNull(toolArgs.assigneeId ?? null, "assigneeId"),
+        priority: assertOptionalNumberOrNull(toolArgs.priority ?? null, "priority"),
+        query: assertOptionalStringOrNull(toolArgs.query ?? null, "query"),
+        first: typeof toolArgs.first === "number" ? toolArgs.first : 50,
+        after: assertOptionalStringOrNull(toolArgs.after ?? null, "after"),
+        includeArchived: asBoolean(toolArgs.includeArchived, false),
+      });
+    }
+
     if (name === "getLinearSyncDashboard") {
       return requireLinearSyncService(runtime).getDashboard();
     }

apps/ade-cli/src/cli.test.ts

@@ -877,6 +877,48 @@ describe("ADE CLI", () => {
     });
   });
 
+  it("maps Linear picker data to the typed RPC tool", () => {
+    const plan = buildCliPlan(["linear", "picker-data", "--text"]);
+
+    expect(plan.kind).toBe("execute");
+    if (plan.kind !== "execute") return;
+    expect(plan.label).toBe("Linear picker data");
+    expect(plan.steps[0]?.params).toEqual({
+      name: "getLinearIssuePickerData",
+      arguments: {},
+    });
+  });
+
+  it("maps Linear search-issues filters to the typed RPC tool", () => {
+    const plan = buildCliPlan([
+      "linear",
+      "search-issues",
+      "--project-id",
+      "proj-1",
+      "--state-type",
+      "started,unstarted",
+      "--query",
+      "auth",
+      "--first",
+      "25",
+      "--include-archived",
+    ]);
+
+    expect(plan.kind).toBe("execute");
+    if (plan.kind !== "execute") return;
+    expect(plan.label).toBe("Linear search issues");
+    expect(plan.steps[0]?.params).toEqual({
+      name: "searchLinearIssues",
+      arguments: {
+        projectId: "proj-1",
+        stateTypes: ["started", "unstarted"],
+        query: "auth",
+        first: 25,
+        includeArchived: true,
+      },
+    });
+  });
+
   it("shows focused ios-sim help for subcommand help flags", () => {
     const renderHelp = buildCliPlan(["ios-sim", "preview-render", "--help"]);
     expect(renderHelp.kind).toBe("help");

apps/ade-cli/src/cli.ts

@@ -681,6 +681,7 @@ const HELP_BY_COMMAND: Record<string, string> = {
     $ ade lanes show <lane> --text                  Inspect one lane status
     $ ade lanes create --name <name>                Create a lane from the current project context
     $ ade lanes create --linear-issue-json '{...}'  Create a lane linked to a Linear issue
+    $ ade lanes create --branch-name <branch>       Override the auto-generated branch name
     $ ade lanes child --lane <parent> --name <name> Create a child lane under a parent
     $ ade lanes import --branch <branch>            Register an existing branch/worktree
     $ ade lanes archive <lane>                      Archive a lane in ADE
@@ -1006,6 +1007,9 @@ const HELP_BY_COMMAND: Record<string, string> = {
   Linear workflows
 
     $ ade --role cto linear quick-view --text      Show connected workspace, projects, and issues
+    $ ade --role cto linear picker-data --text     Read projects/users/states for the issue picker
+    $ ade --role cto linear search-issues --query "auth" --state-type started,unstarted --first 50
+                                                    Search issues for the lane Linear-issue picker
     $ ade linear workflows --text                   List configured workflows
     $ ade linear sync dashboard --text              Show sync dashboard
     $ ade linear sync run                           Trigger a sync run
@@ -3186,6 +3190,29 @@ function buildLinearPlan(args: string[]): CliPlan {
   if (sub === "quick-view" || sub === "quick" || sub === "overview") {
     return { kind: "execute", label: "Linear quick view", formatter: "linear-quick-view", steps: [actionCallStep("result", "getLinearQuickView", collectGenericObjectArgs(args))] };
   }
+  if (sub === "picker-data" || sub === "picker") {
+    return { kind: "execute", label: "Linear picker data", steps: [actionCallStep("result", "getLinearIssuePickerData", collectGenericObjectArgs(args))] };
+  }
+  if (sub === "search-issues" || sub === "search") {
+    const stateTypesValue = readValue(args, ["--state-type", "--state-types", "--state"]);
+    const stateTypes = stateTypesValue
+      ? stateTypesValue.split(",").map((entry) => entry.trim()).filter(Boolean)
+      : [];
+    const input: JsonObject = {};
+    maybePut(input, "projectId", readValue(args, ["--project-id"]));
+    maybePut(input, "projectSlug", readValue(args, ["--project-slug", "--project"]));
+    maybePut(input, "teamKey", readValue(args, ["--team-key", "--team"]));
+    if (stateTypes.length) input.stateTypes = stateTypes;
+    maybePut(input, "assigneeId", readValue(args, ["--assignee", "--assignee-id"]));
+    const priority = readNumberOption(args, ["--priority"]);
+    if (priority !== undefined) input.priority = priority;
+    maybePut(input, "query", readValue(args, ["--query", "-q"]));
+    const first = readNumberOption(args, ["--first", "--limit"]);
+    if (first !== undefined) input.first = first;
+    maybePut(input, "after", readValue(args, ["--after", "--cursor"]));
+    if (readFlag(args, ["--include-archived"])) input.includeArchived = true;
+    return { kind: "execute", label: "Linear search issues", steps: [actionCallStep("result", "searchLinearIssues", collectGenericObjectArgs(args, input))] };
+  }
   if (sub === "workflows") return { kind: "execute", label: "Linear workflows", steps: [actionCallStep("result", "listLinearWorkflows", collectGenericObjectArgs(args))] };
   if (sub === "run") {
     const mode = firstPositional(args) ?? "status";

apps/desktop/src/main/services/cto/issueTracker.ts

@@ -66,6 +66,10 @@ export type IssueTracker = {
     connected: boolean;
     viewerId: string | null;
     viewerName: string | null;
+    organizationId?: string | null;
+    organizationName?: string | null;
+    organizationUrlKey?: string | null;
+    organizationLogoUrl?: string | null;
     message: string | null;
   }>;
 };

apps/desktop/src/main/services/cto/linearAuth.test.ts

@@ -371,22 +371,37 @@ describe("linearOAuthService", () => {
     expect(session.error).toContain("User declined");
   });
 
-  it("handles OAuth callback with state mismatch", async () => {
+  it("rejects stale OAuth callbacks without failing the active session", async () => {
     const credentials = createCredentialsMock();
+    const mockFetch = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({ access_token: "linear-access-token-123" }),
+    })) as any;
     const service = createLinearOAuthService({
       credentials: credentials as any,
       logger: createLogger(),
+      fetchImpl: mockFetch,
     });
     activeServices.push(service);
 
-    const { sessionId, redirectUri } = await service.startSession();
+    const { sessionId, authUrl, redirectUri } = await service.startSession();
+    const stateParam = new URL(authUrl).searchParams.get("state")!;
+
+    const staleCallbackUrl = `${redirectUri}?code=stale-code&state=wrong-state`;
+    const staleResponse = await httpGet(staleCallbackUrl);
+
+    expect(staleResponse.statusCode).toBe(400);
+    expect(service.getSession(sessionId).status).toBe("pending");
+    expect(credentials.setOAuthToken).not.toHaveBeenCalled();
 
-    const callbackUrl = `${redirectUri}?code=test-code&state=wrong-state`;
+    const callbackUrl = `${redirectUri}?code=test-code&state=${stateParam}`;
     await httpGet(callbackUrl);
 
-    await waitForSessionStatus(service, sessionId, "failed");
-    const session = service.getSession(sessionId);
-    expect(session.error).toContain("state did not match");
+    await waitForSessionStatus(service, sessionId, "completed");
+    expect(credentials.setOAuthToken).toHaveBeenCalledWith(expect.objectContaining({
+      accessToken: "linear-access-token-123",
+    }));
   });
 
   it("handles OAuth callback without authorization code", async () => {
@@ -623,6 +638,44 @@ describe("linearClient", () => {
     expect(fetchImpl).toHaveBeenCalledTimes(2);
   });
 
+  it("loads connection identity with the authorized Linear workspace", async () => {
+    const fetchImpl = vi.fn(async (_url: string, init?: RequestInit) => {
+      expect(init?.headers).toMatchObject({ authorization: "Bearer test-token" });
+      return new Response(
+        JSON.stringify({
+          data: {
+            viewer: { id: "viewer-1", displayName: "Alex" },
+            organization: {
+              id: "org-1",
+              name: "Acme Workspace",
+              urlKey: "acme",
+              logoUrl: "https://linear.app/acme/logo.png",
+            },
+          },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } }
+      );
+    });
+
+    const client = createLinearClient({
+      credentials: {
+        getTokenOrThrow: () => "Bearer test-token",
+        getStatus: () => ({ authMode: "oauth" }),
+      } as any,
+      fetchImpl: fetchImpl as any,
+      logger: null,
+    });
+
+    await expect(client.getConnectionIdentity()).resolves.toEqual({
+      viewerId: "viewer-1",
+      viewerName: "Alex",
+      organizationId: "org-1",
+      organizationName: "Acme Workspace",
+      organizationUrlKey: "acme",
+      organizationLogoUrl: "https://linear.app/acme/logo.png",
+    });
+  });
+
   it("lists projects with their owning team names", async () => {
     const fetchImpl = vi.fn(async (_url: string, init?: RequestInit) => {
       const body = JSON.parse(String(init?.body ?? "{}")) as { query?: string };