hungry-ghost-hive 0.43.2 → 0.44.0

package/src/cli/commands/pr.test.ts

@@ -2,7 +2,11 @@
 
 import type { Command } from 'commander';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getPullRequestById, updatePullRequest } from '../../db/queries/pull-requests.js';
+import {
+  getOpenPullRequestsByStory,
+  getPullRequestById,
+  updatePullRequest,
+} from '../../db/queries/pull-requests.js';
 import { autoMergeApprovedPRs } from '../../utils/auto-merge.js';
 
 // Mock dependencies
@@ -205,6 +209,78 @@ describe('pr command', () => {
       const fromOpt = submitCmd?.options.find(opt => opt.long === '--from');
       expect(fromOpt).toBeDefined();
     });
+
+    it('should auto-close existing PRs with different github_pr_number', async () => {
+      vi.mocked(getOpenPullRequestsByStory).mockReturnValue([
+        {
+          id: 'old-pr-1',
+          story_id: 'TEST-1',
+          team_id: 'team-1',
+          branch_name: 'feature/old-branch',
+          github_pr_number: 42,
+          github_pr_url: null,
+          submitted_by: null,
+          reviewed_by: null,
+          status: 'queued',
+          review_notes: null,
+          created_at: '2026-01-01T00:00:00.000Z',
+          updated_at: '2026-01-01T00:00:00.000Z',
+          reviewed_at: null,
+        },
+      ]);
+
+      await run(
+        'submit',
+        '--branch',
+        'feature/new-branch',
+        '--story',
+        'TEST-1',
+        '--pr-number',
+        '99'
+      );
+
+      expect(updatePullRequest).toHaveBeenCalledWith(
+        expect.anything(),
+        'old-pr-1',
+        expect.objectContaining({ status: 'closed' })
+      );
+    });
+
+    it('should skip auto-close when resubmitting same github PR number', async () => {
+      vi.mocked(getOpenPullRequestsByStory).mockReturnValue([
+        {
+          id: 'existing-pr-1',
+          story_id: 'TEST-1',
+          team_id: 'team-1',
+          branch_name: 'feature/same-branch',
+          github_pr_number: 55,
+          github_pr_url: null,
+          submitted_by: null,
+          reviewed_by: null,
+          status: 'queued',
+          review_notes: null,
+          created_at: '2026-01-01T00:00:00.000Z',
+          updated_at: '2026-01-01T00:00:00.000Z',
+          reviewed_at: null,
+        },
+      ]);
+
+      await run(
+        'submit',
+        '--branch',
+        'feature/same-branch',
+        '--story',
+        'TEST-1',
+        '--pr-number',
+        '55'
+      );
+
+      expect(updatePullRequest).not.toHaveBeenCalledWith(
+        expect.anything(),
+        'existing-pr-1',
+        expect.objectContaining({ status: 'closed' })
+      );
+    });
   });
 
   describe('queue subcommand', () => {

package/src/cli/commands/pr.ts

@@ -62,8 +62,13 @@ prCommand
         teamId = story.team_id;
 
         // Auto-close any existing open PRs for this story
+        const incomingPrNumber = options.prNumber ? parseInt(options.prNumber, 10) : null;
         const existingPRs = getOpenPullRequestsByStory(db.db, storyId);
         for (const existingPR of existingPRs) {
+          // Skip auto-close if this is a resubmit of the same GitHub PR
+          if (incomingPrNumber !== null && existingPR.github_pr_number === incomingPrNumber) {
+            continue;
+          }
           updatePullRequest(db.db, existingPR.id, { status: 'closed' });
           createLog(db.db, {
             agentId: options.from || 'system',

package/src/cli/commands/req.ts

@@ -221,9 +221,12 @@ export const reqCommand = new Command('req')
 
           try {
             // Build CLI command using the configured runtime for Tech Lead
+            const chromeEnabled =
+              config.agents?.chrome_enabled === true && techLeadCliTool === 'claude';
             const commandArgs = getCliRuntimeBuilder(techLeadCliTool).buildSpawnCommand(
               techLeadModel,
-              techLeadSafetyMode
+              techLeadSafetyMode,
+              { chrome: chromeEnabled }
             );
 
             // Pass the prompt as initialPrompt so it's included as a CLI positional

package/src/cli/commands/resume.ts

@@ -91,8 +91,11 @@ export const resumeCommand = new Command('resume')
           const model = resolveRuntimeModelForCli(selectedModel, cliTool);
 
           // Build resume command using CLI runtime builder
+          const chromeEnabled = config.agents?.chrome_enabled === true && cliTool === 'claude';
           const runtimeBuilder = getCliRuntimeBuilder(cliTool);
-          const commandArgs = runtimeBuilder.buildResumeCommand(model, sessionName, safetyMode);
+          const commandArgs = runtimeBuilder.buildResumeCommand(model, sessionName, safetyMode, {
+            chrome: chromeEnabled,
+          });
 
           // Spawn new session
           await spawnTmuxSession({

package/src/cli-runtimes/chrome.ts

@@ -0,0 +1,43 @@
+// Licensed under the Hungry Ghost Hive License. See LICENSE.
+
+import { execa } from 'execa';
+import type { CliRuntimeType } from './types.js';
+
+/**
+ * Detect whether the Claude CLI supports the --chrome flag.
+ * Runs `claude --help` and checks if the output mentions --chrome.
+ * @returns true if --chrome is recognized by the CLI
+ */
+export async function detectChromeAvailability(): Promise<boolean> {
+  try {
+    const result = await execa('claude', ['--help']);
+    const output = result.stdout + result.stderr;
+    return output.includes('--chrome');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Resolve the effective chrome enabled state from config value.
+ * - true/false: use the explicit value
+ * - 'auto': detect availability, but only enable for claude CLI tool
+ * @param configValue - The chrome_enabled config value (true, false, or 'auto')
+ * @param cliTool - The CLI tool configured for the agent
+ * @returns Whether chrome should be enabled
+ */
+export async function resolveChromeEnabled(
+  configValue: boolean | 'auto',
+  cliTool: CliRuntimeType
+): Promise<boolean> {
+  if (typeof configValue === 'boolean') {
+    return configValue;
+  }
+
+  // Auto-detect: only enable for claude CLI tool
+  if (cliTool !== 'claude') {
+    return false;
+  }
+
+  return detectChromeAvailability();
+}

package/src/cli-runtimes/claude.ts

@@ -1,20 +1,37 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import { CliRuntimeBuilder, RuntimeSafetyMode } from './types.js';
+import { CliRuntimeBuilder, RuntimeOptions, RuntimeSafetyMode } from './types.js';
 
 export class ClaudeRuntimeBuilder implements CliRuntimeBuilder {
-  buildSpawnCommand(model: string, safetyMode: RuntimeSafetyMode): string[] {
-    if (safetyMode === 'safe') {
-      return ['claude', '--model', model];
+  buildSpawnCommand(
+    model: string,
+    safetyMode: RuntimeSafetyMode,
+    options?: RuntimeOptions
+  ): string[] {
+    const args =
+      safetyMode === 'safe'
+        ? ['claude', '--model', model]
+        : ['claude', '--dangerously-skip-permissions', '--model', model];
+    if (options?.chrome) {
+      args.push('--chrome');
     }
-    return ['claude', '--dangerously-skip-permissions', '--model', model];
+    return args;
   }
 
-  buildResumeCommand(model: string, sessionId: string, safetyMode: RuntimeSafetyMode): string[] {
-    if (safetyMode === 'safe') {
-      return ['claude', '--model', model, '--resume', sessionId];
+  buildResumeCommand(
+    model: string,
+    sessionId: string,
+    safetyMode: RuntimeSafetyMode,
+    options?: RuntimeOptions
+  ): string[] {
+    const args =
+      safetyMode === 'safe'
+        ? ['claude', '--model', model, '--resume', sessionId]
+        : ['claude', '--dangerously-skip-permissions', '--model', model, '--resume', sessionId];
+    if (options?.chrome) {
+      args.push('--chrome');
     }
-    return ['claude', '--dangerously-skip-permissions', '--model', model, '--resume', sessionId];
+    return args;
   }
 
   getAutoApprovalFlag(safetyMode: RuntimeSafetyMode): string {

package/src/cli-runtimes/codex.ts

@@ -1,9 +1,13 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import { CliRuntimeBuilder, RuntimeSafetyMode } from './types.js';
+import { CliRuntimeBuilder, RuntimeOptions, RuntimeSafetyMode } from './types.js';
 
 export class CodexRuntimeBuilder implements CliRuntimeBuilder {
-  buildSpawnCommand(model: string, safetyMode: RuntimeSafetyMode): string[] {
+  buildSpawnCommand(
+    model: string,
+    safetyMode: RuntimeSafetyMode,
+    _options?: RuntimeOptions
+  ): string[] {
     const approvalPolicy = safetyMode === 'safe' ? 'on-request' : 'never';
     const sandboxMode = safetyMode === 'safe' ? 'workspace-write' : 'danger-full-access';
     return [
@@ -17,7 +21,12 @@ export class CodexRuntimeBuilder implements CliRuntimeBuilder {
     ];
   }
 
-  buildResumeCommand(model: string, sessionId: string, safetyMode: RuntimeSafetyMode): string[] {
+  buildResumeCommand(
+    model: string,
+    sessionId: string,
+    safetyMode: RuntimeSafetyMode,
+    _options?: RuntimeOptions
+  ): string[] {
     const approvalPolicy = safetyMode === 'safe' ? 'on-request' : 'never';
     const sandboxMode = safetyMode === 'safe' ? 'workspace-write' : 'danger-full-access';
     return [

package/src/cli-runtimes/gemini.ts

@@ -1,14 +1,23 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import { CliRuntimeBuilder, RuntimeSafetyMode } from './types.js';
+import { CliRuntimeBuilder, RuntimeOptions, RuntimeSafetyMode } from './types.js';
 
 export class GeminiRuntimeBuilder implements CliRuntimeBuilder {
-  buildSpawnCommand(model: string, safetyMode: RuntimeSafetyMode): string[] {
+  buildSpawnCommand(
+    model: string,
+    safetyMode: RuntimeSafetyMode,
+    _options?: RuntimeOptions
+  ): string[] {
     const sandboxMode = safetyMode === 'safe' ? 'workspace-write' : 'none';
     return ['gemini', '--model', model, '--sandbox', sandboxMode];
   }
 
-  buildResumeCommand(model: string, sessionId: string, safetyMode: RuntimeSafetyMode): string[] {
+  buildResumeCommand(
+    model: string,
+    sessionId: string,
+    safetyMode: RuntimeSafetyMode,
+    _options?: RuntimeOptions
+  ): string[] {
     const sandboxMode = safetyMode === 'safe' ? 'workspace-write' : 'none';
     return ['gemini', '--model', model, '--sandbox', sandboxMode, '--resume', sessionId];
   }

package/src/cli-runtimes/index.test.ts

@@ -5,7 +5,9 @@ import {
   ClaudeRuntimeBuilder,
   CodexRuntimeBuilder,
   GeminiRuntimeBuilder,
+  detectChromeAvailability,
   getCliRuntimeBuilder,
+  resolveChromeEnabled,
   resolveRuntimeModelForCli,
   selectCompatibleModelForCli,
   validateCliBinary,
@@ -506,4 +508,160 @@ describe('CLI Runtime Builders', () => {
       expect(selected).toBe('claude-sonnet-4-5-20250929');
     });
   });
+
+  describe('detectChromeAvailability', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('should return true when claude --help output includes --chrome', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockResolvedValue({
+        stdout: 'Usage: claude [options]\n  --chrome    Enable Chrome integration\n',
+        stderr: '',
+        exitCode: 0,
+        command: 'claude --help',
+        escapedCommand: 'claude --help',
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false,
+      } as any);
+
+      const result = await detectChromeAvailability();
+      expect(result).toBe(true);
+    });
+
+    it('should return false when claude --help output does not include --chrome', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockResolvedValue({
+        stdout: 'Usage: claude [options]\n  --model    Set the model\n',
+        stderr: '',
+        exitCode: 0,
+        command: 'claude --help',
+        escapedCommand: 'claude --help',
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false,
+      } as any);
+
+      const result = await detectChromeAvailability();
+      expect(result).toBe(false);
+    });
+
+    it('should return true when --chrome appears in stderr', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockResolvedValue({
+        stdout: '',
+        stderr: 'Options:\n  --chrome    Enable Chrome integration\n',
+        exitCode: 0,
+        command: 'claude --help',
+        escapedCommand: 'claude --help',
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false,
+      } as any);
+
+      const result = await detectChromeAvailability();
+      expect(result).toBe(true);
+    });
+
+    it('should return false when the command fails', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockRejectedValue(new Error('Command failed'));
+
+      const result = await detectChromeAvailability();
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('resolveChromeEnabled', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('should return true when configValue is explicitly true', async () => {
+      const result = await resolveChromeEnabled(true, 'claude');
+      expect(result).toBe(true);
+    });
+
+    it('should return true when configValue is explicitly true for non-claude tool', async () => {
+      const result = await resolveChromeEnabled(true, 'codex');
+      expect(result).toBe(true);
+    });
+
+    it('should return false when configValue is explicitly false', async () => {
+      const result = await resolveChromeEnabled(false, 'claude');
+      expect(result).toBe(false);
+    });
+
+    it('should return false when configValue is explicitly false for non-claude tool', async () => {
+      const result = await resolveChromeEnabled(false, 'gemini');
+      expect(result).toBe(false);
+    });
+
+    it('should return false for auto mode with codex CLI tool', async () => {
+      const result = await resolveChromeEnabled('auto', 'codex');
+      expect(result).toBe(false);
+    });
+
+    it('should return false for auto mode with gemini CLI tool', async () => {
+      const result = await resolveChromeEnabled('auto', 'gemini');
+      expect(result).toBe(false);
+    });
+
+    it('should detect chrome availability for auto mode with claude CLI tool when --chrome is available', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockResolvedValue({
+        stdout: 'Usage: claude [options]\n  --chrome    Enable Chrome integration\n',
+        stderr: '',
+        exitCode: 0,
+        command: 'claude --help',
+        escapedCommand: 'claude --help',
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false,
+      } as any);
+
+      const result = await resolveChromeEnabled('auto', 'claude');
+      expect(result).toBe(true);
+    });
+
+    it('should return false for auto mode with claude CLI tool when --chrome is not available', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockResolvedValue({
+        stdout: 'Usage: claude [options]\n  --model    Set the model\n',
+        stderr: '',
+        exitCode: 0,
+        command: 'claude --help',
+        escapedCommand: 'claude --help',
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false,
+      } as any);
+
+      const result = await resolveChromeEnabled('auto', 'claude');
+      expect(result).toBe(false);
+    });
+
+    it('should return false for auto mode with claude CLI tool when detection fails', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockRejectedValue(new Error('Command not found'));
+
+      const result = await resolveChromeEnabled('auto', 'claude');
+      expect(result).toBe(false);
+    });
+  });
 });

package/src/cli-runtimes/index.ts

@@ -5,7 +5,7 @@ import { UnsupportedFeatureError, ValidationError } from '../errors/index.js';
 import { ClaudeRuntimeBuilder } from './claude.js';
 import { CodexRuntimeBuilder } from './codex.js';
 import { GeminiRuntimeBuilder } from './gemini.js';
-import { CliRuntimeBuilder, CliRuntimeType, RuntimeSafetyMode } from './types.js';
+import { CliRuntimeBuilder, CliRuntimeType, RuntimeOptions, RuntimeSafetyMode } from './types.js';
 
 const CODEX_CHATGPT_SAFE_MODEL = 'gpt-5.2-codex';
 
@@ -144,7 +144,8 @@ export function resolveRuntimeModelForCli(model: string, cliTool: CliRuntimeType
   return model;
 }
 
+export { detectChromeAvailability, resolveChromeEnabled } from './chrome.js';
 export { ClaudeRuntimeBuilder } from './claude.js';
 export { CodexRuntimeBuilder } from './codex.js';
 export { GeminiRuntimeBuilder } from './gemini.js';
-export type { CliRuntimeBuilder, CliRuntimeType, RuntimeSafetyMode };
+export type { CliRuntimeBuilder, CliRuntimeType, RuntimeOptions, RuntimeSafetyMode };

package/src/cli-runtimes/types.ts

@@ -3,21 +3,38 @@
 export type CliRuntimeType = 'claude' | 'codex' | 'gemini';
 export type RuntimeSafetyMode = 'safe' | 'unsafe';
 
+export interface RuntimeOptions {
+  chrome?: boolean;
+}
+
 export interface CliRuntimeBuilder {
   /**
    * Build command array for spawning a new agent session
    * @param model - The model identifier to use
+   * @param safetyMode - The safety mode for the agent
+   * @param options - Optional runtime options (e.g., chrome flag)
    * @returns Array of command and arguments suitable for spawn
    */
-  buildSpawnCommand(model: string, safetyMode: RuntimeSafetyMode): string[];
+  buildSpawnCommand(
+    model: string,
+    safetyMode: RuntimeSafetyMode,
+    options?: RuntimeOptions
+  ): string[];
 
   /**
    * Build command array for resuming an existing agent session
    * @param model - The model identifier to use
    * @param sessionId - The session ID to resume
+   * @param safetyMode - The safety mode for the agent
+   * @param options - Optional runtime options (e.g., chrome flag)
    * @returns Array of command and arguments suitable for spawn
    */
-  buildResumeCommand(model: string, sessionId: string, safetyMode: RuntimeSafetyMode): string[];
+  buildResumeCommand(
+    model: string,
+    sessionId: string,
+    safetyMode: RuntimeSafetyMode,
+    options?: RuntimeOptions
+  ): string[];
 
   /**
    * Get the auto-approval flag for this CLI runtime

package/src/config/schema.ts

@@ -210,6 +210,9 @@ const AgentsConfigSchema = z.object({
   llm_timeout_ms: z.number().int().positive().default(1800000),
   // Max retries for LLM calls on timeout
   llm_max_retries: z.number().int().nonnegative().default(2),
+  // Enable Chrome browser automation via Claude in Chrome extension
+  // true = always enable, false = always disable, 'auto' = detect availability
+  chrome_enabled: z.union([z.boolean(), z.literal('auto')]).default('auto'),
 });
 
 // Manager daemon configuration
@@ -521,6 +524,9 @@ agents:
   llm_timeout_ms: 1800000
   # Max retries for LLM calls on timeout
   llm_max_retries: 2
+  # Enable Chrome browser automation (true, false, or auto)
+  # auto = detect if Claude CLI supports --chrome flag
+  chrome_enabled: auto
 
 # Manager daemon (micromanager nudge behavior)
 manager:

package/src/context-files/index.test.ts

@@ -205,6 +205,7 @@ describe('context-files module', () => {
         checkpoint_threshold: 14000,
         llm_timeout_ms: 1800000,
         llm_max_retries: 2,
+        chrome_enabled: 'auto',
       },
       manager: {
         fast_poll_interval: 15000,

package/src/orchestrator/scheduler.ts

@@ -1052,7 +1052,15 @@ export class Scheduler {
       }
 
       // Build CLI command using the configured runtime
-      const commandArgs = getCliRuntimeBuilder(cliTool).buildSpawnCommand(runtimeModel, safetyMode);
+      const chromeEnabled =
+        this.config.hiveConfig?.agents?.chrome_enabled === true && cliTool === 'claude';
+      const commandArgs = getCliRuntimeBuilder(cliTool).buildSpawnCommand(
+        runtimeModel,
+        safetyMode,
+        {
+          chrome: chromeEnabled,
+        }
+      );
 
       // Pass the prompt as initialPrompt so it's included as a CLI positional
       // argument via $(cat ...). This delivers the full multi-line prompt

package/src/utils/auto-merge.test.ts

@@ -21,6 +21,11 @@ vi.mock('./paths.js', () => ({
   getHivePaths: vi.fn(() => ({ hiveDir: '/mock/hive' })),
 }));
 
+vi.mock('../connectors/project-management/operations.js', () => ({
+  postLifecycleComment: vi.fn().mockResolvedValue(undefined),
+  syncStatusForStory: vi.fn(),
+}));
+
 import { loadConfig } from '../config/loader.js';
 import { autoMergeApprovedPRs } from './auto-merge.js';
 
@@ -266,6 +271,82 @@ describe('auto-merge functionality', () => {
       expect(mockLoadConfig).toHaveBeenCalledWith('/mock/hive');
     });
 
+    it('should keep PR as queued when auto-merge is pending (PR still open after gh pr merge --auto)', async () => {
+      const pr = createPullRequest(db, {
+        storyId,
+        teamId,
+        branchName: 'feature/auto-merge-pending',
+        githubPrNumber: 456,
+      });
+      updatePullRequest(db, pr.id, { status: 'approved' });
+
+      mockLoadConfig.mockReturnValue({
+        integrations: {
+          autonomy: { level: 'full' },
+          source_control: { provider: 'github' },
+          project_management: { provider: 'none' },
+        },
+      } as any);
+
+      // Mock execSync: first call returns OPEN+MERGEABLE, merge command succeeds,
+      // second call (post-merge check) returns OPEN (auto-merge pending)
+      const mockExecSync = vi.fn();
+      mockExecSync
+        .mockReturnValueOnce(
+          JSON.stringify({ state: 'OPEN', mergeable: 'MERGEABLE', mergeStateStatus: 'CLEAN' })
+        )
+        .mockReturnValueOnce(undefined) // gh pr merge --auto
+        .mockReturnValueOnce(
+          JSON.stringify({ state: 'OPEN', mergeable: 'MERGEABLE', mergeStateStatus: 'BLOCKED' })
+        );
+
+      vi.doMock('child_process', () => ({ execSync: mockExecSync }));
+
+      const dbClient = { db, save: vi.fn(), close: vi.fn(), runMigrations: vi.fn() };
+      const result = await autoMergeApprovedPRs('/mock/root', dbClient);
+
+      // Should return 0 because the PR was not actually merged yet
+      expect(result).toBe(0);
+      // PR should remain 'queued' (not rolled back to 'approved' or advanced to 'merged')
+      expect(getPullRequestById(db, pr.id)?.status).toBe('queued');
+    });
+
+    it('should reset stale branch PR to approved after updating behind branch', async () => {
+      const pr = createPullRequest(db, {
+        storyId,
+        teamId,
+        branchName: 'feature/stale-branch',
+        githubPrNumber: 789,
+      });
+      updatePullRequest(db, pr.id, { status: 'approved' });
+
+      mockLoadConfig.mockReturnValue({
+        integrations: {
+          autonomy: { level: 'full' },
+          source_control: { provider: 'github' },
+          project_management: { provider: 'none' },
+        },
+      } as any);
+
+      // Mock execSync: PR state shows BEHIND, then gh pr update-branch succeeds
+      const mockExecSync = vi.fn();
+      mockExecSync
+        .mockReturnValueOnce(
+          JSON.stringify({ state: 'OPEN', mergeable: 'MERGEABLE', mergeStateStatus: 'BEHIND' })
+        )
+        .mockReturnValueOnce(undefined); // gh pr update-branch
+
+      vi.doMock('child_process', () => ({ execSync: mockExecSync }));
+
+      const dbClient = { db, save: vi.fn(), close: vi.fn(), runMigrations: vi.fn() };
+      const result = await autoMergeApprovedPRs('/mock/root', dbClient);
+
+      // Should return 0 because no merge happened yet
+      expect(result).toBe(0);
+      // PR should be reset to 'approved' to be retried on next cycle
+      expect(getPullRequestById(db, pr.id)?.status).toBe('approved');
+    });
+
     it('should skip approved PRs marked for manual merge', async () => {
       const pr = createPullRequest(db, {
         storyId,