hungry-ghost-hive 0.43.2 → 0.45.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

@@ -15,6 +15,7 @@ import { createLog } from '../../db/queries/logs.js';
 import { createRequirement, updateRequirement } from '../../db/queries/requirements.js';
 import { getAllTeams } from '../../db/queries/teams.js';
 import { isTmuxAvailable, spawnTmuxSession } from '../../tmux/manager.js';
+import { getTechLeadSessionName } from '../../utils/instance.js';
 import { withHiveContext } from '../../utils/with-hive-context.js';
 import { startDashboard } from '../dashboard/index.js';
 
@@ -209,21 +210,25 @@ export const reqCommand = new Command('req')
           });
 
           // Spawn Tech Lead tmux session
-          const sessionName = `hive-tech-lead`;
+          const sessionName = getTechLeadSessionName(paths.hiveDir);
           const techLeadPrompt = generateTechLeadPrompt(
             req.id,
             title,
             description,
             teams,
             options.godmode,
-            targetBranch
+            targetBranch,
+            sessionName
           );
 
           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
@@ -318,8 +323,10 @@ export function generateTechLeadPrompt(
   description: string,
   teams: { id: string; name: string; repo_path: string; repo_url: string }[],
   godmode?: boolean,
-  targetBranch?: string
+  targetBranch?: string,
+  techLeadSession?: string
 ): string {
+  const tlSession = techLeadSession || 'hive-tech-lead';
   const teamList = teams.map(t => `- ${t.name}: ${t.repo_path} (${t.repo_url})`).join('\n');
   const godmodeNotice = godmode
     ? `
@@ -384,7 +391,7 @@ The SQLite database is at .hive/hive.db
 
 Check your inbox for messages from developers:
 \`\`\`bash
-hive msg inbox hive-tech-lead
+hive msg inbox ${tlSession}
 \`\`\`
 
 Read a specific message:
@@ -397,7 +404,7 @@ Reply to a message:
 hive msg reply <msg-id> "Your response here"
 \`\`\`
 
-**IMPORTANT:** Periodically run \`hive msg inbox hive-tech-lead\` to check if any developers need guidance. Answer their questions promptly to keep the team unblocked.
+**IMPORTANT:** Periodically run \`hive msg inbox ${tlSession}\` to check if any developers need guidance. Answer their questions promptly to keep the team unblocked.
 
 When done planning, update the requirement status to 'planned' and run \`hive assign\` to spawn Senior developers who will implement the stories.
 `;

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/commands/stories.ts

@@ -87,23 +87,32 @@ storiesCommand
       criteria?: string[];
       json?: boolean;
     }) => {
-      await withHiveContext(async ({ root, db }) => {
+      await withHiveContext(async ({ root, paths, db }) => {
         // Create local story
-        const story = createStory(db.db, {
-          requirementId: options.requirement || null,
-          teamId: options.team || null,
-          title: options.title,
-          description: options.description,
-          acceptanceCriteria: options.criteria || null,
-        });
+        const story = createStory(
+          db.db,
+          {
+            requirementId: options.requirement || null,
+            teamId: options.team || null,
+            title: options.title,
+            description: options.description,
+            acceptanceCriteria: options.criteria || null,
+          },
+          paths.storiesDir
+        );
 
         // Update with optional fields
         if (options.points !== undefined || options.complexity !== undefined) {
-          updateStory(db.db, story.id, {
-            storyPoints: options.points ?? null,
-            complexityScore: options.complexity ?? null,
-            status: 'estimated',
-          });
+          updateStory(
+            db.db,
+            story.id,
+            {
+              storyPoints: options.points ?? null,
+              complexityScore: options.complexity ?? null,
+              status: 'estimated',
+            },
+            paths.storiesDir
+          );
         }
 
         // Sync to PM provider if configured

package/src/cli/dashboard/panels/agents.ts

@@ -9,6 +9,7 @@ import type { ModelsConfig } from '../../../config/schema.js';
 import { getActiveAgents, type AgentRow } from '../../../db/queries/agents.js';
 import { getTeamById } from '../../../db/queries/teams.js';
 import { getHiveSessions } from '../../../tmux/manager.js';
+import { getManagerSessionName } from '../../../utils/instance.js';
 import { findHiveRoot, getHivePaths } from '../../../utils/paths.js';
 
 function debugLog(msg: string) {
@@ -125,8 +126,11 @@ export async function updateAgentsPanel(list: Widgets.ListElement, db: Database)
   }
 
   // Check for manager session (not in DB)
-  const hiveSessions = await getHiveSessions();
-  const managerSession = hiveSessions.find(s => s.name === 'hive-manager');
+  const hiveRoot = findHiveRoot();
+  const hDir = hiveRoot ? getHivePaths(hiveRoot).hiveDir : undefined;
+  const managerName = hDir ? getManagerSessionName(hDir) : 'hive-manager';
+  const hiveSessions = await getHiveSessions(hDir);
+  const managerSession = hiveSessions.find(s => s.name === managerName);
 
   // Build combined list - manager first if running
   const displayAgents: DisplayAgent[] = [];
@@ -137,7 +141,7 @@ export async function updateAgentsPanel(list: Widgets.ListElement, db: Database)
       id: 'manager',
       type: 'manager' as AgentRow['type'],
       team_id: null,
-      tmux_session: 'hive-manager',
+      tmux_session: managerName,
       model: '-',
       status: 'working',
       current_story_id: null,

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: