fix: address linear auto-create review

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: centdix

backend/src/__tests__/linear-auto-create-service.test.ts

@@ -1,10 +1,11 @@
 import { beforeEach, describe, expect, it } from "bun:test";
 import type { CreateLifecycleWorktreeInput } from "../services/lifecycle-service";
-import type { LinearIssue } from "../services/linear-service";
+import type { FetchIssuesResult, LinearIssue } from "../services/linear-service";
 import {
   filterAutoCreateIssues,
   LINEAR_AUTO_CREATE_POLL_INTERVAL_MS,
   resetProcessedIssues,
+  runLinearAutoCreateOnce,
   startLinearAutoCreateMonitor,
   type LinearAutoCreateDependencies,
 } from "../services/linear-auto-create-service";
@@ -45,15 +46,31 @@ function createIssue(overrides: Partial<LinearIssue> = {}): LinearIssue {
   };
 }
 
-async function flushPromises(): Promise<void> {
-  for (let i = 0; i < 5; i += 1) {
-    await Promise.resolve();
-  }
+interface Deferred<T> {
+  promise: Promise<T>;
+  resolve(value: T): void;
+}
+
+function createDeferred<T>(): Deferred<T> {
+  let resolveDeferred: ((value: T) => void) | null = null;
+  const promise = new Promise<T>((resolve) => {
+    resolveDeferred = resolve;
+  });
+
+  return {
+    promise,
+    resolve(value) {
+      if (!resolveDeferred) throw new Error("deferred resolver not initialized");
+      resolveDeferred(value);
+    },
+  };
 }
 
 function createDeps(input: {
   issues?: LinearIssue[];
   existingBranches?: string[];
+  fetchResult?: FetchIssuesResult;
+  onFetch?: (options: { skipCache?: boolean } | undefined) => void;
 } = {}): {
   deps: LinearAutoCreateDependencies;
   created: CreateLifecycleWorktreeInput[];
@@ -90,7 +107,8 @@ function createDeps(input: {
       projectRoot: "/repo",
       fetchIssues: async (options) => {
         fetchOptions.push(options);
-        return {
+        input.onFetch?.(options);
+        return input.fetchResult ?? {
           ok: true,
           data: issues,
         };
@@ -132,53 +150,85 @@ describe("filterAutoCreateIssues", () => {
   });
 });
 
-describe("startLinearAutoCreateMonitor", () => {
+describe("runLinearAutoCreateOnce", () => {
   beforeEach(() => {
     resetProcessedIssues();
   });
 
-  it("uses a 30 second poll interval", async () => {
-    let scheduledInterval: number | null = null;
-    const { deps } = createDeps();
+  it("creates worktrees without requiring dashboard activity", async () => {
+    const issue = createIssue();
+    const { deps, created, fetchOptions } = createDeps({ issues: [issue] });
 
-    const stop = startLinearAutoCreateMonitor(deps, {
-      intervalDeps: {
-        scheduleEvery: (_handler, intervalMs) => {
-          scheduledInterval = intervalMs;
-          return 1;
-        },
-        cancelSchedule: () => {},
+    await runLinearAutoCreateOnce(deps);
+
+    expect(fetchOptions).toEqual([{ skipCache: true }]);
+    expect(created).toEqual([
+      {
+        mode: "new",
+        branch: issue.branchName,
+        prompt: `${issue.title}\n\n${issue.description}`,
+      },
+    ]);
+  });
+
+  it("does not create duplicate worktrees for processed issues", async () => {
+    const issue = createIssue();
+    const { deps, created, fetchOptions } = createDeps({ issues: [issue] });
+
+    await runLinearAutoCreateOnce(deps);
+    await runLinearAutoCreateOnce(deps);
+
+    expect(fetchOptions).toEqual([{ skipCache: true }, { skipCache: true }]);
+    expect(created).toEqual([
+      {
+        mode: "new",
+        branch: issue.branchName,
+        prompt: `${issue.title}\n\n${issue.description}`,
+      },
+    ]);
+  });
+
+  it("does not create worktrees when the Linear fetch fails", async () => {
+    const { deps, created, fetchOptions } = createDeps({
+      fetchResult: {
+        ok: false,
+        error: "Linear API 401: Unauthorized",
       },
     });
 
-    await flushPromises();
-    stop();
+    await runLinearAutoCreateOnce(deps);
 
-    expect(scheduledInterval).toBe(LINEAR_AUTO_CREATE_POLL_INTERVAL_MS);
-    expect(scheduledInterval).toBe(30_000);
+    expect(fetchOptions).toEqual([{ skipCache: true }]);
+    expect(created).toEqual([]);
   });
+});
 
-  it("creates worktrees without requiring dashboard activity", async () => {
-    const issue = createIssue();
-    const { deps, created, fetchOptions } = createDeps({ issues: [issue] });
+describe("startLinearAutoCreateMonitor", () => {
+  beforeEach(() => {
+    resetProcessedIssues();
+  });
+
+  it("uses a 60 second poll interval", async () => {
+    let scheduledInterval = -1;
+    const fetchStarted = createDeferred<void>();
+    const { deps } = createDeps({
+      onFetch: () => fetchStarted.resolve(undefined),
+    });
 
     const stop = startLinearAutoCreateMonitor(deps, {
       intervalDeps: {
-        scheduleEvery: () => 1,
+        scheduleEvery: (_handler, intervalMs) => {
+          scheduledInterval = intervalMs;
+          return 1;
+        },
         cancelSchedule: () => {},
       },
     });
 
-    await flushPromises();
+    await fetchStarted.promise;
     stop();
 
-    expect(fetchOptions).toEqual([{ skipCache: true }]);
-    expect(created).toEqual([
-      {
-        mode: "new",
-        branch: issue.branchName,
-        prompt: `${issue.title}\n\n${issue.description}`,
-      },
-    ]);
+    expect(scheduledInterval).toBe(LINEAR_AUTO_CREATE_POLL_INTERVAL_MS);
+    expect(scheduledInterval).toBe(60_000);
   });
 });

backend/src/services/linear-auto-create-service.ts

@@ -4,7 +4,7 @@ import { branchMatchesIssue, fetchAssignedIssues, type LinearIssue } from "./lin
 import type { CreateLifecycleWorktreeInput } from "./lifecycle-service";
 import type { GitGateway } from "../adapters/git";
 
-export const LINEAR_AUTO_CREATE_POLL_INTERVAL_MS = 30_000;
+export const LINEAR_AUTO_CREATE_POLL_INTERVAL_MS = 60_000;
 
 export interface LinearAutoCreateLifecycleService {
   createWorktree(input: CreateLifecycleWorktreeInput): Promise<{
@@ -20,9 +20,8 @@ export interface LinearAutoCreateDependencies {
   fetchIssues?: typeof fetchAssignedIssues;
 }
 
-export interface LinearAutoCreateMonitorOptions<THandle = ReturnType<typeof setInterval>> {
-  intervalMs?: number;
-  intervalDeps?: SerializedIntervalDependencies<THandle>;
+export interface LinearAutoCreateMonitorOptions {
+  intervalDeps?: SerializedIntervalDependencies<unknown>;
 }
 
 /** Issue IDs for which worktrees have been successfully created.
@@ -44,7 +43,7 @@ export function filterAutoCreateIssues(
   });
 }
 
-async function runAutoCreate(deps: LinearAutoCreateDependencies): Promise<void> {
+export async function runLinearAutoCreateOnce(deps: LinearAutoCreateDependencies): Promise<void> {
   const fetchIssues = deps.fetchIssues ?? fetchAssignedIssues;
   const result = await fetchIssues({ skipCache: true });
   if (!result.ok) {
@@ -85,15 +84,14 @@ async function runAutoCreate(deps: LinearAutoCreateDependencies): Promise<void>
 
 /** Start periodic polling for new Linear Todo issues and auto-create worktrees.
  *  Returns a cleanup function that stops the monitor. */
-export function startLinearAutoCreateMonitor<THandle = ReturnType<typeof setInterval>>(
+export function startLinearAutoCreateMonitor(
   deps: LinearAutoCreateDependencies,
-  options: LinearAutoCreateMonitorOptions<THandle> = {},
+  options: LinearAutoCreateMonitorOptions = {},
 ): () => void {
-  const intervalMs = options.intervalMs ?? LINEAR_AUTO_CREATE_POLL_INTERVAL_MS;
-  log.info(`[linear-auto-create] monitor started (interval: ${intervalMs}ms)`);
-  return startSerializedInterval(
-    () => runAutoCreate(deps),
-    intervalMs,
+  log.info(`[linear-auto-create] monitor started (interval: ${LINEAR_AUTO_CREATE_POLL_INTERVAL_MS}ms)`);
+  return startSerializedInterval<unknown>(
+    () => runLinearAutoCreateOnce(deps),
+    LINEAR_AUTO_CREATE_POLL_INTERVAL_MS,
     options.intervalDeps,
   );
 }