@aaronshaf/ger 0.2.5 → 0.3.2

package/README.md

@@ -59,6 +59,10 @@ ger extract-url "build-summary-report" | tail -1
 ger build-status 12345  # Returns: pending, running, success, failure, or not_found
 ger build-status        # Auto-detects from HEAD commit
 
+# Watch build status until completion (like gh run watch)
+ger build-status 12345 --watch
+ger build-status --watch --exit-status && deploy.sh
+
 # AI-powered code review (requires claude, llm, or opencode CLI)
 ger review 12345
 ger review 12345 --dry-run  # Preview without posting
@@ -257,21 +261,48 @@ ger extract-url "job/[^/]+/job/[^/]+/\d+/$" --regex
 
 Check the CI build status of a change by parsing Gerrit messages for build events and verification results:
 
+#### Single Check (Snapshot)
 ```bash
 # Check build status for a specific change
 ger build-status 12345
+# Output: {"state":"success"}
 
 # Auto-detect change from HEAD commit
 ger build-status
 
 # Use in scripts with jq
 ger build-status | jq -r '.state'
+```
+
+#### Watch Mode (Poll Until Completion)
+Like `gh run watch`, you can poll the build status until it reaches a terminal state:
+
+```bash
+# Watch until completion (outputs JSON on each poll)
+ger build-status 12345 --watch
+# Output:
+# {"state":"pending"}
+# {"state":"running"}
+# {"state":"running"}
+# {"state":"success"}
+
+# Auto-detect from HEAD commit
+ger build-status --watch
 
-# Wait for build completion in CI scripts
-while [ "$(ger build-status | jq -r '.state')" = "running" ]; do
-  echo "Waiting for build..."
-  sleep 30
-done
+# Custom polling interval (check every 5 seconds, default: 10)
+ger build-status --watch --interval 5
+
+# Custom timeout (60 minutes, default: 30 minutes)
+ger build-status --watch --timeout 3600
+
+# Exit with code 1 on build failure (for CI/CD pipelines)
+ger build-status --watch --exit-status && deploy.sh
+
+# Trigger notification when done (like gh run watch pattern)
+ger build-status --watch && notify-send 'Build is done!'
+
+# Extract final state in scripts
+ger build-status --watch | tail -1 | jq -r '.state'
 ```
 
 #### Output format (JSON):
@@ -286,17 +317,24 @@ done
 - **`failure`**: Verified -1 after most recent "Build Started"
 - **`not_found`**: Change does not exist
 
+#### Exit codes:
+- **`0`**: Default for all states (like `gh run watch`)
+- **`1`**: Only when `--exit-status` flag is used AND build fails
+- **`2`**: Timeout reached in watch mode
+- **`3`**: API/network errors
+
 #### How it works:
 1. Fetches all messages for the change
 2. Finds the most recent "Build Started" message
 3. Checks for "Verified +1" or "Verified -1" messages after the build started
 4. Returns the appropriate state
+5. In watch mode: polls every N seconds until terminal state or timeout
 
 #### Use cases:
 - **CI/CD integration**: Wait for builds before proceeding with deployment
 - **Automation**: Trigger actions based on build results
 - **Scripting**: Check build status in shell scripts
-- **Monitoring**: Poll build status for long-running builds
+- **Monitoring**: Poll build status for long-running builds with watch mode
 
 ### Diff
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaronshaf/ger",
-  "version": "0.2.5",
+  "version": "0.3.2",
   "description": "Gerrit CLI and SDK - A modern CLI tool and TypeScript SDK for Gerrit Code Review, built with Effect-TS",
   "keywords": [
     "gerrit",

package/src/cli/commands/build-status.ts

@@ -6,6 +6,23 @@ import { getChangeIdFromHead, GitError, NoChangeIdError } from '@/utils/git-comm
 // Export types for external use
 export type BuildState = 'pending' | 'running' | 'success' | 'failure' | 'not_found'
 
+// Watch options (matches gh run watch pattern)
+export type WatchOptions = {
+  readonly watch: boolean
+  readonly interval: number // seconds
+  readonly timeout: number // seconds
+  readonly exitStatus: boolean
+}
+
+// Timeout error for watch mode
+export class TimeoutError extends Error {
+  readonly _tag = 'TimeoutError'
+  constructor(message: string) {
+    super(message)
+    this.name = 'TimeoutError'
+  }
+}
+
 // Effect Schema for BuildStatus (follows project patterns)
 export const BuildStatus: Schema.Schema<{
   readonly state: 'pending' | 'running' | 'success' | 'failure' | 'not_found'
@@ -20,7 +37,8 @@ const VERIFIED_PLUS_PATTERN = /Verified\s*[+]\s*1/
 const VERIFIED_MINUS_PATTERN = /Verified\s*[-]\s*1/
 
 /**
- * Parse messages to determine build status based on "Build Started" and verification messages
+ * Parse messages to determine build status based on "Build Started" and verification messages.
+ * Only considers verification messages for the same patchset as the latest build.
  */
 const parseBuildStatus = (messages: readonly MessageInfo[]): BuildStatus => {
   // Empty messages means change exists but has no activity yet - return pending
@@ -28,11 +46,13 @@ const parseBuildStatus = (messages: readonly MessageInfo[]): BuildStatus => {
     return { state: 'pending' }
   }
 
-  // Find the most recent "Build Started" message
+  // Find the most recent "Build Started" message and its revision number
   let lastBuildDate: string | null = null
+  let lastBuildRevision: number | undefined = undefined
   for (const msg of messages) {
     if (BUILD_STARTED_PATTERN.test(msg.message)) {
       lastBuildDate = msg.date
+      lastBuildRevision = msg._revision_number
     }
   }
 
@@ -41,12 +61,18 @@ const parseBuildStatus = (messages: readonly MessageInfo[]): BuildStatus => {
     return { state: 'pending' }
   }
 
-  // Check for verification messages after the build started
+  // Check for verification messages after the build started AND for the same revision
   for (const msg of messages) {
     const date = msg.date
     // Gerrit timestamps are ISO 8601 strings (lexicographically sortable)
     if (date <= lastBuildDate) continue
 
+    // Only consider verification messages for the same patchset
+    // If revision numbers are available, they must match
+    if (lastBuildRevision !== undefined && msg._revision_number !== undefined) {
+      if (msg._revision_number !== lastBuildRevision) continue
+    }
+
     if (VERIFIED_PLUS_PATTERN.test(msg.message)) {
       return { state: 'success' }
     } else if (VERIFIED_MINUS_PATTERN.test(msg.message)) {
@@ -71,38 +97,129 @@ const getMessagesForChange = (
   })
 
 /**
- * Build status command - determines build status from Gerrit messages
+ * Poll build status until terminal state or timeout
+ * Outputs JSON status on each iteration (mimics gh run watch)
+ */
+const pollBuildStatus = (
+  changeId: string,
+  options: WatchOptions,
+): Effect.Effect<BuildStatus, ApiError | TimeoutError, GerritApiService> =>
+  Effect.gen(function* () {
+    const startTime = Date.now()
+    const timeoutMs = options.timeout * 1000
+
+    while (true) {
+      // Check timeout
+      const elapsed = Date.now() - startTime
+      if (elapsed > timeoutMs) {
+        yield* Effect.sync(() => {
+          console.error(`Timeout: Build status check exceeded ${options.timeout}s`)
+        })
+        yield* Effect.fail(
+          new TimeoutError(`Build status check timed out after ${options.timeout}s`),
+        )
+      }
+
+      // Fetch and parse status
+      const messages = yield* getMessagesForChange(changeId)
+      const status = parseBuildStatus(messages)
+
+      // Check timeout again after API call (in case it took longer than expected)
+      const elapsedAfterFetch = Date.now() - startTime
+      if (elapsedAfterFetch > timeoutMs) {
+        yield* Effect.sync(() => {
+          console.error(`Timeout: Build status check exceeded ${options.timeout}s`)
+        })
+        yield* Effect.fail(
+          new TimeoutError(`Build status check timed out after ${options.timeout}s`),
+        )
+      }
+
+      // Output current status to stdout (JSON, like single-check mode)
+      yield* Effect.sync(() => {
+        process.stdout.write(JSON.stringify(status) + '\n')
+      })
+
+      // Terminal states - wait for interval before returning to allow logs to be written
+      if (status.state === 'success' || status.state === 'not_found') {
+        return status
+      }
+
+      if (status.state === 'failure') {
+        // Wait for interval seconds to allow build failure logs to be fully written
+        yield* Effect.sleep(options.interval * 1000)
+        return status
+      }
+
+      // Non-terminal states - sleep for interval duration
+      yield* Effect.sleep(options.interval * 1000)
+    }
+  })
+
+/**
+ * Build status command with optional watch mode (mimics gh run watch)
  */
 export const buildStatusCommand = (
   changeId: string | undefined,
-): Effect.Effect<void, ApiError | Error | GitError | NoChangeIdError, GerritApiService> =>
+  options: Partial<WatchOptions> = {},
+): Effect.Effect<
+  void,
+  ApiError | Error | GitError | NoChangeIdError | TimeoutError,
+  GerritApiService
+> =>
   Effect.gen(function* () {
     // Auto-detect Change-ID from HEAD commit if not provided
     const resolvedChangeId = changeId || (yield* getChangeIdFromHead())
 
-    // Fetch messages
-    const messages = yield* getMessagesForChange(resolvedChangeId)
+    // Set defaults (matching gh run watch patterns)
+    const watchOpts: WatchOptions = {
+      watch: options.watch ?? false,
+      interval: Math.max(1, options.interval ?? 10), // Min 1 second
+      timeout: Math.max(1, options.timeout ?? 1800), // Min 1 second, default 30 minutes
+      exitStatus: options.exitStatus ?? false,
+    }
+
+    let status: BuildStatus
 
-    // Parse build status
-    const status = parseBuildStatus(messages)
+    if (watchOpts.watch) {
+      // Polling mode - outputs JSON on each iteration
+      status = yield* pollBuildStatus(resolvedChangeId, watchOpts)
+    } else {
+      // Single check mode (existing behavior)
+      const messages = yield* getMessagesForChange(resolvedChangeId)
+      status = parseBuildStatus(messages)
 
-    // Output JSON to stdout
-    const jsonOutput = JSON.stringify(status) + '\n'
-    yield* Effect.sync(() => {
-      process.stdout.write(jsonOutput)
-    })
+      // Output JSON to stdout
+      yield* Effect.sync(() => {
+        process.stdout.write(JSON.stringify(status) + '\n')
+      })
+    }
+
+    // Handle exit codes (only non-zero when explicitly requested)
+    if (watchOpts.exitStatus && status.state === 'failure') {
+      yield* Effect.sync(() => process.exit(1))
+    }
+
+    // Default: exit 0 for all states (success, failure, pending, etc.)
   }).pipe(
-    // Error handling - return not_found for API errors (e.g., change not found)
     Effect.catchAll((error) => {
+      // Timeout error
+      if (error instanceof TimeoutError) {
+        return Effect.sync(() => {
+          console.error(`Error: ${error.message}`)
+          process.exit(2)
+        })
+      }
+
+      // 404 - change not found
       if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
-        // Change not found - output not_found state and exit successfully
         const status: BuildStatus = { state: 'not_found' }
         return Effect.sync(() => {
           process.stdout.write(JSON.stringify(status) + '\n')
         })
       }
 
-      // For other errors, write to stderr and exit with error
+      // Other errors - exit 3
       const errorMessage =
         error instanceof GitError || error instanceof NoChangeIdError || error instanceof Error
           ? error.message
@@ -110,7 +227,7 @@ export const buildStatusCommand = (
 
       return Effect.sync(() => {
         console.error(`Error: ${errorMessage}`)
-        process.exit(1)
+        process.exit(3)
       })
     }),
   )

package/src/cli/index.ts

@@ -426,6 +426,10 @@ program
   .description(
     'Check build status from Gerrit messages (auto-detects from HEAD commit if not specified)',
   )
+  .option('--watch', 'Watch build status until completion (mimics gh run watch)')
+  .option('-i, --interval <seconds>', 'Refresh interval in seconds (default: 10)', '10')
+  .option('--timeout <seconds>', 'Maximum wait time in seconds (default: 1800 / 30min)', '1800')
+  .option('--exit-status', 'Exit with non-zero status if build fails')
   .addHelpText(
     'after',
     `
@@ -439,40 +443,58 @@ Output is JSON with a "state" field that can be:
   - failure: Build completed with Verified-1
   - not_found: Change does not exist
 
+Exit codes:
+  - 0: Default for all states (like gh run watch)
+  - 1: Only when --exit-status is used AND build fails
+  - 2: Timeout reached in watch mode
+  - 3: API/network errors
+
 Examples:
-  # Check build status for specific change (using change number)
+  # Single check (current behavior)
   $ ger build-status 392385
   {"state":"success"}
 
-  # Check build status for specific change (using Change-ID)
-  $ ger build-status If5a3ae8cb5a107e187447802358417f311d0c4b1
+  # Watch until completion (outputs JSON on each poll)
+  $ ger build-status 392385 --watch
+  {"state":"pending"}
+  {"state":"running"}
   {"state":"running"}
+  {"state":"success"}
 
-  # Auto-detect from HEAD commit
-  $ ger build-status
-  {"state":"pending"}
+  # Watch with custom interval (check every 5 seconds)
+  $ ger build-status --watch --interval 5
+
+  # Watch with custom timeout (60 minutes)
+  $ ger build-status --watch --timeout 3600
 
-  # Use in scripts (exit code 0 on success, 1 on error)
-  $ if ger build-status | jq -e '.state == "success"' > /dev/null; then
-      echo "Build passed!"
-    fi
+  # Exit with code 1 on failure (for CI/CD pipelines)
+  $ ger build-status --watch --exit-status && deploy.sh
+
+  # Trigger notification when done (like gh run watch pattern)
+  $ ger build-status --watch && notify-send 'Build is done!'
+
+  # Parse final state in scripts
+  $ ger build-status --watch | tail -1 | jq -r '.state'
+  success
 
 Note: When no change-id is provided, it will be automatically extracted from the
       Change-ID footer in your HEAD commit.`,
   )
-  .action(async (changeId) => {
+  .action(async (changeId, cmdOptions) => {
     try {
-      const effect = buildStatusCommand(changeId).pipe(
-        Effect.provide(GerritApiServiceLive),
-        Effect.provide(ConfigServiceLive),
-      )
+      const effect = buildStatusCommand(changeId, {
+        watch: cmdOptions.watch,
+        interval: Number.parseInt(cmdOptions.interval, 10),
+        timeout: Number.parseInt(cmdOptions.timeout, 10),
+        exitStatus: cmdOptions.exitStatus,
+      }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(ConfigServiceLive))
       await Effect.runPromise(effect)
     } catch (error) {
       // Errors are handled within the command itself
       // This catch is just for any unexpected errors
       if (error instanceof Error && error.message !== 'Process exited') {
         console.error('✗ Unexpected error:', error.message)
-        process.exit(1)
+        process.exit(3)
       }
     }
   })

package/tests/build-status-watch.test.ts

@@ -0,0 +1,344 @@
+import { describe, test, expect, beforeAll, afterAll, afterEach } from 'bun:test'
+import { http, HttpResponse } from 'msw'
+import { Effect } from 'effect'
+import { buildStatusCommand } from '@/cli/commands/build-status'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import type { MessageInfo } from '@/schemas/gerrit'
+import {
+  server,
+  capturedStdout,
+  capturedErrors,
+  mockProcessExit,
+  setupBuildStatusTests,
+  teardownBuildStatusTests,
+  resetBuildStatusMocks,
+  createMockConfigLayer,
+} from './helpers/build-status-test-setup'
+
+beforeAll(() => {
+  setupBuildStatusTests()
+})
+
+afterAll(() => {
+  teardownBuildStatusTests()
+})
+
+afterEach(() => {
+  resetBuildStatusMocks()
+})
+
+describe('build-status command - watch mode', () => {
+  test('polls until success state is reached', async () => {
+    let callCount = 0
+
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          callCount++
+
+          let messages: MessageInfo[]
+          if (callCount === 1) {
+            // First call: pending (no build started)
+            messages = []
+          } else if (callCount === 2) {
+            // Second call: running (build started, no verification)
+            messages = [
+              {
+                id: 'msg1',
+                message: 'Build Started',
+                date: '2024-01-15 10:00:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+            ]
+          } else {
+            // Third call: success (verified +1)
+            messages = [
+              {
+                id: 'msg1',
+                message: 'Build Started',
+                date: '2024-01-15 10:00:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+              {
+                id: 'msg2',
+                message: 'Patch Set 1: Verified+1',
+                date: '2024-01-15 10:05:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+            ]
+          }
+
+          return HttpResponse.json(
+            { messages },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1, // Fast polling for tests
+      timeout: 10,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    // Should have multiple outputs (one per poll)
+    expect(capturedStdout.length).toBeGreaterThanOrEqual(3)
+    expect(JSON.parse(capturedStdout[0])).toEqual({ state: 'pending' })
+    expect(JSON.parse(capturedStdout[1])).toEqual({ state: 'running' })
+    expect(JSON.parse(capturedStdout[2])).toEqual({ state: 'success' })
+
+    // Minimalistic output: no stderr messages except on timeout/error
+    expect(capturedErrors.length).toBe(0)
+  })
+
+  test('polls until failure state is reached', async () => {
+    let callCount = 0
+
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          callCount++
+
+          let messages: MessageInfo[]
+          if (callCount === 1) {
+            messages = [
+              {
+                id: 'msg1',
+                message: 'Build Started',
+                date: '2024-01-15 10:00:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+            ]
+          } else {
+            messages = [
+              {
+                id: 'msg1',
+                message: 'Build Started',
+                date: '2024-01-15 10:00:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+              {
+                id: 'msg2',
+                message: 'Patch Set 1: Verified-1',
+                date: '2024-01-15 10:05:00.000000000',
+                author: { _account_id: 9999, name: 'CI Bot' },
+              },
+            ]
+          }
+
+          return HttpResponse.json(
+            { messages },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1,
+      timeout: 10,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    expect(capturedStdout.length).toBeGreaterThanOrEqual(2)
+    expect(JSON.parse(capturedStdout[capturedStdout.length - 1])).toEqual({ state: 'failure' })
+
+    // Minimalistic output: no stderr messages except on timeout/error
+    expect(capturedErrors.length).toBe(0)
+  })
+
+  test('times out after specified duration', async () => {
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          // Always return running state
+          return HttpResponse.json(
+            {
+              messages: [
+                {
+                  id: 'msg1',
+                  message: 'Build Started',
+                  date: '2024-01-15 10:00:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+              ],
+            },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1,
+      timeout: 0.5, // Very short timeout
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    try {
+      await Effect.runPromise(effect)
+    } catch {
+      // Should exit with code 2 for timeout
+      expect(mockProcessExit).toHaveBeenCalledWith(2)
+      expect(capturedErrors.some((e: string) => e.includes('Timeout'))).toBe(true)
+    }
+  })
+
+  test('exit-status flag causes exit 1 on failure', async () => {
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            {
+              messages: [
+                {
+                  id: 'msg1',
+                  message: 'Build Started',
+                  date: '2024-01-15 10:00:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+                {
+                  id: 'msg2',
+                  message: 'Patch Set 1: Verified-1',
+                  date: '2024-01-15 10:05:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+              ],
+            },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1,
+      timeout: 10,
+      exitStatus: true,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    try {
+      await Effect.runPromise(effect)
+    } catch {
+      // Should exit with code 1 for failure when --exit-status is used
+      expect(mockProcessExit).toHaveBeenCalledWith(1)
+    }
+  })
+
+  test('exit-status flag does not affect success state', async () => {
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            {
+              messages: [
+                {
+                  id: 'msg1',
+                  message: 'Build Started',
+                  date: '2024-01-15 10:00:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+                {
+                  id: 'msg2',
+                  message: 'Patch Set 1: Verified+1',
+                  date: '2024-01-15 10:05:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+              ],
+            },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: true,
+      interval: 0.1,
+      timeout: 10,
+      exitStatus: true,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    // Should not call process.exit for success state
+    expect(mockProcessExit).not.toHaveBeenCalled()
+    expect(JSON.parse(capturedStdout[0])).toEqual({ state: 'success' })
+  })
+
+  test('watch mode handles not_found state', async () => {
+    server.use(
+      http.get('*/a/changes/99999', () => {
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('99999', {
+      watch: true,
+      interval: 0.1,
+      timeout: 10,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    expect(capturedStdout.length).toBe(1)
+    expect(JSON.parse(capturedStdout[0])).toEqual({ state: 'not_found' })
+
+    // 404 errors bypass pollBuildStatus and are handled in error handler
+    // Minimalistic output: no stderr messages for not_found state
+    expect(capturedErrors.length).toBe(0)
+  })
+
+  test('without watch flag, behaves as single check', async () => {
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            {
+              messages: [
+                {
+                  id: 'msg1',
+                  message: 'Build Started',
+                  date: '2024-01-15 10:00:00.000000000',
+                  author: { _account_id: 9999, name: 'CI Bot' },
+                },
+              ],
+            },
+            { headers: { 'Content-Type': 'application/json' } },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345', {
+      watch: false,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(createMockConfigLayer()))
+
+    await Effect.runPromise(effect)
+
+    // Should only have one output (no polling)
+    expect(capturedStdout.length).toBe(1)
+    expect(JSON.parse(capturedStdout[0])).toEqual({ state: 'running' })
+
+    // Should not have watch mode messages in stderr
+    expect(capturedErrors.some((e: string) => e.includes('Watching build status'))).toBe(false)
+  })
+})

package/tests/build-status.test.ts

@@ -1,84 +1,33 @@
-import { describe, test, expect, beforeAll, afterAll, afterEach, mock } from 'bun:test'
-import { setupServer } from 'msw/node'
+import { describe, test, expect, beforeAll, afterAll, afterEach } from 'bun:test'
 import { http, HttpResponse } from 'msw'
-import { Effect, Layer } from 'effect'
+import { Effect } from 'effect'
 import { buildStatusCommand } from '@/cli/commands/build-status'
 import { GerritApiServiceLive } from '@/api/gerrit'
-import { ConfigService } from '@/services/config'
 import type { MessageInfo } from '@/schemas/gerrit'
-import { createMockConfigService } from './helpers/config-mock'
-
-const server = setupServer(
-  // Default handler for auth check
-  http.get('*/a/accounts/self', ({ request }) => {
-    const auth = request.headers.get('Authorization')
-    if (!auth || !auth.startsWith('Basic ')) {
-      return HttpResponse.text('Unauthorized', { status: 401 })
-    }
-    return HttpResponse.json({
-      _account_id: 1000,
-      name: 'Test User',
-      email: 'test@example.com',
-    })
-  }),
-)
-
-// Store captured output
-let capturedStdout: string[] = []
-let capturedErrors: string[] = []
-
-// Mock process.stdout.write to capture JSON output
-const mockStdoutWrite = mock((chunk: any) => {
-  capturedStdout.push(String(chunk))
-  return true
-})
-
-// Mock console.error to capture errors
-const mockConsoleError = mock((...args: any[]) => {
-  capturedErrors.push(args.join(' '))
-})
-
-// Mock process.exit to prevent test termination
-const mockProcessExit = mock((_code?: number) => {
-  throw new Error('Process exited')
-})
-
-// Store original methods
-const originalStdoutWrite = process.stdout.write
-const originalConsoleError = console.error
-const originalProcessExit = process.exit
+import {
+  server,
+  capturedStdout,
+  capturedErrors,
+  mockProcessExit,
+  setupBuildStatusTests,
+  teardownBuildStatusTests,
+  resetBuildStatusMocks,
+  createMockConfigLayer,
+} from './helpers/build-status-test-setup'
 
 beforeAll(() => {
-  server.listen({ onUnhandledRequest: 'bypass' })
-  // @ts-ignore - Mocking stdout
-  process.stdout.write = mockStdoutWrite
-  // @ts-ignore - Mocking console
-  console.error = mockConsoleError
-  // @ts-ignore - Mocking process.exit
-  process.exit = mockProcessExit
+  setupBuildStatusTests()
 })
 
 afterAll(() => {
-  server.close()
-  // @ts-ignore - Restoring stdout
-  process.stdout.write = originalStdoutWrite
-  console.error = originalConsoleError
-  // @ts-ignore - Restoring process.exit
-  process.exit = originalProcessExit
+  teardownBuildStatusTests()
 })
 
 afterEach(() => {
-  server.resetHandlers()
-  mockStdoutWrite.mockClear()
-  mockConsoleError.mockClear()
-  mockProcessExit.mockClear()
-  capturedStdout = []
-  capturedErrors = []
+  resetBuildStatusMocks()
 })
 
 describe('build-status command', () => {
-  const createMockConfigLayer = () => Layer.succeed(ConfigService, createMockConfigService())
-
   test('returns pending when no Build Started message found', async () => {
     const messages: MessageInfo[] = [
       {
@@ -590,9 +539,9 @@ describe('build-status command', () => {
 
     try {
       await Effect.runPromise(effect)
-    } catch (_error) {
-      // Should throw error and call process.exit
-      expect(mockProcessExit).toHaveBeenCalledWith(1)
+    } catch {
+      // Should throw error and call process.exit with code 3 for API errors
+      expect(mockProcessExit).toHaveBeenCalledWith(3)
       expect(capturedErrors.length).toBeGreaterThan(0)
     }
   })
@@ -688,4 +637,153 @@ describe('build-status command', () => {
     // Regex should handle extra whitespace
     expect(output).toEqual({ state: 'running' })
   })
+
+  test('ignores verification from older patchset when newer patchset build is running', async () => {
+    // This test replicates the bug scenario:
+    // - PS 3 build started, then PS 4 build started
+    // - PS 3 verification (-1) comes AFTER PS 4 build started
+    // - Should return "running" because PS 4 has no verification yet
+    const messages: MessageInfo[] = [
+      {
+        id: 'msg1',
+        message: 'Build Started https://jenkins.example.com/job/123/',
+        date: '2024-01-15 11:12:00.000000000',
+        _revision_number: 2,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+      {
+        id: 'msg2',
+        message: 'Patch Set 2: Verified -1\n\nBuild Failed',
+        date: '2024-01-15 11:23:00.000000000',
+        _revision_number: 2,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+      {
+        id: 'msg3',
+        message: 'Build Started https://jenkins.example.com/job/456/',
+        date: '2024-01-15 13:57:00.000000000',
+        _revision_number: 3,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+      {
+        id: 'msg4',
+        message: 'Build Started https://jenkins.example.com/job/789/',
+        date: '2024-01-15 14:02:00.000000000',
+        _revision_number: 4,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+      {
+        id: 'msg5',
+        message: 'Patch Set 3: Verified -1\n\nBuild Failed : ABORTED',
+        date: '2024-01-15 14:03:00.000000000',
+        _revision_number: 3,
+        author: {
+          _account_id: 9999,
+          name: 'Service Cloud Jenkins',
+        },
+      },
+    ]
+
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            { messages },
+            {
+              headers: { 'Content-Type': 'application/json' },
+            },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345').pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(createMockConfigLayer()),
+    )
+
+    await Effect.runPromise(effect)
+
+    expect(capturedStdout.length).toBe(1)
+    const output = JSON.parse(capturedStdout[0])
+    // PS 4 build started at 14:02, PS 3 verification at 14:03 should be IGNORED
+    // because it's for a different revision. PS 4 build is still running.
+    expect(output).toEqual({ state: 'running' })
+  })
+
+  test('returns success when verification matches the latest patchset', async () => {
+    const messages: MessageInfo[] = [
+      {
+        id: 'msg1',
+        message: 'Build Started',
+        date: '2024-01-15 10:00:00.000000000',
+        _revision_number: 1,
+        author: {
+          _account_id: 9999,
+          name: 'CI Bot',
+        },
+      },
+      {
+        id: 'msg2',
+        message: 'Build Started',
+        date: '2024-01-15 11:00:00.000000000',
+        _revision_number: 2,
+        author: {
+          _account_id: 9999,
+          name: 'CI Bot',
+        },
+      },
+      {
+        id: 'msg3',
+        message: 'Patch Set 2: Verified+1',
+        date: '2024-01-15 11:15:00.000000000',
+        _revision_number: 2,
+        author: {
+          _account_id: 9999,
+          name: 'CI Bot',
+        },
+      },
+    ]
+
+    server.use(
+      http.get('*/a/changes/12345', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('o') === 'MESSAGES') {
+          return HttpResponse.json(
+            { messages },
+            {
+              headers: { 'Content-Type': 'application/json' },
+            },
+          )
+        }
+        return HttpResponse.text('Not Found', { status: 404 })
+      }),
+    )
+
+    const effect = buildStatusCommand('12345').pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(createMockConfigLayer()),
+    )
+
+    await Effect.runPromise(effect)
+
+    expect(capturedStdout.length).toBe(1)
+    const output = JSON.parse(capturedStdout[0])
+    // PS 2 build started at 11:00, PS 2 verification at 11:15 - same revision, success
+    expect(output).toEqual({ state: 'success' })
+  })
 })

package/tests/helpers/build-status-test-setup.ts

@@ -0,0 +1,83 @@
+import type { Mock } from 'bun:test'
+import { mock } from 'bun:test'
+import type { SetupServer } from 'msw/node'
+import { setupServer } from 'msw/node'
+import { http, HttpResponse } from 'msw'
+import { Layer } from 'effect'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './config-mock'
+
+export const server: SetupServer = setupServer(
+  // Default handler for auth check
+  http.get('*/a/accounts/self', ({ request }) => {
+    const auth = request.headers.get('Authorization')
+    if (!auth || !auth.startsWith('Basic ')) {
+      return HttpResponse.text('Unauthorized', { status: 401 })
+    }
+    return HttpResponse.json({
+      _account_id: 1000,
+      name: 'Test User',
+      email: 'test@example.com',
+    })
+  }),
+)
+
+// Store captured output
+export let capturedStdout: string[] = []
+export let capturedErrors: string[] = []
+
+// Mock process.stdout.write to capture JSON output
+export const mockStdoutWrite: Mock<(chunk: unknown) => boolean> = mock(
+  (chunk: unknown): boolean => {
+    capturedStdout.push(String(chunk))
+    return true
+  },
+)
+
+// Mock console.error to capture errors
+export const mockConsoleError: Mock<(...args: unknown[]) => void> = mock(
+  (...args: unknown[]): void => {
+    capturedErrors.push(args.join(' '))
+  },
+)
+
+// Mock process.exit to prevent test termination
+export const mockProcessExit: Mock<(code?: number) => never> = mock((_code?: number): never => {
+  throw new Error('Process exited')
+})
+
+// Store original methods
+export const originalStdoutWrite: typeof process.stdout.write = process.stdout.write
+export const originalConsoleError: typeof console.error = console.error
+export const originalProcessExit: typeof process.exit = process.exit
+
+export const setupBuildStatusTests = (): void => {
+  server.listen({ onUnhandledRequest: 'bypass' })
+  // @ts-ignore - Mocking stdout
+  process.stdout.write = mockStdoutWrite
+  // @ts-ignore - Mocking console
+  console.error = mockConsoleError
+  // @ts-ignore - Mocking process.exit
+  process.exit = mockProcessExit
+}
+
+export const teardownBuildStatusTests = (): void => {
+  server.close()
+  // @ts-ignore - Restoring stdout
+  process.stdout.write = originalStdoutWrite
+  console.error = originalConsoleError
+  // @ts-ignore - Restoring process.exit
+  process.exit = originalProcessExit
+}
+
+export const resetBuildStatusMocks = (): void => {
+  server.resetHandlers()
+  mockStdoutWrite.mockClear()
+  mockConsoleError.mockClear()
+  mockProcessExit.mockClear()
+  capturedStdout = []
+  capturedErrors = []
+}
+
+export const createMockConfigLayer = (): Layer.Layer<ConfigService> =>
+  Layer.succeed(ConfigService, createMockConfigService())