@iloom/cli 0.1.19 → 0.3.0

package/dist/cli.js

@@ -1,11 +1,94 @@
 #!/usr/bin/env node
+import {
+  IssueTrackerFactory,
+  generateIssueManagementMcpConfig
+} from "./chunk-RO26VS3W.js";
+import {
+  CLIIsolationManager,
+  DatabaseManager,
+  EnvironmentManager,
+  LoomManager,
+  ResourceCleanup
+} from "./chunk-5EF7Z346.js";
+import {
+  IdentifierParser,
+  loadEnvIntoProcess
+} from "./chunk-IP7SMKIF.js";
+import {
+  ProcessManager
+} from "./chunk-VU3QMIP2.js";
+import {
+  createNeonProviderFromSettings
+} from "./chunk-JQFO7QQN.js";
 import {
   ShellCompletion
-} from "./chunk-PV3GAXQO.js";
+} from "./chunk-VAYCCUXW.js";
+import {
+  getConfiguredRepoFromSettings,
+  getEffectivePRTargetRemote,
+  hasMultipleRemotes,
+  parseGitRemotes
+} from "./chunk-PA6Q6AWM.js";
+import {
+  IssueEnhancementService
+} from "./chunk-47KSHUCR.js";
+import {
+  AgentManager
+} from "./chunk-OC4H6HJD.js";
+import {
+  openBrowser
+} from "./chunk-YETJNRQM.js";
+import {
+  MergeManager
+} from "./chunk-AWOFAD5O.js";
 import {
   GitWorktreeManager
-} from "./chunk-IO4WFTL2.js";
-import "./chunk-KOCQAD2E.js";
+} from "./chunk-4HHRTA7Q.js";
+import {
+  detectPackageManager,
+  installDependencies,
+  runScript
+} from "./chunk-ZT3YZB4K.js";
+import {
+  ClaudeContextManager
+} from "./chunk-C5QCTEQK.js";
+import "./chunk-FIAT22G7.js";
+import {
+  detectClaudeCli,
+  launchClaude
+} from "./chunk-XXV3UFZL.js";
+import "./chunk-WEN5C5DM.js";
+import {
+  DefaultBranchNamingService
+} from "./chunk-3KATJIKO.js";
+import {
+  ProjectCapabilityDetector
+} from "./chunk-EBISESAP.js";
+import {
+  hasScript,
+  readPackageJson
+} from "./chunk-2ZPFJQ3B.js";
+import {
+  extractSettingsOverrides
+} from "./chunk-GYCR2LOU.js";
+import {
+  SettingsManager
+} from "./chunk-ML3NRPNB.js";
+import {
+  executeGitCommand,
+  extractIssueNumber,
+  findMainWorktreePathWithSettings,
+  pushBranchToRemote
+} from "./chunk-MAVL6PJF.js";
+import "./chunk-G2IEYOLQ.js";
+import {
+  executeGhCommand
+} from "./chunk-3RUPPQRG.js";
+import {
+  promptConfirmation,
+  waitForKeypress
+} from "./chunk-JKXJ7BGL.js";
+import "./chunk-ZZZWQGTS.js";
 import {
   logger
 } from "./chunk-GEHQXLEI.js";
@@ -13,6 +96,2342 @@ import {
 // src/cli.ts
 import { program, Option } from "commander";
 
+// src/commands/start.ts
+import path2 from "path";
+
+// src/utils/first-run-setup.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+async function needsFirstRunSetup() {
+  const iloomDir = path.join(process.cwd(), ".iloom");
+  if (!existsSync(iloomDir)) {
+    return true;
+  }
+  const settingsPath = path.join(iloomDir, "settings.json");
+  const settingsLocalPath = path.join(iloomDir, "settings.local.json");
+  const hasSettings = await hasNonEmptySettings(settingsPath);
+  const hasLocalSettings = await hasNonEmptySettings(settingsLocalPath);
+  return !hasSettings && !hasLocalSettings;
+}
+async function hasNonEmptySettings(filePath) {
+  if (!existsSync(filePath)) return false;
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return Object.keys(parsed).length > 0;
+  } catch {
+    return false;
+  }
+}
+async function launchFirstRunSetup() {
+  logger.info("First-time project setup detected.");
+  logger.info(
+    "iloom will now launch an interactive configuration session with Claude."
+  );
+  const { waitForKeypress: waitForKeypress2 } = await import("./prompt-7INJ7YRU.js");
+  await waitForKeypress2("Press any key to start configuration...");
+  const { InitCommand } = await import("./init-G3T64SC4.js");
+  const initCommand = new InitCommand();
+  await initCommand.execute(
+    "Help me configure iloom settings for this project. This is my first time using iloom here. Note: Your iloom command will execute once we are done with configuration changes."
+  );
+  logger.info("Configuration complete! Continuing with your original command...");
+}
+
+// src/commands/start.ts
+var StartCommand = class {
+  constructor(issueTracker, loomManager, _agentManager, settingsManager) {
+    this.loomManager = null;
+    this.issueTracker = issueTracker;
+    this.settingsManager = settingsManager ?? new SettingsManager();
+    this.providedLoomManager = loomManager;
+    const envResult = loadEnvIntoProcess();
+    if (envResult.error) {
+      logger.debug(`Environment loading warning: ${envResult.error.message}`);
+    }
+    if (envResult.parsed) {
+      logger.debug(`Loaded ${Object.keys(envResult.parsed).length} environment variables`);
+    }
+  }
+  /**
+   * Initialize LoomManager with the main worktree path
+   * Uses lazy initialization to ensure we have the correct path
+   */
+  async initializeLoomManager() {
+    var _a, _b;
+    if (this.loomManager) {
+      return this.loomManager;
+    }
+    if (this.providedLoomManager) {
+      this.loomManager = this.providedLoomManager;
+      return this.loomManager;
+    }
+    const mainWorktreePath = await findMainWorktreePathWithSettings();
+    const settings = await this.settingsManager.loadSettings();
+    const environmentManager = new EnvironmentManager();
+    const neonProvider = createNeonProviderFromSettings(settings);
+    const databaseUrlEnvVarName = ((_b = (_a = settings.capabilities) == null ? void 0 : _a.database) == null ? void 0 : _b.databaseUrlEnvVarName) ?? "DATABASE_URL";
+    const databaseManager = new DatabaseManager(neonProvider, environmentManager, databaseUrlEnvVarName);
+    const branchNaming = new DefaultBranchNamingService({ useClaude: true });
+    this.loomManager = new LoomManager(
+      new GitWorktreeManager(mainWorktreePath),
+      this.issueTracker,
+      branchNaming,
+      // Add branch naming service
+      environmentManager,
+      // Reuse same instance
+      new ClaudeContextManager(),
+      new ProjectCapabilityDetector(),
+      new CLIIsolationManager(),
+      this.settingsManager,
+      // Use same instance with CLI overrides
+      databaseManager
+      // Add database manager
+    );
+    return this.loomManager;
+  }
+  /**
+   * Main entry point for the start command
+   */
+  async execute(input) {
+    var _a, _b, _c, _d;
+    try {
+      const initialSettings = await this.settingsManager.loadSettings();
+      if (process.env.FORCE_FIRST_TIME_SETUP === "true" || await needsFirstRunSetup()) {
+        await launchFirstRunSetup();
+        const newSettings = await this.settingsManager.loadSettings();
+        const newProvider = ((_a = newSettings.issueManagement) == null ? void 0 : _a.provider) ?? "github";
+        if (newProvider !== this.issueTracker.providerName) {
+          logger.debug(`Reinitializing issue tracker: provider changed to "${newProvider}"`);
+          this.issueTracker = IssueTrackerFactory.create(newSettings);
+        }
+      }
+      let repo;
+      const multipleRemotes = await hasMultipleRemotes();
+      if (multipleRemotes) {
+        repo = await getConfiguredRepoFromSettings(initialSettings);
+        logger.info(`Using GitHub repository: ${repo}`);
+      }
+      const loomManager = await this.initializeLoomManager();
+      let parentLoom = await this.detectParentLoom(loomManager);
+      const parsed = await this.parseInput(input.identifier, repo);
+      await this.validateInput(parsed, repo);
+      if (parentLoom) {
+        const { isInteractiveEnvironment, promptConfirmation: promptConfirmation2 } = await import("./prompt-7INJ7YRU.js");
+        const parentDisplay = parentLoom.type === "issue" ? `issue #${parentLoom.identifier}` : parentLoom.type === "pr" ? `PR #${parentLoom.identifier}` : `branch ${parentLoom.identifier}`;
+        if (input.options.childLoom === true) {
+          logger.info(`Creating as child loom of ${parentDisplay} (--child-loom flag)`);
+        } else if (input.options.childLoom === false) {
+          parentLoom = null;
+          logger.info("Creating as independent loom (--no-child-loom flag)");
+        } else {
+          let createAsChild = true;
+          if (isInteractiveEnvironment()) {
+            createAsChild = await promptConfirmation2(
+              `You are not in your main worktree. Create as a child loom of ${parentDisplay}?`,
+              true
+              // Default yes
+            );
+          } else {
+            logger.error(`Non-interactive environment detected, use either --child-loom or --no-child-loom to specify behavior`);
+            process.exit(1);
+          }
+          if (!createAsChild) {
+            parentLoom = null;
+            logger.info("Creating as independent loom");
+          }
+        }
+      } else if (input.options.childLoom === true) {
+        logger.debug("--child-loom flag provided but not running from inside an existing loom (ignored)");
+      }
+      if (parsed.type === "description") {
+        logger.info("Creating GitHub issue from description...");
+        const body = input.options.body ?? "";
+        const result = await this.issueTracker.createIssue(
+          parsed.originalInput,
+          // Use description as title
+          body
+          // Use provided body or empty
+        );
+        logger.success(`Created issue #${result.number}: ${result.url}`);
+        parsed.type = "issue";
+        parsed.number = result.number;
+      }
+      if (input.options.oneShot === "bypassPermissions") {
+        const { promptConfirmation: promptConfirmation2 } = await import("./prompt-7INJ7YRU.js");
+        const confirmed = await promptConfirmation2(
+          "\u26A0\uFE0F  WARNING: bypassPermissions mode will allow Claude to execute all tool calls without confirmation. This can be dangerous. Do you want to proceed?"
+        );
+        if (!confirmed) {
+          logger.info("Operation cancelled by user");
+          process.exit(0);
+        }
+      }
+      const cliOverrides = extractSettingsOverrides();
+      const settings = await this.settingsManager.loadSettings(void 0, cliOverrides);
+      const workflowType = parsed.type === "branch" ? "regular" : parsed.type;
+      const workflowConfig = (_b = settings.workflows) == null ? void 0 : _b[workflowType];
+      const { extractRawSetArguments, getExecutablePath } = await import("./cli-overrides-XFZWY7CM.js");
+      const setArguments = extractRawSetArguments();
+      const executablePath = getExecutablePath();
+      logger.info(`\u2705 Validated input: ${this.formatParsedInput(parsed)}`);
+      const identifier = parsed.type === "branch" ? parsed.branchName ?? "" : parsed.number ?? 0;
+      const enableClaude = input.options.claude ?? (workflowConfig == null ? void 0 : workflowConfig.startAiAgent) ?? true;
+      const enableCode = input.options.code ?? (workflowConfig == null ? void 0 : workflowConfig.startIde) ?? true;
+      const enableDevServer = input.options.devServer ?? (workflowConfig == null ? void 0 : workflowConfig.startDevServer) ?? true;
+      const enableTerminal = input.options.terminal ?? (workflowConfig == null ? void 0 : workflowConfig.startTerminal) ?? false;
+      logger.debug("Final workflow config values:", {
+        enableClaude,
+        enableCode,
+        enableDevServer,
+        enableTerminal
+      });
+      const loom = await loomManager.createIloom({
+        type: parsed.type,
+        identifier,
+        originalInput: parsed.originalInput,
+        ...parentLoom && { parentLoom },
+        options: {
+          enableClaude,
+          enableCode,
+          enableDevServer,
+          enableTerminal,
+          ...input.options.oneShot && { oneShot: input.options.oneShot },
+          ...setArguments.length > 0 && { setArguments },
+          ...executablePath && { executablePath }
+        }
+      });
+      logger.success(`\u2705 Created loom: ${loom.id} at ${loom.path}`);
+      logger.info(`   Branch: ${loom.branch}`);
+      if ((_c = loom.capabilities) == null ? void 0 : _c.includes("web")) {
+        logger.info(`   Port: ${loom.port}`);
+      }
+      if ((_d = loom.issueData) == null ? void 0 : _d.title) {
+        logger.info(`   Title: ${loom.issueData.title}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        logger.error(`\u274C ${error.message}`);
+      } else {
+        logger.error("\u274C An unknown error occurred");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Parse input to determine type and extract relevant data
+   */
+  async parseInput(identifier, repo) {
+    const trimmedIdentifier = identifier.trim();
+    if (!trimmedIdentifier) {
+      throw new Error("Missing required argument: identifier");
+    }
+    const spaceCount = (trimmedIdentifier.match(/ /g) ?? []).length;
+    if (trimmedIdentifier.length > 25 && spaceCount > 2) {
+      return {
+        type: "description",
+        originalInput: trimmedIdentifier
+      };
+    }
+    const prPattern = /^pr[/-](\d+)$/i;
+    const prMatch = trimmedIdentifier.match(prPattern);
+    if (prMatch == null ? void 0 : prMatch[1]) {
+      return {
+        type: "pr",
+        number: parseInt(prMatch[1], 10),
+        originalInput: trimmedIdentifier
+      };
+    }
+    const linearPattern = /^([A-Z]{2,}-\d+)$/i;
+    const linearMatch = trimmedIdentifier.match(linearPattern);
+    if (linearMatch == null ? void 0 : linearMatch[1]) {
+      const detection = await this.issueTracker.detectInputType(
+        trimmedIdentifier,
+        repo
+      );
+      if (detection.type === "issue" && detection.identifier) {
+        return {
+          type: "issue",
+          number: detection.identifier,
+          // Keep as string for Linear
+          originalInput: trimmedIdentifier
+        };
+      }
+      throw new Error(
+        `Could not find Linear issue ${linearMatch[1].toUpperCase()}`
+      );
+    }
+    const numericPattern = /^#?(\d+)$/;
+    const numericMatch = trimmedIdentifier.match(numericPattern);
+    if (numericMatch == null ? void 0 : numericMatch[1]) {
+      const number = parseInt(numericMatch[1], 10);
+      const detection = await this.issueTracker.detectInputType(
+        trimmedIdentifier,
+        repo
+      );
+      if (detection.type === "pr") {
+        return {
+          type: "pr",
+          number: detection.identifier ? parseInt(detection.identifier, 10) : number,
+          originalInput: trimmedIdentifier
+        };
+      } else if (detection.type === "issue") {
+        return {
+          type: "issue",
+          number: detection.identifier ? parseInt(detection.identifier, 10) : number,
+          originalInput: trimmedIdentifier
+        };
+      } else {
+        throw new Error(`Could not find issue or PR #${number}`);
+      }
+    }
+    return {
+      type: "branch",
+      branchName: trimmedIdentifier,
+      originalInput: trimmedIdentifier
+    };
+  }
+  /**
+   * Validate the parsed input based on its type
+   */
+  async validateInput(parsed, repo) {
+    switch (parsed.type) {
+      case "pr": {
+        if (!parsed.number) {
+          throw new Error("Invalid PR number");
+        }
+        if (!this.issueTracker.supportsPullRequests || !this.issueTracker.fetchPR || !this.issueTracker.validatePRState) {
+          throw new Error("Issue tracker does not support pull requests");
+        }
+        const pr = await this.issueTracker.fetchPR(parsed.number, repo);
+        await this.issueTracker.validatePRState(pr);
+        logger.debug(`Validated PR #${parsed.number}`);
+        break;
+      }
+      case "issue": {
+        if (!parsed.number) {
+          throw new Error("Invalid issue number");
+        }
+        const issue = await this.issueTracker.fetchIssue(parsed.number, repo);
+        await this.issueTracker.validateIssueState(issue);
+        logger.debug(`Validated issue #${parsed.number}`);
+        break;
+      }
+      case "branch": {
+        if (!parsed.branchName) {
+          throw new Error("Invalid branch name");
+        }
+        if (!this.isValidBranchName(parsed.branchName)) {
+          throw new Error(
+            "Invalid branch name. Use only letters, numbers, hyphens, underscores, and slashes"
+          );
+        }
+        logger.debug(`Validated branch name: ${parsed.branchName}`);
+        break;
+      }
+      case "description": {
+        logger.debug("Detected description input", {
+          length: parsed.originalInput.length
+        });
+        break;
+      }
+      default: {
+        const unknownType = parsed;
+        throw new Error(`Unknown input type: ${unknownType.type}`);
+      }
+    }
+  }
+  /**
+   * Validate branch name format
+   */
+  isValidBranchName(branch) {
+    return /^[a-zA-Z0-9/_-]+$/.test(branch);
+  }
+  /**
+   * Format parsed input for display
+   */
+  formatParsedInput(parsed) {
+    switch (parsed.type) {
+      case "pr":
+        return `PR #${parsed.number}`;
+      case "issue":
+        return `Issue #${parsed.number}`;
+      case "branch":
+        return `Branch '${parsed.branchName}'`;
+      case "description":
+        return `Description: ${parsed.originalInput.slice(0, 50)}...`;
+      default:
+        return "Unknown input";
+    }
+  }
+  /**
+   * Detect if running from inside an existing loom worktree
+   * Returns parent loom info if detected, null otherwise
+   */
+  async detectParentLoom(loomManager) {
+    try {
+      const cwd = process.cwd();
+      const looms = await loomManager.listLooms();
+      if (!looms) {
+        return null;
+      }
+      const mainWorktreePath = await findMainWorktreePathWithSettings();
+      const parentLoom = looms.find((loom) => {
+        if (loom.path === mainWorktreePath) {
+          return false;
+        }
+        return cwd === loom.path || cwd.startsWith(loom.path + path2.sep);
+      });
+      if (!parentLoom) {
+        return null;
+      }
+      logger.debug(`Detected parent loom: ${parentLoom.type} ${parentLoom.identifier} at ${parentLoom.path}`);
+      const result = {
+        type: parentLoom.type,
+        identifier: parentLoom.identifier,
+        branchName: parentLoom.branch,
+        worktreePath: parentLoom.path
+      };
+      if (parentLoom.databaseBranch) {
+        result.databaseBranch = parentLoom.databaseBranch;
+      }
+      if (!result.databaseBranch) {
+        const databaseBranch = await loomManager.getDatabaseBranchForLoom(parentLoom.path);
+        if (databaseBranch) {
+          result.databaseBranch = databaseBranch;
+          logger.debug(`Detected parent database branch: ${databaseBranch}`);
+        }
+      }
+      return result;
+    } catch (error) {
+      logger.debug(`Failed to detect parent loom: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return null;
+    }
+  }
+};
+
+// src/commands/add-issue.ts
+var AddIssueCommand = class {
+  constructor(enhancementService, settingsManager) {
+    this.enhancementService = enhancementService;
+    this.settingsManager = settingsManager ?? new SettingsManager();
+  }
+  /**
+   * Execute the add-issue command workflow:
+   * 1. Validate description format
+   * 2. Enhance description with Claude AI
+   * 3. Create GitHub issue
+   * 4. Wait for keypress and open browser for review
+   * 5. Return issue number
+   */
+  async execute(input) {
+    const { description } = input;
+    const settings = await this.settingsManager.loadSettings();
+    let repo;
+    const multipleRemotes = await hasMultipleRemotes();
+    if (multipleRemotes) {
+      repo = await getConfiguredRepoFromSettings(settings);
+      logger.info(`Using GitHub repository: ${repo}`);
+    }
+    if (!description || !this.enhancementService.validateDescription(description)) {
+      throw new Error("Description is required and must be more than 30 characters with at least 3 words");
+    }
+    const enhancedDescription = await this.enhancementService.enhanceDescription(description);
+    const result = await this.enhancementService.createEnhancedIssue(
+      description,
+      enhancedDescription,
+      repo
+    );
+    await this.enhancementService.waitForReviewAndOpen(result.number);
+    return result.number;
+  }
+};
+
+// src/commands/enhance.ts
+var EnhanceCommand = class {
+  constructor(issueTracker, agentManager, settingsManager) {
+    this.issueTracker = issueTracker;
+    this.agentManager = agentManager ?? new AgentManager();
+    this.settingsManager = settingsManager ?? new SettingsManager();
+  }
+  /**
+   * Execute the enhance command workflow:
+   * 1. Validate issue number
+   * 2. Fetch issue to verify it exists
+   * 3. Load agent configurations
+   * 4. Invoke Claude CLI with enhancer agent
+   * 5. Parse response to determine outcome
+   * 6. Handle browser interaction based on outcome
+   */
+  async execute(input) {
+    const { issueNumber, options } = input;
+    const { author } = options;
+    const settings = await this.settingsManager.loadSettings();
+    let repo;
+    const multipleRemotes = await hasMultipleRemotes();
+    if (multipleRemotes) {
+      repo = await getConfiguredRepoFromSettings(settings);
+      logger.info(`Using GitHub repository: ${repo}`);
+    }
+    this.validateIssueNumber(issueNumber);
+    logger.info(`Fetching issue #${issueNumber}...`);
+    const issue = await this.issueTracker.fetchIssue(issueNumber, repo);
+    logger.debug("Issue fetched successfully", { number: issue.number, title: issue.title });
+    logger.debug("Loading agent configurations...");
+    const loadedAgents = await this.agentManager.loadAgents(settings);
+    const agents = this.agentManager.formatForCli(loadedAgents);
+    let mcpConfig;
+    let allowedTools;
+    let disallowedTools;
+    try {
+      const provider = this.issueTracker.providerName;
+      mcpConfig = await generateIssueManagementMcpConfig("issue", repo, provider, settings);
+      logger.debug("Generated MCP configuration for issue management:", { mcpConfig });
+      allowedTools = [
+        "mcp__issue_management__get_issue",
+        "mcp__issue_management__get_comment",
+        "mcp__issue_management__create_comment",
+        "mcp__issue_management__update_comment"
+      ];
+      disallowedTools = ["Bash(gh api:*)"];
+      logger.debug("Configured tool filtering for issue workflow", { allowedTools, disallowedTools });
+    } catch (error) {
+      logger.warn(`Failed to generate MCP config: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    logger.info("Invoking enhancer agent. This may take a moment...");
+    const prompt = this.constructPrompt(issueNumber, author);
+    const response = await launchClaude(prompt, {
+      headless: true,
+      model: "sonnet",
+      agents,
+      ...mcpConfig && { mcpConfig },
+      ...allowedTools && { allowedTools },
+      ...disallowedTools && { disallowedTools }
+    });
+    const result = this.parseEnhancerResponse(response);
+    if (!result.enhanced) {
+      logger.success("Issue already has thorough description. No enhancement needed.");
+      return;
+    }
+    logger.success(`Issue #${issueNumber} enhanced successfully!`);
+    logger.info(`Enhanced specification available at: ${result.url}`);
+    if (!options.noBrowser && result.url) {
+      await this.promptAndOpenBrowser(result.url);
+    }
+  }
+  /**
+   * Validate that issue number is a valid positive integer
+   */
+  validateIssueNumber(issueNumber) {
+    if (issueNumber === void 0 || issueNumber === null) {
+      throw new Error("Issue number is required");
+    }
+    if (typeof issueNumber === "number") {
+      if (Number.isNaN(issueNumber) || issueNumber <= 0 || !Number.isInteger(issueNumber)) {
+        throw new Error("Issue number must be a valid positive integer");
+      }
+    }
+    if (typeof issueNumber === "string" && issueNumber.trim().length === 0) {
+      throw new Error("Issue identifier cannot be empty");
+    }
+  }
+  /**
+   * Construct the prompt for the orchestrating Claude instance.
+   * This prompt is very clear about expected output format to ensure reliable parsing.
+   */
+  constructPrompt(issueNumber, author) {
+    const authorInstruction = author ? `
+IMPORTANT: When you create your analysis comment, tag @${author} in the "Questions for Reporter" section if you have questions.
+` : "";
+    return `Execute @agent-iloom-issue-enhancer ${issueNumber}${authorInstruction}
+
+## OUTPUT REQUIREMENTS
+* If the issue was not enhanced, return ONLY: "No enhancement needed"
+* If the issue WAS enhanced, return ONLY: <FULL URL OF THE COMMENT INCLUDING COMMENT ID>
+* If you encounter permission/authentication/access errors, return ONLY: "Permission denied: <specific error description>"
+* IMPORTANT: Return ONLY one of the above - DO NOT include commentary such as "I created a comment at <URL>" or "I examined the issue and found no enhancement was necessary"
+* CONTEXT: Your output is going to be parsed programmatically, so adherence to the output requirements is CRITICAL.`;
+  }
+  /**
+   * Parse the response from the enhancer agent.
+   * Returns either { enhanced: false } or { enhanced: true, url: "..." }
+   * Throws specific errors for permission issues.
+   */
+  parseEnhancerResponse(response) {
+    if (!response || typeof response !== "string") {
+      throw new Error("No response from enhancer agent");
+    }
+    const trimmed = response.trim();
+    logger.debug(`RESPONSE FROM ENHANCER AGENT: '${trimmed}'`);
+    if (trimmed.toLowerCase().startsWith("permission denied:")) {
+      const errorMessage = trimmed.substring("permission denied:".length).trim();
+      throw new Error(`Permission denied: ${errorMessage}`);
+    }
+    if (trimmed.toLowerCase().includes("no enhancement needed")) {
+      return { enhanced: false };
+    }
+    const urlPattern = /https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/\d+#issuecomment-\d+/;
+    const match = trimmed.match(urlPattern);
+    if (match) {
+      return { enhanced: true, url: match[0] };
+    }
+    throw new Error(`Unexpected response from enhancer agent: ${trimmed}`);
+  }
+  /**
+   * Prompt user and open browser to view enhanced issue.
+   * Matches the pattern from the issue specification.
+   */
+  async promptAndOpenBrowser(commentUrl) {
+    try {
+      const key = await waitForKeypress(
+        "Press q to quit or any other key to view the enhanced issue in a web browser..."
+      );
+      if (key.toLowerCase() === "q") {
+        logger.info("Skipping browser opening");
+        return;
+      }
+      await openBrowser(commentUrl);
+    } catch (error) {
+      logger.warn(`Failed to open browser: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+};
+
+// src/lib/ValidationRunner.ts
+var ValidationRunner = class {
+  /**
+   * Run all validations in sequence: typecheck → lint → test
+   * Fails fast on first error
+   */
+  async runValidations(worktreePath, options = {}) {
+    const startTime = Date.now();
+    const steps = [];
+    if (!options.skipTypecheck) {
+      const typecheckResult = await this.runTypecheck(
+        worktreePath,
+        options.dryRun ?? false
+      );
+      steps.push(typecheckResult);
+      if (!typecheckResult.passed && !typecheckResult.skipped) {
+        return {
+          success: false,
+          steps,
+          totalDuration: Date.now() - startTime
+        };
+      }
+    }
+    if (!options.skipLint) {
+      const lintResult = await this.runLint(worktreePath, options.dryRun ?? false);
+      steps.push(lintResult);
+      if (!lintResult.passed && !lintResult.skipped) {
+        return { success: false, steps, totalDuration: Date.now() - startTime };
+      }
+    }
+    if (!options.skipTests) {
+      const testResult = await this.runTests(
+        worktreePath,
+        options.dryRun ?? false
+      );
+      steps.push(testResult);
+      if (!testResult.passed && !testResult.skipped) {
+        return { success: false, steps, totalDuration: Date.now() - startTime };
+      }
+    }
+    return { success: true, steps, totalDuration: Date.now() - startTime };
+  }
+  /**
+   * Run typecheck validation
+   */
+  async runTypecheck(worktreePath, dryRun) {
+    const stepStartTime = Date.now();
+    try {
+      const pkgJson = await readPackageJson(worktreePath);
+      const hasTypecheckScript = hasScript(pkgJson, "typecheck");
+      if (!hasTypecheckScript) {
+        logger.debug("Skipping typecheck - no typecheck script found");
+        return {
+          step: "typecheck",
+          passed: true,
+          skipped: true,
+          duration: Date.now() - stepStartTime
+        };
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("package.json not found")) {
+        logger.debug("Skipping typecheck - no package.json found (non-Node.js project)");
+        return {
+          step: "typecheck",
+          passed: true,
+          skipped: true,
+          duration: Date.now() - stepStartTime
+        };
+      }
+      throw error;
+    }
+    const packageManager = await detectPackageManager(worktreePath);
+    if (dryRun) {
+      const command = packageManager === "npm" ? "npm run typecheck" : `${packageManager} typecheck`;
+      logger.info(`[DRY RUN] Would run: ${command}`);
+      return {
+        step: "typecheck",
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    }
+    logger.info("Running typecheck...");
+    try {
+      await runScript("typecheck", worktreePath, [], { quiet: true });
+      logger.success("Typecheck passed");
+      return {
+        step: "typecheck",
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    } catch {
+      const fixed = await this.attemptClaudeFix(
+        "typecheck",
+        worktreePath,
+        packageManager
+      );
+      if (fixed) {
+        return {
+          step: "typecheck",
+          passed: true,
+          skipped: false,
+          duration: Date.now() - stepStartTime
+        };
+      }
+      const runCommand = packageManager === "npm" ? "npm run typecheck" : `${packageManager} typecheck`;
+      throw new Error(
+        `Error: Typecheck failed.
+Fix type errors before merging.
+
+Run '${runCommand}' to see detailed errors.`
+      );
+    }
+  }
+  /**
+   * Run lint validation
+   */
+  async runLint(worktreePath, dryRun) {
+    const stepStartTime = Date.now();
+    try {
+      const pkgJson = await readPackageJson(worktreePath);
+      const hasLintScript = hasScript(pkgJson, "lint");
+      if (!hasLintScript) {
+        logger.debug("Skipping lint - no lint script found");
+        return {
+          step: "lint",
+          passed: true,
+          skipped: true,
+          duration: Date.now() - stepStartTime
+        };
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("package.json not found")) {
+        logger.debug("Skipping lint - no package.json found (non-Node.js project)");
+        return {
+          step: "lint",
+          passed: true,
+          skipped: true,
+          duration: Date.now() - stepStartTime
+        };
+      }
+      throw error;
+    }
+    const packageManager = await detectPackageManager(worktreePath);
+    if (dryRun) {
+      const command = packageManager === "npm" ? "npm run lint" : `${packageManager} lint`;
+      logger.info(`[DRY RUN] Would run: ${command}`);
+      return {
+        step: "lint",
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    }
+    logger.info("Running lint...");
+    try {
+      await runScript("lint", worktreePath, [], { quiet: true });
+      logger.success("Linting passed");
+      return {
+        step: "lint",
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    } catch {
+      const fixed = await this.attemptClaudeFix(
+        "lint",
+        worktreePath,
+        packageManager
+      );
+      if (fixed) {
+        return {
+          step: "lint",
+          passed: true,
+          skipped: false,
+          duration: Date.now() - stepStartTime
+        };
+      }
+      const runCommand = packageManager === "npm" ? "npm run lint" : `${packageManager} lint`;
+      throw new Error(
+        `Error: Linting failed.
+Fix linting errors before merging.
+
+Run '${runCommand}' to see detailed errors.`
+      );
+    }
+  }
+  /**
+   * Run test validation
+   */
+  async runTests(worktreePath, dryRun) {
+    const stepStartTime = Date.now();
+    try {
+      const pkgJson = await readPackageJson(worktreePath);
+      const hasTestScript = hasScript(pkgJson, "test");
+      if (!hasTestScript) {
+        logger.debug("Skipping tests - no test script found");
+        return {
+          step: "test",
+          passed: true,
+          skipped: true,
+          duration: Date.now() - stepStartTime
+        };
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("package.json not found")) {
+        logger.debug("Skipping tests - no package.json found (non-Node.js project)");
+        return {
+          step: "test",
+          passed: true,
+          skipped: true,
+          duration: Date.now() - stepStartTime
+        };
+      }
+      throw error;
+    }
+    const packageManager = await detectPackageManager(worktreePath);
+    if (dryRun) {
+      const command = packageManager === "npm" ? "npm run test" : `${packageManager} test`;
+      logger.info(`[DRY RUN] Would run: ${command}`);
+      return {
+        step: "test",
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    }
+    logger.info("Running tests...");
+    try {
+      await runScript("test", worktreePath, [], { quiet: true });
+      logger.success("Tests passed");
+      return {
+        step: "test",
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    } catch {
+      const fixed = await this.attemptClaudeFix(
+        "test",
+        worktreePath,
+        packageManager
+      );
+      if (fixed) {
+        return {
+          step: "test",
+          passed: true,
+          skipped: false,
+          duration: Date.now() - stepStartTime
+        };
+      }
+      const runCommand = packageManager === "npm" ? "npm run test" : `${packageManager} test`;
+      throw new Error(
+        `Error: Tests failed.
+Fix test failures before merging.
+
+Run '${runCommand}' to see detailed errors.`
+      );
+    }
+  }
+  /**
+   * Attempt to fix validation errors using Claude
+   * Pattern based on MergeManager.attemptClaudeConflictResolution
+   *
+   * @param validationType - Type of validation that failed ('typecheck' | 'lint' | 'test')
+   * @param worktreePath - Path to the worktree
+   * @param packageManager - Detected package manager
+   * @returns true if Claude fixed the issue, false otherwise
+   */
+  async attemptClaudeFix(validationType, worktreePath, packageManager) {
+    const isClaudeAvailable = await detectClaudeCli();
+    if (!isClaudeAvailable) {
+      logger.debug("Claude CLI not available, skipping auto-fix");
+      return false;
+    }
+    const validationCommand = this.getValidationCommand(validationType, packageManager);
+    const prompt = this.getClaudePrompt(validationType, validationCommand);
+    const validationTypeCapitalized = validationType.charAt(0).toUpperCase() + validationType.slice(1);
+    logger.info(`Launching Claude to help fix ${validationTypeCapitalized} errors...`);
+    try {
+      await launchClaude(prompt, {
+        addDir: worktreePath,
+        headless: false,
+        // Interactive mode
+        permissionMode: "acceptEdits",
+        // Auto-accept edits
+        model: "sonnet"
+        // Use Sonnet model
+      });
+      logger.info(`Re-running ${validationTypeCapitalized} after Claude's fixes...`);
+      try {
+        await runScript(validationType, worktreePath, [], { quiet: true });
+        logger.success(`${validationTypeCapitalized} passed after Claude auto-fix`);
+        return true;
+      } catch {
+        logger.warn(`${validationTypeCapitalized} still failing after Claude's help`);
+        return false;
+      }
+    } catch (error) {
+      logger.warn("Claude auto-fix failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+  /**
+   * Get validation command string for prompts
+   */
+  getValidationCommand(validationType, packageManager) {
+    if (packageManager === "npm") {
+      return `npm run ${validationType}`;
+    }
+    return `${packageManager} ${validationType}`;
+  }
+  /**
+   * Get Claude prompt for specific validation type
+   * Matches bash script prompts exactly
+   */
+  getClaudePrompt(validationType, validationCommand) {
+    switch (validationType) {
+      case "typecheck":
+        return `There are TypeScript errors in this codebase. Please analyze the typecheck output, identify all type errors, and fix them. Run '${validationCommand}' to see the errors, then make the necessary code changes to resolve all type issues. When you are done, tell the user to quit using /exit to continue the validation process.`;
+      case "lint":
+        return `There are ESLint errors in this codebase. Please analyze the linting output, identify all linting issues, and fix them. Run '${validationCommand}' to see the errors, then make the necessary code changes to resolve all linting issues. Focus on code quality, consistency, and following the project's linting rules. When you are done, tell the user to quit using /exit to continue the validation process.`;
+      case "test":
+        return `There are unit test failures in this codebase. Please analyze the test output to understand what's failing, then fix the issues. This might involve updating test code, fixing bugs in the source code, or updating tests to match new behavior. Run '${validationCommand}' to see the detailed test failures, then make the necessary changes to get all tests passing. When you are done, tell the user to quit using /exit to continue the validation process.`;
+    }
+  }
+};
+
+// src/lib/CommitManager.ts
+var CommitManager = class {
+  /**
+   * Detect uncommitted changes in a worktree
+   * Parses git status --porcelain output into structured GitStatus
+   */
+  async detectUncommittedChanges(worktreePath) {
+    const porcelainOutput = await executeGitCommand(["status", "--porcelain"], {
+      cwd: worktreePath
+    });
+    const { stagedFiles, unstagedFiles } = this.parseGitStatus(porcelainOutput);
+    const currentBranch = await executeGitCommand(["branch", "--show-current"], {
+      cwd: worktreePath
+    });
+    return {
+      hasUncommittedChanges: stagedFiles.length > 0 || unstagedFiles.length > 0,
+      unstagedFiles,
+      stagedFiles,
+      currentBranch: currentBranch.trim(),
+      // Defer these to future enhancement
+      isAheadOfRemote: false,
+      isBehindRemote: false
+    };
+  }
+  /**
+   * Stage all changes and commit with Claude-generated or simple message
+   * Tries Claude first, falls back to simple message if Claude unavailable or fails
+   */
+  async commitChanges(worktreePath, options) {
+    if (options.dryRun) {
+      logger.info("[DRY RUN] Would run: git add -A");
+      logger.info("[DRY RUN] Would generate commit message with Claude (if available)");
+      const fallbackMessage = this.generateFallbackMessage(options);
+      const verifyFlag = options.skipVerify ? " --no-verify" : "";
+      logger.info(`[DRY RUN] Would commit with message${verifyFlag}: ${fallbackMessage}`);
+      return;
+    }
+    await executeGitCommand(["add", "-A"], { cwd: worktreePath });
+    let message = null;
+    if (!options.message) {
+      try {
+        message = await this.generateClaudeCommitMessage(worktreePath, options.issueNumber);
+      } catch (error) {
+        logger.debug("Claude commit message generation failed, using fallback", { error });
+      }
+    }
+    message ??= this.generateFallbackMessage(options);
+    if (options.skipVerify) {
+      logger.warn("\u26A0\uFE0F  Skipping pre-commit hooks (--no-verify configured in settings)");
+    }
+    try {
+      if (options.noReview || options.message) {
+        const commitArgs = ["commit", "-m", message];
+        if (options.skipVerify) {
+          commitArgs.push("--no-verify");
+        }
+        await executeGitCommand(commitArgs, { cwd: worktreePath });
+      } else {
+        logger.info("Opening git editor for commit message review...");
+        const commitArgs = ["commit", "-e", "-m", message];
+        if (options.skipVerify) {
+          commitArgs.push("--no-verify");
+        }
+        await executeGitCommand(commitArgs, {
+          cwd: worktreePath,
+          stdio: "inherit",
+          timeout: 3e5
+          // 5 minutes for interactive editing
+        });
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("nothing to commit")) {
+        logger.info("No changes to commit");
+        return;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Generate simple fallback commit message when Claude unavailable
+   * Used as fallback for Claude-powered commit messages
+   */
+  generateFallbackMessage(options) {
+    if (options.message) {
+      return options.message;
+    }
+    if (options.issueNumber) {
+      return `WIP: Auto-commit for issue #${options.issueNumber}
+
+Fixes #${options.issueNumber}`;
+    } else {
+      return "WIP: Auto-commit uncommitted changes";
+    }
+  }
+  /**
+   * Parse git status --porcelain output
+   * Format: "XY filename" where X=index, Y=worktree
+   * Examples:
+   *   "M  file.ts" - staged modification
+   *   " M file.ts" - unstaged modification
+   *   "MM file.ts" - both staged and unstaged
+   *   "?? file.ts" - untracked
+   */
+  parseGitStatus(porcelainOutput) {
+    const stagedFiles = [];
+    const unstagedFiles = [];
+    if (!porcelainOutput.trim()) {
+      return { stagedFiles, unstagedFiles };
+    }
+    const lines = porcelainOutput.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      if (line.length < 3) continue;
+      const indexStatus = line[0];
+      const worktreeStatus = line[1];
+      const filename = line.substring(3);
+      if (indexStatus !== " " && indexStatus !== "?") {
+        stagedFiles.push(filename);
+      }
+      if (worktreeStatus !== " " || line.startsWith("??")) {
+        unstagedFiles.push(filename);
+      }
+    }
+    return { stagedFiles, unstagedFiles };
+  }
+  /**
+   * Generate commit message using Claude AI
+   * Claude examines the git repository directly via --add-dir option
+   * Returns null if Claude unavailable or fails validation
+   */
+  async generateClaudeCommitMessage(worktreePath, issueNumber) {
+    const startTime = Date.now();
+    logger.info("Starting Claude commit message generation...", {
+      worktreePath: worktreePath.split("/").pop(),
+      // Just show the folder name for privacy
+      issueNumber
+    });
+    logger.debug("Checking Claude CLI availability...");
+    const isClaudeAvailable = await detectClaudeCli();
+    if (!isClaudeAvailable) {
+      logger.info("Claude CLI not available, skipping Claude commit message generation");
+      return null;
+    }
+    logger.debug("Claude CLI is available");
+    logger.debug("Building commit message prompt...");
+    const prompt = this.buildCommitMessagePrompt(issueNumber);
+    logger.debug("Prompt built", { promptLength: prompt.length });
+    logger.debug("Claude prompt content:", {
+      prompt,
+      truncatedPreview: prompt.substring(0, 500) + (prompt.length > 500 ? "...[truncated]" : "")
+    });
+    try {
+      logger.info("Calling Claude CLI for commit message generation...");
+      const claudeStartTime = Date.now();
+      const claudeOptions = {
+        headless: true,
+        addDir: worktreePath,
+        model: "claude-haiku-4-5-20251001",
+        // Fast, cost-effective model
+        timeout: 12e4
+        // 120 second timeout
+      };
+      logger.debug("Claude CLI call parameters:", {
+        options: claudeOptions,
+        worktreePathForAnalysis: worktreePath,
+        addDirContents: "Will include entire worktree directory for analysis"
+      });
+      const result = await launchClaude(prompt, claudeOptions);
+      const claudeDuration = Date.now() - claudeStartTime;
+      logger.debug("Claude API call completed", { duration: `${claudeDuration}ms` });
+      if (typeof result !== "string") {
+        logger.warn("Claude returned non-string result", { resultType: typeof result });
+        return null;
+      }
+      logger.debug("Raw Claude output received", {
+        outputLength: result.length,
+        preview: result.substring(0, 200) + (result.length > 200 ? "..." : "")
+      });
+      logger.debug("Sanitizing Claude output...");
+      const sanitized = this.sanitizeClaudeOutput(result);
+      logger.debug("Output sanitized", {
+        originalLength: result.length,
+        sanitizedLength: sanitized.length,
+        sanitized: sanitized.substring(0, 200) + (sanitized.length > 200 ? "..." : "")
+      });
+      if (!sanitized) {
+        logger.warn("Claude returned empty message after sanitization");
+        return null;
+      }
+      let finalMessage = sanitized;
+      if (issueNumber) {
+        if (!finalMessage.includes(`Fixes #${issueNumber}`)) {
+          finalMessage = `${finalMessage}
+
+Fixes #${issueNumber}`;
+          logger.debug(`Added "Fixes #${issueNumber}" trailer to commit message`);
+        } else {
+          logger.debug(`"Fixes #${issueNumber}" already present in commit message`);
+        }
+      }
+      const totalDuration = Date.now() - startTime;
+      logger.info("Claude commit message generated successfully", {
+        message: finalMessage,
+        totalDuration: `${totalDuration}ms`,
+        claudeApiDuration: `${claudeDuration}ms`
+      });
+      return finalMessage;
+    } catch (error) {
+      const totalDuration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      if (errorMessage.includes("timed out") || errorMessage.includes("timeout")) {
+        logger.warn("Claude commit message generation timed out after 45 seconds", {
+          totalDuration: `${totalDuration}ms`,
+          worktreePath: worktreePath.split("/").pop()
+        });
+      } else {
+        logger.warn("Failed to generate commit message with Claude", {
+          error: errorMessage,
+          totalDuration: `${totalDuration}ms`,
+          worktreePath: worktreePath.split("/").pop()
+        });
+      }
+      return null;
+    }
+  }
+  /**
+   * Build structured XML prompt for commit message generation
+   * Uses XML format for clear task definition and output expectations
+   */
+  buildCommitMessagePrompt(issueNumber) {
+    const issueContext = issueNumber ? `
+<IssueContext>
+This commit is associated with GitHub issue #${issueNumber}.
+If the changes appear to resolve the issue, include "Fixes #${issueNumber}" at the end of the first line of commit message.
+</IssueContext>` : "";
+    return `<Task>
+You are a software engineer writing a commit message for this repository.
+Examine the staged changes in the git repository and generate a concise, meaningful commit message.
+</Task>
+
+<Requirements>
+<Format>The first line must be a brief summary of the changes made as a full sentence. If it references an issue, include "Fixes #N" at the end of this line.
+
+Add 2 newlines, then add a bullet-point form description of the changes made, each change on a new line.</Format>
+<Mood>Use imperative mood (e.g., "Add feature" not "Added feature")</Mood>
+<Focus>Be specific about what was changed and why</Focus>
+<Conciseness>Keep message under 72 characters for subject line when possible</Conciseness>
+<NoMeta>CRITICAL: Do NOT include ANY explanatory text, analysis, or meta-commentary. Output ONLY the raw commit message.</NoMeta>
+<Examples>
+Good: "Add user authentication with JWT tokens. Fixes #42
+
+- Implement login and registration endpoints
+- Secure routes with JWT middleware
+- Update user model to store hashed passwords"
+Good: "Fix navigation bug in sidebar menu."
+Bad: "Based on the changes, I'll create: Add user authentication"
+Bad: "Looking at the files, this commit should be: Fix navigation bug"
+</Examples>
+${issueContext}
+</Requirements>
+
+<Output>
+IMPORTANT: Your entire response will be used directly as the git commit message.
+Do not include any explanatory text before or after the commit message.
+Start your response immediately with the commit message text.
+</Output>`;
+  }
+  /**
+   * Sanitize Claude output to remove meta-commentary and clean formatting
+   * Handles cases where Claude includes explanatory text despite instructions
+   */
+  sanitizeClaudeOutput(rawOutput) {
+    let cleaned = rawOutput.trim();
+    const metaPatterns = [
+      /^.*?based on.*?changes.*?:/i,
+      /^.*?looking at.*?files.*?:/i,
+      /^.*?examining.*?:/i,
+      /^.*?analyzing.*?:/i,
+      /^.*?i'll.*?generate.*?:/i,
+      /^.*?let me.*?:/i,
+      /^.*?the commit message.*?should be.*?:/i,
+      /^.*?here.*?is.*?commit.*?message.*?:/i
+    ];
+    for (const pattern of metaPatterns) {
+      cleaned = cleaned.replace(pattern, "").trim();
+    }
+    if (cleaned.includes(":")) {
+      const colonIndex = cleaned.indexOf(":");
+      const beforeColon = cleaned.substring(0, colonIndex).trim().toLowerCase();
+      const metaIndicators = [
+        "here is the commit message",
+        "commit message",
+        "here is",
+        "the message should be",
+        "i suggest",
+        "my suggestion"
+      ];
+      const isMetaCommentary = metaIndicators.some((indicator) => beforeColon.includes(indicator));
+      if (isMetaCommentary) {
+        const afterColon = cleaned.substring(colonIndex + 1).trim();
+        if (afterColon && afterColon.length > 10) {
+          cleaned = afterColon;
+        }
+      }
+    }
+    if (cleaned.startsWith('"') && cleaned.endsWith('"') || cleaned.startsWith("'") && cleaned.endsWith("'")) {
+      cleaned = cleaned.slice(1, -1).trim();
+    }
+    return cleaned;
+  }
+};
+
+// src/lib/BuildRunner.ts
+var BuildRunner = class {
+  constructor(capabilityDetector) {
+    this.capabilityDetector = capabilityDetector ?? new ProjectCapabilityDetector();
+  }
+  /**
+   * Run build verification in the specified directory
+   * @param buildPath - Path where build should run (typically main worktree path)
+   * @param options - Build options
+   */
+  async runBuild(buildPath, options = {}) {
+    const startTime = Date.now();
+    try {
+      const pkgJson = await readPackageJson(buildPath);
+      const hasBuildScript = hasScript(pkgJson, "build");
+      if (!hasBuildScript) {
+        logger.debug("Skipping build - no build script found");
+        return {
+          success: true,
+          skipped: true,
+          reason: "No build script found in package.json",
+          duration: Date.now() - startTime
+        };
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("package.json not found")) {
+        logger.debug("Skipping build - no package.json found (non-Node.js project)");
+        return {
+          success: true,
+          skipped: true,
+          reason: "No package.json found in project",
+          duration: Date.now() - startTime
+        };
+      }
+      throw error;
+    }
+    const capabilities = await this.capabilityDetector.detectCapabilities(buildPath);
+    const isCLIProject = capabilities.capabilities.includes("cli");
+    if (!isCLIProject) {
+      logger.debug("Skipping build - not a CLI project (no bin field)");
+      return {
+        success: true,
+        skipped: true,
+        reason: "Project is not a CLI project (no bin field in package.json)",
+        duration: Date.now() - startTime
+      };
+    }
+    const packageManager = await detectPackageManager(buildPath);
+    if (options.dryRun) {
+      const command = packageManager === "npm" ? "npm run build" : `${packageManager} build`;
+      logger.info(`[DRY RUN] Would run: ${command}`);
+      return {
+        success: true,
+        skipped: false,
+        duration: Date.now() - startTime
+      };
+    }
+    logger.info("Running build...");
+    try {
+      await runScript("build", buildPath, [], { quiet: true });
+      logger.success("Build completed successfully");
+      return {
+        success: true,
+        skipped: false,
+        duration: Date.now() - startTime
+      };
+    } catch {
+      const runCommand = packageManager === "npm" ? "npm run build" : `${packageManager} build`;
+      throw new Error(
+        `Error: Build failed.
+Fix build errors before proceeding.
+
+Run '${runCommand}' to see detailed errors.`
+      );
+    }
+  }
+};
+
+// src/lib/PRManager.ts
+var PRManager = class {
+  constructor(settings) {
+    this.settings = settings;
+  }
+  /**
+   * Check if a PR already exists for the given branch
+   * @param branchName - Branch to check
+   * @param cwd - Working directory
+   * @returns Existing PR info or null if none found
+   */
+  async checkForExistingPR(branchName, cwd) {
+    try {
+      const prList = await executeGhCommand(
+        ["pr", "list", "--head", branchName, "--state", "open", "--json", "number,url"],
+        cwd ? { cwd } : void 0
+      );
+      if (prList.length > 0) {
+        return prList[0] ?? null;
+      }
+      return null;
+    } catch (error) {
+      logger.debug("Error checking for existing PR", { error });
+      return null;
+    }
+  }
+  /**
+   * Generate PR body using Claude if available, otherwise use simple template
+   * @param issueNumber - Issue number to include in body
+   * @param worktreePath - Path to worktree for context
+   * @returns PR body markdown
+   */
+  async generatePRBody(issueNumber, worktreePath) {
+    const hasClaudeCli = await detectClaudeCli();
+    if (hasClaudeCli) {
+      try {
+        const prompt = this.buildPRBodyPrompt(issueNumber);
+        const body2 = await launchClaude(prompt, {
+          headless: true,
+          addDir: worktreePath,
+          timeout: 3e4
+        });
+        if (body2 && typeof body2 === "string" && body2.trim()) {
+          const sanitized = this.sanitizeClaudeOutput(body2);
+          if (sanitized) {
+            return sanitized;
+          }
+        }
+      } catch (error) {
+        logger.debug("Claude PR body generation failed, using template", { error });
+      }
+    }
+    let body = "This PR contains changes from the iloom workflow.\n\n";
+    if (issueNumber) {
+      body += `Fixes #${issueNumber}`;
+    }
+    return body;
+  }
+  /**
+   * Build structured XML prompt for PR body generation
+   * Uses XML format for clear task definition and output expectations
+   */
+  buildPRBodyPrompt(issueNumber) {
+    const issueContext = issueNumber ? `
+<IssueContext>
+This PR is associated with GitHub issue #${issueNumber}.
+Include "Fixes #${issueNumber}" at the end of the body on its own line.
+</IssueContext>` : "";
+    return `<Task>
+You are a software engineer writing a pull request body for this repository.
+Examine the changes in the git repository and generate a concise, professional PR description.
+</Task>
+
+<Requirements>
+<Format>Write 2-3 sentences summarizing what was changed and why.${issueNumber ? `
+
+End with "Fixes #${issueNumber}" on its own line.` : ""}</Format>
+<Tone>Professional and concise</Tone>
+<Focus>Summarize the changes and their purpose</Focus>
+<NoMeta>CRITICAL: Do NOT include ANY explanatory text, analysis, or meta-commentary. Output ONLY the raw PR body text.</NoMeta>
+<Examples>
+Good: "Add user authentication with JWT tokens to secure the API endpoints. This includes login and registration endpoints with proper password hashing.
+
+Fixes #42"
+Good: "Fix navigation bug in sidebar menu that caused incorrect highlighting on nested routes."
+Bad: "Here's the PR body:
+
+---
+
+Add user authentication..."
+Bad: "Based on the changes, I'll write: Fix navigation bug..."
+</Examples>
+${issueContext}
+</Requirements>
+
+<Output>
+IMPORTANT: Your entire response will be used directly as the GitHub pull request body.
+Do not include any explanatory text, headers, or separators before or after the body.
+Start your response immediately with the PR body text.
+</Output>`;
+  }
+  /**
+   * Sanitize Claude output to remove meta-commentary and clean formatting
+   * Handles cases where Claude includes explanatory text despite instructions
+   */
+  sanitizeClaudeOutput(rawOutput) {
+    let cleaned = rawOutput.trim();
+    const metaPatterns = [
+      /^.*?based on.*?changes.*?:/i,
+      /^.*?looking at.*?files.*?:/i,
+      /^.*?examining.*?:/i,
+      /^.*?analyzing.*?:/i,
+      /^.*?i'll.*?generate.*?:/i,
+      /^.*?let me.*?:/i,
+      /^.*?here.*?is.*?(?:the\s+)?(?:pr|pull request).*?body.*?:/i,
+      /^.*?here's.*?(?:the\s+)?(?:pr|pull request).*?body.*?:/i
+    ];
+    for (const pattern of metaPatterns) {
+      cleaned = cleaned.replace(pattern, "").trim();
+    }
+    cleaned = cleaned.replace(/^[-=]{3,}\s*/m, "").trim();
+    if (cleaned.includes(":")) {
+      const colonIndex = cleaned.indexOf(":");
+      const beforeColon = cleaned.substring(0, colonIndex).trim().toLowerCase();
+      const metaIndicators = [
+        "here is the pr body",
+        "here is the pull request body",
+        "pr body",
+        "pull request body",
+        "here is",
+        "here's",
+        "the body should be",
+        "i suggest",
+        "my suggestion"
+      ];
+      const isMetaCommentary = metaIndicators.some((indicator) => beforeColon.includes(indicator));
+      if (isMetaCommentary) {
+        const afterColon = cleaned.substring(colonIndex + 1).trim();
+        const afterSeparator = afterColon.replace(/^[-=]{3,}\s*/m, "").trim();
+        if (afterSeparator && afterSeparator.length > 10) {
+          cleaned = afterSeparator;
+        }
+      }
+    }
+    if (cleaned.startsWith('"') && cleaned.endsWith('"') || cleaned.startsWith("'") && cleaned.endsWith("'")) {
+      cleaned = cleaned.slice(1, -1).trim();
+    }
+    return cleaned;
+  }
+  /**
+   * Create a GitHub PR for the branch
+   * @param branchName - Branch to create PR from (used as --head)
+   * @param title - PR title
+   * @param body - PR body
+   * @param baseBranch - Base branch to target (usually main/master)
+   * @param cwd - Working directory
+   * @returns PR URL
+   */
+  async createPR(branchName, title, body, baseBranch, cwd) {
+    try {
+      const targetRemote = await getEffectivePRTargetRemote(this.settings, cwd);
+      let headValue = branchName;
+      if (targetRemote !== "origin") {
+        const remotes = await parseGitRemotes(cwd);
+        const originRemote = remotes.find((r) => r.name === "origin");
+        if (originRemote) {
+          headValue = `${originRemote.owner}:${branchName}`;
+          logger.debug(`Fork workflow detected, using head: ${headValue}`);
+        }
+      }
+      const args = ["pr", "create", "--head", headValue, "--title", title, "--body", body, "--base", baseBranch];
+      if (targetRemote !== "origin") {
+        const repo = await getConfiguredRepoFromSettings(this.settings, cwd);
+        args.push("--repo", repo);
+      }
+      const result = await executeGhCommand(args, cwd ? { cwd } : void 0);
+      const url = typeof result === "string" ? result.trim() : String(result).trim();
+      if (!url.includes("github.com") || !url.includes("/pull/")) {
+        throw new Error(`Unexpected response from gh pr create: ${url}`);
+      }
+      return url;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("Head sha can't be blank") || errorMessage.includes("No commits between")) {
+        throw new Error(
+          `Failed to create pull request: ${errorMessage}
+
+This error typically occurs when:
+  - The branch was not fully pushed to the remote
+  - There's a race condition between push and PR creation
+  - The branch has no commits ahead of the base branch
+
+Try running: git push -u origin ${branchName}
+Then retry: il finish`
+        );
+      }
+      throw new Error(`Failed to create pull request: ${errorMessage}`);
+    }
+  }
+  /**
+   * Open PR URL in browser
+   * @param url - PR URL to open
+   */
+  async openPRInBrowser(url) {
+    try {
+      await openBrowser(url);
+      logger.debug("Opened PR in browser", { url });
+    } catch (error) {
+      logger.warn("Failed to open PR in browser", { error });
+    }
+  }
+  /**
+   * Complete PR workflow: check for existing, create if needed, optionally open in browser
+   * @param branchName - Branch to create PR from
+   * @param title - PR title
+   * @param issueNumber - Optional issue number for body generation
+   * @param baseBranch - Base branch to target
+   * @param worktreePath - Path to worktree
+   * @param openInBrowser - Whether to open PR in browser
+   * @returns PR creation result
+   */
+  async createOrOpenPR(branchName, title, issueNumber, baseBranch, worktreePath, openInBrowser) {
+    const existingPR = await this.checkForExistingPR(branchName, worktreePath);
+    if (existingPR) {
+      logger.info(`Pull request already exists: ${existingPR.url}`);
+      if (openInBrowser) {
+        await this.openPRInBrowser(existingPR.url);
+      }
+      return {
+        url: existingPR.url,
+        number: existingPR.number,
+        wasExisting: true
+      };
+    }
+    const body = await this.generatePRBody(issueNumber, worktreePath);
+    logger.info("Creating pull request...");
+    const url = await this.createPR(branchName, title, body, baseBranch, worktreePath);
+    const prNumber = this.extractPRNumberFromUrl(url);
+    if (openInBrowser) {
+      await this.openPRInBrowser(url);
+    }
+    return {
+      url,
+      number: prNumber,
+      wasExisting: false
+    };
+  }
+  /**
+   * Extract PR number from GitHub PR URL
+   * @param url - PR URL (e.g., https://github.com/owner/repo/pull/123)
+   * @returns PR number
+   */
+  extractPRNumberFromUrl(url) {
+    const match = url.match(/\/pull\/(\d+)/);
+    if (match == null ? void 0 : match[1]) {
+      return parseInt(match[1], 10);
+    }
+    throw new Error(`Could not extract PR number from URL: ${url}`);
+  }
+};
+
+// src/commands/finish.ts
+import path3 from "path";
+var FinishCommand = class {
+  constructor(issueTracker, gitWorktreeManager, validationRunner, commitManager, mergeManager, identifierParser, resourceCleanup, buildRunner, settingsManager, loomManager) {
+    const envResult = loadEnvIntoProcess();
+    if (envResult.error) {
+      logger.debug(`Environment loading warning: ${envResult.error.message}`);
+    }
+    if (envResult.parsed) {
+      logger.debug(`Loaded ${Object.keys(envResult.parsed).length} environment variables`);
+    }
+    this.issueTracker = issueTracker;
+    this.gitWorktreeManager = gitWorktreeManager ?? new GitWorktreeManager();
+    this.validationRunner = validationRunner ?? new ValidationRunner();
+    this.commitManager = commitManager ?? new CommitManager();
+    this.mergeManager = mergeManager ?? new MergeManager();
+    this.identifierParser = identifierParser ?? new IdentifierParser(this.gitWorktreeManager);
+    this.settingsManager = settingsManager ?? new SettingsManager();
+    if (resourceCleanup) {
+      this.resourceCleanup = resourceCleanup;
+    }
+    this.buildRunner = buildRunner ?? new BuildRunner();
+    if (loomManager) {
+      this.loomManager = loomManager;
+    }
+  }
+  /**
+   * Lazy initialization of ResourceCleanup with properly configured DatabaseManager
+   */
+  async ensureResourceCleanup() {
+    var _a, _b;
+    if (this.resourceCleanup && this.loomManager) {
+      return;
+    }
+    const settings = await this.settingsManager.loadSettings();
+    const databaseUrlEnvVarName = ((_b = (_a = settings.capabilities) == null ? void 0 : _a.database) == null ? void 0 : _b.databaseUrlEnvVarName) ?? "DATABASE_URL";
+    const environmentManager = new EnvironmentManager();
+    const neonProvider = createNeonProviderFromSettings(settings);
+    const databaseManager = new DatabaseManager(neonProvider, environmentManager, databaseUrlEnvVarName);
+    const cliIsolationManager = new CLIIsolationManager();
+    const { DefaultBranchNamingService: DefaultBranchNamingService2 } = await import("./BranchNamingService-3OQPRSWT.js");
+    this.loomManager ??= new LoomManager(
+      this.gitWorktreeManager,
+      this.issueTracker,
+      new DefaultBranchNamingService2({ useClaude: true }),
+      environmentManager,
+      new ClaudeContextManager(),
+      new ProjectCapabilityDetector(),
+      cliIsolationManager,
+      this.settingsManager,
+      databaseManager
+    );
+    this.resourceCleanup ??= new ResourceCleanup(
+      this.gitWorktreeManager,
+      new ProcessManager(),
+      databaseManager,
+      cliIsolationManager
+    );
+  }
+  /**
+   * Check for child looms and exit gracefully if any exist
+   * Always checks the TARGET loom (the one being finished), not the current directory's loom
+   *
+   * @param parsed - The parsed input identifying the loom being finished
+   */
+  async checkForChildLooms(parsed) {
+    await this.ensureResourceCleanup();
+    if (!this.loomManager) {
+      throw new Error("Failed to initialize LoomManager");
+    }
+    let targetBranch;
+    if (parsed.branchName) {
+      targetBranch = parsed.branchName;
+    } else if (parsed.type === "issue" && parsed.number !== void 0) {
+      const worktree = await this.gitWorktreeManager.findWorktreeForIssue(parsed.number);
+      targetBranch = worktree == null ? void 0 : worktree.branch;
+    } else if (parsed.type === "pr" && parsed.number !== void 0) {
+      const prNumber = typeof parsed.number === "number" ? parsed.number : Number(parsed.number);
+      if (isNaN(prNumber) || !isFinite(prNumber)) {
+        throw new Error(`Invalid PR number: ${parsed.number}. PR numbers must be numeric.`);
+      }
+      const worktree = await this.gitWorktreeManager.findWorktreeForPR(prNumber, "");
+      targetBranch = worktree == null ? void 0 : worktree.branch;
+    }
+    if (!targetBranch) {
+      logger.debug(`Cannot determine target branch for child loom check`);
+      return;
+    }
+    const hasChildLooms = await this.loomManager.checkAndWarnChildLooms(targetBranch);
+    if (hasChildLooms) {
+      logger.error("Cannot finish loom while child looms exist. Please finish child looms first.");
+      process.exit(1);
+    }
+  }
+  /**
+   * Main entry point for finish command
+   */
+  async execute(input) {
+    try {
+      const settings = await this.settingsManager.loadSettings();
+      let repo;
+      const multipleRemotes = await hasMultipleRemotes();
+      if (multipleRemotes) {
+        repo = await getConfiguredRepoFromSettings(settings);
+        logger.info(`Using GitHub repository: ${repo}`);
+      }
+      const parsed = await this.parseInput(input.identifier, input.options);
+      await this.checkForChildLooms(parsed);
+      const worktrees = await this.validateInput(parsed, input.options, repo);
+      logger.info(`Validated input: ${this.formatParsedInput(parsed)}`);
+      const worktree = worktrees[0];
+      if (!worktree) {
+        throw new Error("No worktree found");
+      }
+      if (parsed.type === "pr") {
+        if (!parsed.number) {
+          throw new Error("Invalid PR number");
+        }
+        if (!this.issueTracker.supportsPullRequests || !this.issueTracker.fetchPR) {
+          throw new Error("Issue tracker does not support pull requests");
+        }
+        const pr = await this.issueTracker.fetchPR(parsed.number, repo);
+        await this.executePRWorkflow(parsed, input.options, worktree, pr);
+      } else {
+        await this.executeIssueWorkflow(parsed, input.options, worktree);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        logger.error(`${error.message}`);
+      } else {
+        logger.error("An unknown error occurred");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Parse input to determine type and extract relevant data
+   * Supports auto-detection from current directory when identifier is undefined
+   */
+  async parseInput(identifier, options) {
+    if (options.pr !== void 0) {
+      return {
+        type: "pr",
+        number: options.pr,
+        originalInput: `--pr ${options.pr}`,
+        autoDetected: false
+      };
+    }
+    if (identifier == null ? void 0 : identifier.trim()) {
+      return await this.parseExplicitInput(identifier.trim());
+    }
+    return await this.autoDetectFromCurrentDirectory();
+  }
+  /**
+   * Parse explicit identifier input using pattern-based detection
+   * (No GitHub API calls - uses IdentifierParser)
+   */
+  async parseExplicitInput(identifier) {
+    const prPattern = /^(?:pr|PR)[/-](\d+)$/;
+    const prMatch = identifier.match(prPattern);
+    if (prMatch == null ? void 0 : prMatch[1]) {
+      return {
+        type: "pr",
+        number: parseInt(prMatch[1], 10),
+        originalInput: identifier,
+        autoDetected: false
+      };
+    }
+    const parsed = await this.identifierParser.parseForPatternDetection(identifier);
+    if (parsed.type === "description") {
+      throw new Error("Description input type is not supported in finish command");
+    }
+    const result = {
+      type: parsed.type,
+      originalInput: parsed.originalInput,
+      autoDetected: false
+    };
+    if (parsed.number !== void 0) {
+      result.number = parsed.number;
+    }
+    if (parsed.branchName !== void 0) {
+      result.branchName = parsed.branchName;
+    }
+    return result;
+  }
+  /**
+   * Auto-detect PR or issue from current directory
+   * Ports logic from merge-current-issue.sh lines 30-52
+   */
+  async autoDetectFromCurrentDirectory() {
+    const currentDir = path3.basename(process.cwd());
+    const prPattern = /_pr_(\d+)$/;
+    const prMatch = currentDir.match(prPattern);
+    if (prMatch == null ? void 0 : prMatch[1]) {
+      const prNumber = parseInt(prMatch[1], 10);
+      logger.debug(`Auto-detected PR #${prNumber} from directory: ${currentDir}`);
+      return {
+        type: "pr",
+        number: prNumber,
+        originalInput: currentDir,
+        autoDetected: true
+      };
+    }
+    const issueNumber = extractIssueNumber(currentDir);
+    if (issueNumber !== null) {
+      logger.debug(
+        `Auto-detected issue #${issueNumber} from directory: ${currentDir}`
+      );
+      return {
+        type: "issue",
+        number: issueNumber,
+        originalInput: currentDir,
+        autoDetected: true
+      };
+    }
+    const repoInfo = await this.gitWorktreeManager.getRepoInfo();
+    const currentBranch = repoInfo.currentBranch;
+    if (!currentBranch) {
+      throw new Error(
+        "Could not auto-detect identifier. Please provide an issue number, PR number, or branch name.\nExpected directory pattern: feat/issue-XX-description OR worktree with _pr_N suffix"
+      );
+    }
+    const branchIssueNumber = extractIssueNumber(currentBranch);
+    if (branchIssueNumber !== null) {
+      logger.debug(
+        `Auto-detected issue #${branchIssueNumber} from branch: ${currentBranch}`
+      );
+      return {
+        type: "issue",
+        number: branchIssueNumber,
+        originalInput: currentBranch,
+        autoDetected: true
+      };
+    }
+    return {
+      type: "branch",
+      branchName: currentBranch,
+      originalInput: currentBranch,
+      autoDetected: true
+    };
+  }
+  /**
+   * Validate the parsed input based on its type
+   */
+  async validateInput(parsed, options, repo) {
+    switch (parsed.type) {
+      case "pr": {
+        if (!parsed.number) {
+          throw new Error("Invalid PR number");
+        }
+        if (!this.issueTracker.supportsPullRequests || !this.issueTracker.fetchPR) {
+          throw new Error("Issue tracker does not support pull requests");
+        }
+        const pr = await this.issueTracker.fetchPR(parsed.number);
+        logger.debug(`Validated PR #${parsed.number} (state: ${pr.state})`);
+        return await this.findWorktreeForIdentifier(parsed);
+      }
+      case "issue": {
+        if (!parsed.number) {
+          throw new Error("Invalid issue number");
+        }
+        const issue = await this.issueTracker.fetchIssue(parsed.number, repo);
+        if (issue.state === "closed" && !options.force) {
+          throw new Error(
+            `Issue #${parsed.number} is closed. Use --force to finish anyway.`
+          );
+        }
+        logger.debug(`Validated issue #${parsed.number} (state: ${issue.state})`);
+        return await this.findWorktreeForIdentifier(parsed);
+      }
+      case "branch": {
+        if (!parsed.branchName) {
+          throw new Error("Invalid branch name");
+        }
+        if (!this.isValidBranchName(parsed.branchName)) {
+          throw new Error(
+            "Invalid branch name. Use only letters, numbers, hyphens, underscores, and slashes"
+          );
+        }
+        logger.debug(`Validated branch name: ${parsed.branchName}`);
+        return await this.findWorktreeForIdentifier(parsed);
+      }
+      default: {
+        const unknownType = parsed;
+        throw new Error(`Unknown input type: ${unknownType.type}`);
+      }
+    }
+  }
+  /**
+   * Find worktree for the given identifier using specific methods based on type
+   * (uses precise pattern matching instead of broad substring matching)
+   * Throws error if not found
+   */
+  async findWorktreeForIdentifier(parsed) {
+    let worktree = null;
+    switch (parsed.type) {
+      case "pr": {
+        if (!parsed.number) {
+          throw new Error("Invalid PR number");
+        }
+        const prNumber = typeof parsed.number === "number" ? parsed.number : Number(parsed.number);
+        if (isNaN(prNumber) || !isFinite(prNumber)) {
+          throw new Error(`Invalid PR number: ${parsed.number}. PR numbers must be numeric.`);
+        }
+        worktree = await this.gitWorktreeManager.findWorktreeForPR(
+          prNumber,
+          ""
+        );
+        break;
+      }
+      case "issue": {
+        if (!parsed.number) {
+          throw new Error("Invalid issue number");
+        }
+        worktree = await this.gitWorktreeManager.findWorktreeForIssue(
+          parsed.number
+        );
+        break;
+      }
+      case "branch": {
+        if (!parsed.branchName) {
+          throw new Error("Invalid branch name");
+        }
+        worktree = await this.gitWorktreeManager.findWorktreeForBranch(
+          parsed.branchName
+        );
+        break;
+      }
+      default: {
+        const unknownType = parsed;
+        throw new Error(`Unknown input type: ${unknownType.type}`);
+      }
+    }
+    if (!worktree) {
+      throw new Error(
+        `No worktree found for ${this.formatParsedInput(parsed)}. Use 'il list' to see available worktrees.`
+      );
+    }
+    logger.debug(`Found worktree: ${worktree.path}`);
+    return [worktree];
+  }
+  /**
+   * Validate branch name format
+   */
+  isValidBranchName(branch) {
+    return /^[a-zA-Z0-9/_-]+$/.test(branch);
+  }
+  /**
+   * Format parsed input for display
+   */
+  formatParsedInput(parsed) {
+    const autoLabel = parsed.autoDetected ? " (auto-detected)" : "";
+    switch (parsed.type) {
+      case "pr":
+        return `PR #${parsed.number}${autoLabel}`;
+      case "issue":
+        return `Issue #${parsed.number}${autoLabel}`;
+      case "branch":
+        return `Branch '${parsed.branchName}'${autoLabel}`;
+      default:
+        return "Unknown input";
+    }
+  }
+  /**
+   * Execute workflow for issues and branches (merge into main)
+   * This is the traditional workflow: validate → commit → rebase → merge → cleanup
+   */
+  async executeIssueWorkflow(parsed, options, worktree) {
+    var _a, _b;
+    if (!options.dryRun) {
+      logger.info("Running pre-merge validations...");
+      await this.validationRunner.runValidations(worktree.path, {
+        dryRun: options.dryRun ?? false
+      });
+      logger.success("All validations passed");
+    } else {
+      logger.info("[DRY RUN] Would run pre-merge validations");
+    }
+    const gitStatus = await this.commitManager.detectUncommittedChanges(worktree.path);
+    if (gitStatus.hasUncommittedChanges) {
+      if (options.dryRun) {
+        logger.info("[DRY RUN] Would auto-commit uncommitted changes (validation passed)");
+      } else {
+        logger.info("Validation passed, auto-committing uncommitted changes...");
+        const settings2 = await this.settingsManager.loadSettings(worktree.path);
+        const skipVerify = ((_b = (_a = settings2.workflows) == null ? void 0 : _a.issue) == null ? void 0 : _b.noVerify) ?? false;
+        const commitOptions = {
+          dryRun: options.dryRun ?? false,
+          skipVerify
+        };
+        if (parsed.type === "issue" && parsed.number) {
+          commitOptions.issueNumber = parsed.number;
+        }
+        await this.commitManager.commitChanges(worktree.path, commitOptions);
+        logger.success("Changes committed successfully");
+      }
+    } else {
+      logger.debug("No uncommitted changes found");
+    }
+    const settings = await this.settingsManager.loadSettings(worktree.path);
+    const mergeBehavior = settings.mergeBehavior ?? { mode: "local" };
+    if (mergeBehavior.mode === "github-pr") {
+      await this.executeGitHubPRWorkflow(parsed, options, worktree, settings);
+      return;
+    }
+    logger.info("Rebasing branch on main...");
+    const mergeOptions = {
+      dryRun: options.dryRun ?? false,
+      force: options.force ?? false
+    };
+    await this.mergeManager.rebaseOnMain(worktree.path, mergeOptions);
+    logger.success("Branch rebased successfully");
+    logger.info("Performing fast-forward merge...");
+    await this.mergeManager.performFastForwardMerge(worktree.branch, worktree.path, mergeOptions);
+    logger.success("Fast-forward merge completed successfully");
+    if (options.dryRun) {
+      logger.info("[DRY RUN] Would install dependencies in main worktree");
+    } else {
+      logger.info("Installing dependencies in main worktree...");
+      const mainWorktreePath = await findMainWorktreePathWithSettings(worktree.path, this.settingsManager);
+      await installDependencies(mainWorktreePath, true, true);
+    }
+    if (!options.skipBuild) {
+      await this.runPostMergeBuild(worktree.path, options);
+    } else {
+      logger.debug("Skipping build verification (--skip-build flag provided)");
+    }
+    await this.performPostMergeCleanup(parsed, options, worktree);
+  }
+  /**
+   * Execute workflow for Pull Requests
+   * Behavior depends on PR state:
+   * - OPEN: Commit changes, push to remote, keep worktree active
+   * - CLOSED/MERGED: Skip to cleanup
+   */
+  async executePRWorkflow(parsed, options, worktree, pr) {
+    var _a, _b;
+    if (pr.state === "closed" || pr.state === "merged") {
+      logger.info(`PR #${parsed.number} is ${pr.state.toUpperCase()} - skipping to cleanup`);
+      const gitStatus = await this.commitManager.detectUncommittedChanges(worktree.path);
+      if (gitStatus.hasUncommittedChanges && !options.force) {
+        logger.warn("PR has uncommitted changes");
+        throw new Error(
+          "Cannot cleanup PR with uncommitted changes. Commit or stash changes, then run again with --force to cleanup anyway."
+        );
+      }
+      await this.performPRCleanup(parsed, options, worktree);
+      logger.success(`PR #${parsed.number} cleanup completed`);
+    } else {
+      logger.info(`PR #${parsed.number} is OPEN - will push changes and keep worktree active`);
+      const gitStatus = await this.commitManager.detectUncommittedChanges(worktree.path);
+      if (gitStatus.hasUncommittedChanges) {
+        if (options.dryRun) {
+          logger.info("[DRY RUN] Would commit uncommitted changes");
+        } else {
+          logger.info("Committing uncommitted changes...");
+          const settings = await this.settingsManager.loadSettings(worktree.path);
+          const skipVerify = ((_b = (_a = settings.workflows) == null ? void 0 : _a.pr) == null ? void 0 : _b.noVerify) ?? false;
+          await this.commitManager.commitChanges(worktree.path, {
+            dryRun: false,
+            skipVerify
+            // Do NOT pass issueNumber for PRs - no "Fixes #" trailer needed
+          });
+          logger.success("Changes committed");
+        }
+      } else {
+        logger.debug("No uncommitted changes found");
+      }
+      if (options.dryRun) {
+        logger.info(`[DRY RUN] Would push changes to origin/${pr.branch}`);
+      } else {
+        logger.info("Pushing changes to remote...");
+        await pushBranchToRemote(pr.branch, worktree.path, {
+          dryRun: false
+        });
+        logger.success(`Changes pushed to PR #${parsed.number}`);
+      }
+      logger.success(`PR #${parsed.number} updated successfully`);
+      logger.info("Worktree remains active for continued work");
+      logger.info(`To cleanup when done: il cleanup ${parsed.number}`);
+    }
+  }
+  /**
+   * Execute workflow for GitHub PR creation (github-pr merge mode)
+   * Validates → Commits → Pushes → Creates PR → Prompts for cleanup
+   */
+  async executeGitHubPRWorkflow(parsed, options, worktree, settings) {
+    if (options.dryRun) {
+      logger.info("[DRY RUN] Would push branch to origin");
+    } else {
+      logger.info("Pushing branch to origin...");
+      await pushBranchToRemote(worktree.branch, worktree.path, { dryRun: false });
+      logger.success("Branch pushed successfully");
+    }
+    const prManager = new PRManager(settings);
+    let prTitle = `Work from ${worktree.branch}`;
+    if (parsed.type === "issue" && parsed.number) {
+      try {
+        const issue = await this.issueTracker.fetchIssue(parsed.number);
+        prTitle = issue.title;
+      } catch (error) {
+        logger.debug("Could not fetch issue title, using branch name", { error });
+      }
+    }
+    if (options.dryRun) {
+      logger.info("[DRY RUN] Would create GitHub PR");
+      logger.info(`  Title: ${prTitle}`);
+      logger.info(`  Base: ${settings.mainBranch ?? "main"}`);
+    } else {
+      const baseBranch = settings.mainBranch ?? "main";
+      const openInBrowser = options.noBrowser !== true;
+      const result = await prManager.createOrOpenPR(
+        worktree.branch,
+        prTitle,
+        parsed.type === "issue" ? parsed.number : void 0,
+        baseBranch,
+        worktree.path,
+        openInBrowser
+      );
+      if (result.wasExisting) {
+        logger.success(`Existing pull request: ${result.url}`);
+      } else {
+        logger.success(`Pull request created: ${result.url}`);
+      }
+      await this.handlePRCleanupPrompt(parsed, options, worktree);
+    }
+  }
+  /**
+   * Handle cleanup prompt after PR creation
+   * Respects --cleanup and --no-cleanup flags, otherwise prompts user
+   */
+  async handlePRCleanupPrompt(parsed, options, worktree) {
+    if (options.cleanup === true) {
+      logger.info("Cleaning up worktree (--cleanup flag)...");
+      await this.performWorktreeCleanup(parsed, options, worktree);
+    } else if (options.cleanup === false) {
+      logger.info("Worktree kept active for continued work (--no-cleanup flag)");
+      logger.info(`To cleanup later: il cleanup ${parsed.originalInput}`);
+    } else {
+      logger.info("");
+      logger.info("PR created successfully. Would you like to clean up the worktree?");
+      logger.info(`  Worktree: ${worktree.path}`);
+      logger.info(`  Branch: ${worktree.branch}`);
+      logger.info("");
+      const shouldCleanup = await promptConfirmation(
+        "Clean up worktree now?",
+        false
+        // Default to keeping worktree (safer option)
+      );
+      if (shouldCleanup) {
+        await this.performWorktreeCleanup(parsed, options, worktree);
+      } else {
+        logger.info("Worktree kept active. Run `il cleanup` when ready.");
+      }
+    }
+  }
+  /**
+   * Perform worktree cleanup (used by GitHub PR workflow)
+   * Similar to performPostMergeCleanup but for PR workflow
+   */
+  async performWorktreeCleanup(parsed, options, worktree) {
+    const cleanupInput = {
+      type: parsed.type,
+      originalInput: parsed.originalInput,
+      ...parsed.number !== void 0 && { number: parsed.number },
+      ...parsed.branchName !== void 0 && { branchName: parsed.branchName }
+    };
+    const cleanupOptions = {
+      dryRun: options.dryRun ?? false,
+      deleteBranch: false,
+      // Don't delete branch - PR still needs it
+      keepDatabase: false,
+      // Clean up database
+      force: options.force ?? false
+    };
+    try {
+      logger.info("Starting worktree cleanup...");
+      await this.ensureResourceCleanup();
+      if (!this.resourceCleanup) {
+        throw new Error("Failed to initialize ResourceCleanup");
+      }
+      const result = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
+      this.reportCleanupResults(result);
+      if (!result.success) {
+        logger.warn("Some cleanup operations failed - manual cleanup may be required");
+        this.showManualCleanupInstructions(worktree);
+      } else {
+        logger.success("Worktree cleanup completed successfully");
+      }
+      if (this.isRunningFromWithinWorktree(worktree.path)) {
+        this.showTerminalCloseWarning(worktree);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      logger.warn(`Cleanup failed: ${errorMessage}`);
+      logger.warn("Manual cleanup may be required");
+      this.showManualCleanupInstructions(worktree);
+    }
+  }
+  /**
+   * Perform cleanup for closed/merged PRs
+   * Similar to performPostMergeCleanup but with different messaging
+   */
+  async performPRCleanup(parsed, options, worktree) {
+    const cleanupInput = {
+      type: parsed.type,
+      originalInput: parsed.originalInput,
+      ...parsed.number !== void 0 && { number: parsed.number },
+      ...parsed.branchName !== void 0 && { branchName: parsed.branchName }
+    };
+    const cleanupOptions = {
+      dryRun: options.dryRun ?? false,
+      deleteBranch: true,
+      // Delete branch for closed/merged PRs
+      keepDatabase: false,
+      force: options.force ?? false
+    };
+    try {
+      await this.ensureResourceCleanup();
+      if (!this.resourceCleanup) {
+        throw new Error("Failed to initialize ResourceCleanup");
+      }
+      const result = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
+      this.reportCleanupResults(result);
+      if (!result.success) {
+        logger.warn("Some cleanup operations failed - manual cleanup may be required");
+        this.showManualCleanupInstructions(worktree);
+      } else {
+        if (this.isRunningFromWithinWorktree(worktree.path)) {
+          this.showTerminalCloseWarning(worktree);
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      logger.warn(`Cleanup failed: ${errorMessage}`);
+      this.showManualCleanupInstructions(worktree);
+      throw error;
+    }
+  }
+  /**
+   * Run post-merge build verification for CLI projects
+   * Runs in main worktree to verify merged code builds successfully
+   */
+  async runPostMergeBuild(worktreePath, options) {
+    const mainWorktreePath = await findMainWorktreePathWithSettings(worktreePath, this.settingsManager);
+    if (options.dryRun) {
+      logger.info("[DRY RUN] Would run post-merge build");
+      return;
+    }
+    logger.info("Running post-merge build...");
+    const result = await this.buildRunner.runBuild(mainWorktreePath, {
+      dryRun: options.dryRun ?? false
+    });
+    if (result.skipped) {
+      logger.debug(`Build skipped: ${result.reason}`);
+    } else {
+      logger.success("Post-merge build completed successfully");
+    }
+  }
+  /**
+   * Perform post-merge cleanup operations
+   * Converts ParsedFinishInput to ParsedInput and calls ResourceCleanup
+   * Handles failures gracefully without throwing
+   */
+  async performPostMergeCleanup(parsed, options, worktree) {
+    await this.ensureResourceCleanup();
+    if (!this.loomManager) {
+      throw new Error("Failed to initialize LoomManager");
+    }
+    await this.checkForChildLooms(parsed);
+    const cleanupInput = {
+      type: parsed.type,
+      originalInput: parsed.originalInput,
+      ...parsed.number !== void 0 && { number: parsed.number },
+      ...parsed.branchName !== void 0 && { branchName: parsed.branchName }
+    };
+    const cleanupOptions = {
+      dryRun: options.dryRun ?? false,
+      deleteBranch: true,
+      // Delete branch after successful merge
+      keepDatabase: false,
+      // Clean up database after merge
+      force: options.force ?? false
+    };
+    try {
+      logger.info("Starting post-merge cleanup...");
+      if (!this.resourceCleanup) {
+        throw new Error("Failed to initialize ResourceCleanup");
+      }
+      const result = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
+      this.reportCleanupResults(result);
+      if (!result.success) {
+        logger.warn("Some cleanup operations failed - manual cleanup may be required");
+        this.showManualCleanupInstructions(worktree);
+      } else {
+        logger.success("Post-merge cleanup completed successfully");
+      }
+      if (this.isRunningFromWithinWorktree(worktree.path)) {
+        this.showTerminalCloseWarning(worktree);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      logger.warn(`Cleanup failed: ${errorMessage}`);
+      logger.warn("Merge completed successfully, but manual cleanup is required");
+      this.showManualCleanupInstructions(worktree);
+    }
+  }
+  /**
+   * Report cleanup operation results to user
+   */
+  reportCleanupResults(result) {
+    if (result.operations.length === 0) {
+      return;
+    }
+    logger.info("Cleanup operations:");
+    for (const op of result.operations) {
+      const status = op.success ? "\u2713" : "\u2717";
+      const message = op.error ? `${op.message}: ${op.error}` : op.message;
+      if (op.success) {
+        logger.info(`  ${status} ${message}`);
+      } else {
+        logger.warn(`  ${status} ${message}`);
+      }
+    }
+  }
+  /**
+   * Show manual cleanup instructions when cleanup fails
+   */
+  showManualCleanupInstructions(worktree) {
+    logger.info("\nManual cleanup commands:");
+    logger.info(`  1. Remove worktree: git worktree remove ${worktree.path}`);
+    logger.info(`  2. Delete branch: git branch -d ${worktree.branch}`);
+    logger.info(`  3. Check dev servers: lsof -i :PORT (and kill if needed)`);
+  }
+  /**
+   * Check if current working directory is within the target worktree
+   */
+  isRunningFromWithinWorktree(worktreePath) {
+    const normalizedCwd = path3.normalize(process.cwd());
+    const normalizedWorktree = path3.normalize(worktreePath);
+    return normalizedCwd.startsWith(normalizedWorktree);
+  }
+  /**
+   * Display warning to close terminal/IDE when running from within finished loom
+   */
+  showTerminalCloseWarning(worktree) {
+    logger.info("");
+    logger.info("You are currently in the directory of the loom that was just finished.");
+    logger.info("Please close this terminal and any IDE/terminal windows using this directory.");
+    logger.info(`Directory: ${worktree.path}`);
+  }
+};
+
 // src/utils/package-info.ts
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
@@ -42,6 +2461,10 @@ function getPackageInfo(scriptPath) {
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename = fileURLToPath2(import.meta.url);
 var packageJson = getPackageInfo(__filename);
+function parseIssueIdentifier(value) {
+  const parsed = parseInt(value, 10);
+  return !isNaN(parsed) && String(parsed) === value ? parsed : value;
+}
 program.name("iloom").description(packageJson.description).version(packageJson.version).option("--debug", "Enable debug output (default: based on ILOOM_DEBUG env var)").option("--completion", "Output shell completion script for current shell").option("--set <key=value>", "Override any setting using dot notation (repeatable, e.g., --set workflows.issue.startIde=false)").allowUnknownOption().hook("preAction", async (thisCommand) => {
   const options = thisCommand.opts();
   const envDebug = process.env.ILOOM_DEBUG === "true";
@@ -60,7 +2483,7 @@ program.name("iloom").description(packageJson.description).version(packageJson.v
   } catch {
   }
   try {
-    const { SettingsMigrationManager } = await import("./SettingsMigrationManager-MTQIMI54.js");
+    const { SettingsMigrationManager } = await import("./SettingsMigrationManager-AGIIIPDQ.js");
     const migrationManager = new SettingsMigrationManager();
     await migrationManager.migrateSettingsIfNeeded();
   } catch (error) {
@@ -76,11 +2499,10 @@ async function validateSettingsForCommand(command) {
     return;
   }
   try {
-    const { SettingsManager } = await import("./SettingsManager-SKLUVE3K.js");
     const settingsManager = new SettingsManager();
     const settings = await settingsManager.loadSettings();
-    const { hasMultipleRemotes } = await import("./remote-GJEZWRCC.js");
-    const multipleRemotes = await hasMultipleRemotes();
+    const { hasMultipleRemotes: hasMultipleRemotes2 } = await import("./remote-VUNCQZ6J.js");
+    const multipleRemotes = await hasMultipleRemotes2();
     if (multipleRemotes && !((_b = (_a = settings.issueManagement) == null ? void 0 : _a.github) == null ? void 0 : _b.remote)) {
       await autoLaunchInitForMultipleRemotes();
       return;
@@ -98,22 +2520,22 @@ async function autoLaunchInitForMultipleRemotes() {
   logger.info("iloom will now launch an interactive configuration session with Claude");
   logger.info("to help you select which remote to use for GitHub operations.");
   logger.info("");
-  const { waitForKeypress } = await import("./prompt-ANTQWHUF.js");
-  await waitForKeypress("Press any key to start configuration...");
+  const { waitForKeypress: waitForKeypress2 } = await import("./prompt-7INJ7YRU.js");
+  await waitForKeypress2("Press any key to start configuration...");
   logger.info("");
   try {
-    const { InitCommand } = await import("./init-UMKNHNV5.js");
+    const { InitCommand } = await import("./init-G3T64SC4.js");
     const initCommand = new InitCommand();
     const customInitialMessage = "Help me configure which git remote iloom should use for GitHub operations. I have multiple remotes and need to select the correct one.";
     await initCommand.execute(customInitialMessage);
     logger.info("");
     logger.info("Configuration complete! Continuing with your original command...");
     logger.info("");
-    const { SettingsManager } = await import("./SettingsManager-SKLUVE3K.js");
-    const settingsManager = new SettingsManager();
+    const { SettingsManager: SettingsManager2 } = await import("./SettingsManager-WHHFGSL7.js");
+    const settingsManager = new SettingsManager2();
     const settings = await settingsManager.loadSettings();
-    const { hasMultipleRemotes } = await import("./remote-GJEZWRCC.js");
-    const multipleRemotes = await hasMultipleRemotes();
+    const { hasMultipleRemotes: hasMultipleRemotes2 } = await import("./remote-VUNCQZ6J.js");
+    const multipleRemotes = await hasMultipleRemotes2();
     if (multipleRemotes && !((_b = (_a = settings.issueManagement) == null ? void 0 : _a.github) == null ? void 0 : _b.remote)) {
       logger.error("Configuration incomplete: GitHub remote is still not configured.");
       logger.info('Please run "iloom init" again and configure the GitHub remote setting.');
@@ -128,21 +2550,23 @@ async function autoLaunchInitForMultipleRemotes() {
 }
 var shellCompletion = new ShellCompletion();
 shellCompletion.init();
-program.command("start").alias("create").alias("up").description("Create isolated workspace for an issue/PR").argument("[identifier]", "Issue number, PR number, or branch name (optional - will prompt if not provided)").option("--claude", "Enable Claude integration (default: true)").option("--no-claude", "Disable Claude integration").option("--code", "Enable VSCode (default: true)").option("--no-code", "Disable VSCode").option("--dev-server", "Enable dev server in terminal (default: true)").option("--no-dev-server", "Disable dev server").option("--terminal", "Enable terminal without dev server (default: false)").option("--no-terminal", "Disable terminal").addOption(
+program.command("start").alias("create").alias("up").description("Create isolated workspace for an issue/PR").argument("[identifier]", "Issue number, PR number, or branch name (optional - will prompt if not provided)").option("--claude", "Enable Claude integration (default: true)").option("--no-claude", "Disable Claude integration").option("--code", "Enable VSCode (default: true)").option("--no-code", "Disable VSCode").option("--dev-server", "Enable dev server in terminal (default: true)").option("--no-dev-server", "Disable dev server").option("--terminal", "Enable terminal without dev server (default: false)").option("--no-terminal", "Disable terminal").option("--child-loom", "Force create as child loom (skip prompt)").option("--no-child-loom", "Force create as independent loom (skip prompt)").option("--body <text>", "Body text for issue (skips AI enhancement)").addOption(
   new Option("--one-shot <mode>", "One-shot automation mode").choices(["default", "noReview", "bypassPermissions"]).default("default")
 ).action(async (identifier, options) => {
   try {
     let finalIdentifier = identifier;
     if (!finalIdentifier) {
-      const { promptInput } = await import("./prompt-ANTQWHUF.js");
+      const { promptInput } = await import("./prompt-7INJ7YRU.js");
       finalIdentifier = await promptInput("Enter issue number, PR number (pr/123), or branch name");
       if (!(finalIdentifier == null ? void 0 : finalIdentifier.trim())) {
         logger.error("Identifier is required");
         process.exit(1);
       }
     }
-    const { StartCommand } = await import("./start-CT2ZEFP2.js");
-    const command = new StartCommand();
+    const settingsManager = new SettingsManager();
+    const settings = await settingsManager.loadSettings();
+    const issueTracker = IssueTrackerFactory.create(settings);
+    const command = new StartCommand(issueTracker, void 0, void 0, settingsManager);
     await command.execute({ identifier: finalIdentifier, options });
   } catch (error) {
     logger.error(`Failed to start workspace: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -151,8 +2575,11 @@ program.command("start").alias("create").alias("up").description("Create isolate
 });
 program.command("add-issue").alias("a").description("Create and enhance GitHub issue without starting workspace").argument("<description>", "Natural language description of the issue (>50 chars, >2 spaces)").action(async (description) => {
   try {
-    const { AddIssueCommand } = await import("./add-issue-X56V3XPB.js");
-    const command = new AddIssueCommand();
+    const settingsManager = new SettingsManager();
+    const settings = await settingsManager.loadSettings();
+    const issueTracker = IssueTrackerFactory.create(settings);
+    const enhancementService = new IssueEnhancementService(issueTracker, new AgentManager(), settingsManager);
+    const command = new AddIssueCommand(enhancementService, settingsManager);
     const issueNumber = await command.execute({
       description,
       options: {}
@@ -164,13 +2591,17 @@ program.command("add-issue").alias("a").description("Create and enhance GitHub i
     process.exit(1);
   }
 });
-program.command("feedback").alias("f").description("Submit feedback/bug report to iloom-cli repository").argument("<description>", "Natural language description of feedback (>50 chars, >2 spaces)").action(async (description) => {
+program.command("feedback").alias("f").description("Submit feedback/bug report to iloom-cli repository").argument("<description>", "Natural language description of feedback (>50 chars, >2 spaces)").option("--body <text>", "Body text for feedback (added after diagnostics)").action(async (description, options) => {
   try {
-    const { FeedbackCommand } = await import("./feedback-ZOUCCHN4.js");
+    const { FeedbackCommand } = await import("./feedback-N4ECWIPF.js");
     const command = new FeedbackCommand();
+    const feedbackOptions = {};
+    if (options.body !== void 0) {
+      feedbackOptions.body = options.body;
+    }
     const issueNumber = await command.execute({
       description,
-      options: {}
+      options: feedbackOptions
     });
     logger.success(`Feedback submitted as issue #${issueNumber} in iloom-cli repository`);
     process.exit(0);
@@ -179,10 +2610,12 @@ program.command("feedback").alias("f").description("Submit feedback/bug report t
     process.exit(1);
   }
 });
-program.command("enhance").description("Apply enhancement agent to existing GitHub issue").argument("<issue-number>", "GitHub issue number to enhance", parseInt).option("--no-browser", "Skip browser opening prompt").option("--author <username>", "GitHub username to tag in questions (for CI usage)").action(async (issueNumber, options) => {
+program.command("enhance").description("Apply enhancement agent to existing GitHub issue").argument("<issue-number>", "GitHub issue identifier to enhance", parseIssueIdentifier).option("--no-browser", "Skip browser opening prompt").option("--author <username>", "GitHub username to tag in questions (for CI usage)").action(async (issueNumber, options) => {
   try {
-    const { EnhanceCommand } = await import("./enhance-VGWUX474.js");
-    const command = new EnhanceCommand();
+    const settingsManager = new SettingsManager();
+    const settings = await settingsManager.loadSettings();
+    const issueTracker = IssueTrackerFactory.create(settings);
+    const command = new EnhanceCommand(issueTracker);
     await command.execute({
       issueNumber,
       options: {
@@ -197,10 +2630,12 @@ program.command("enhance").description("Apply enhancement agent to existing GitH
     process.exit(1);
   }
 });
-program.command("finish").alias("dn").description("Merge work and cleanup workspace").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").option("-f, --force", "Skip confirmation prompts").option("-n, --dry-run", "Preview actions without executing").option("--pr <number>", "Treat input as PR number", parseFloat).option("--skip-build", "Skip post-merge build verification").action(async (identifier, options) => {
+program.command("finish").alias("dn").description("Merge work and cleanup workspace").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").option("-f, --force", "Skip confirmation prompts").option("-n, --dry-run", "Preview actions without executing").option("--pr <number>", "Treat input as PR number", parseFloat).option("--skip-build", "Skip post-merge build verification").option("--no-browser", "Skip opening PR in browser (github-pr mode only)").option("--cleanup", "Clean up worktree after PR creation (github-pr mode only)").option("--no-cleanup", "Keep worktree after PR creation (github-pr mode only)").action(async (identifier, options) => {
   try {
-    const { FinishCommand } = await import("./finish-QJSK6Z7J.js");
-    const command = new FinishCommand();
+    const settingsManager = new SettingsManager();
+    const settings = await settingsManager.loadSettings();
+    const issueTracker = IssueTrackerFactory.create(settings);
+    const command = new FinishCommand(issueTracker);
     await command.execute({ identifier, options });
   } catch (error) {
     logger.error(`Failed to finish workspace: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -209,7 +2644,7 @@ program.command("finish").alias("dn").description("Merge work and cleanup worksp
 });
 program.command("rebase").description("Rebase current branch on main with Claude-assisted conflict resolution").option("-f, --force", "Skip confirmation prompts").option("-n, --dry-run", "Preview actions without executing").action(async (options) => {
   try {
-    const { RebaseCommand } = await import("./rebase-KBWFDZCN.js");
+    const { RebaseCommand } = await import("./rebase-Q7GMM7EI.js");
     const command = new RebaseCommand();
     await command.execute(options);
   } catch (error) {
@@ -221,7 +2656,7 @@ program.command("spin").alias("ignite").description("Launch Claude with auto-det
   new Option("--one-shot <mode>", "One-shot automation mode").choices(["default", "noReview", "bypassPermissions"]).default("default")
 ).action(async (options) => {
   try {
-    const { IgniteCommand } = await import("./ignite-HICLZEYU.js");
+    const { IgniteCommand } = await import("./ignite-VM64QO3J.js");
     const command = new IgniteCommand();
     await command.execute(options.oneShot ?? "default");
   } catch (error) {
@@ -232,7 +2667,7 @@ program.command("spin").alias("ignite").description("Launch Claude with auto-det
 program.command("open").description("Open workspace in browser or run CLI tool").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").allowUnknownOption().action(async (identifier, _options, command) => {
   try {
     const args = (command == null ? void 0 : command.args) ? command.args.slice(identifier ? 1 : 0) : [];
-    const { OpenCommand } = await import("./open-ETZUFSE4.js");
+    const { OpenCommand } = await import("./open-KXDXEKRZ.js");
     const cmd = new OpenCommand();
     const input = identifier ? { identifier, args } : { args };
     await cmd.execute(input);
@@ -244,7 +2679,7 @@ program.command("open").description("Open workspace in browser or run CLI tool")
 program.command("run").description("Run CLI tool or open workspace in browser").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").allowUnknownOption().action(async (identifier, _options, command) => {
   try {
     const args = (command == null ? void 0 : command.args) ? command.args.slice(identifier ? 1 : 0) : [];
-    const { RunCommand } = await import("./run-4SVQ3WEU.js");
+    const { RunCommand } = await import("./run-PAWJJCSX.js");
     const cmd = new RunCommand();
     const input = identifier ? { identifier, args } : { args };
     await cmd.execute(input);
@@ -255,7 +2690,7 @@ program.command("run").description("Run CLI tool or open workspace in browser").
 });
 program.command("cleanup").description("Remove workspaces").argument("[identifier]", "Branch name or issue number to cleanup (auto-detected)").option("-l, --list", "List all worktrees").option("-a, --all", "Remove all worktrees (interactive confirmation)").option("-i, --issue <number>", "Cleanup by issue number", parseInt).option("-f, --force", "Skip confirmations and force removal").option("--dry-run", "Show what would be done without doing it").action(async (identifier, options) => {
   try {
-    const { CleanupCommand } = await import("./cleanup-ZHROIBSQ.js");
+    const { CleanupCommand } = await import("./cleanup-7RWLBSLE.js");
     const command = new CleanupCommand();
     const input = {
       options: options ?? {}
@@ -289,15 +2724,25 @@ program.command("list").description("Show active workspaces").option("--json", "
       logger.info(`    Commit: ${formatted.commit}`);
     }
   } catch (error) {
+    if (error instanceof Error && error.message.includes("not a git repository")) {
+      if (options.json) {
+        console.log("[]");
+      } else {
+        logger.info("No worktrees found");
+      }
+      return;
+    }
     logger.error(`Failed to list worktrees: ${error instanceof Error ? error.message : "Unknown error"}`);
     process.exit(1);
   }
 });
-program.command("init").alias("config").description("Initialize iloom configuration and setup shell autocomplete").action(async () => {
+program.command("init").alias("config").description("Initialize iloom configuration and setup shell autocomplete").argument("[prompt]", 'Custom initial message to send to Claude (defaults to "Help me configure iloom settings.")').action(async (prompt) => {
   try {
-    const { InitCommand } = await import("./init-UMKNHNV5.js");
+    const { InitCommand } = await import("./init-G3T64SC4.js");
     const command = new InitCommand();
-    await command.execute();
+    const trimmedPrompt = prompt == null ? void 0 : prompt.trim();
+    const customPrompt = trimmedPrompt && trimmedPrompt.length > 0 ? trimmedPrompt : void 0;
+    await command.execute(customPrompt);
   } catch (error) {
     logger.error(`Failed to initialize: ${error instanceof Error ? error.message : "Unknown error"}`);
     process.exit(1);
@@ -305,7 +2750,7 @@ program.command("init").alias("config").description("Initialize iloom configurat
 });
 program.command("contribute").description("Set up local development environment for contributing to iloom").action(async () => {
   try {
-    const { ContributeCommand } = await import("./contribute-3MQJ3XAQ.js");
+    const { ContributeCommand } = await import("./contribute-BS2L4FZR.js");
     const command = new ContributeCommand();
     await command.execute();
   } catch (error) {
@@ -325,29 +2770,32 @@ program.command("update").description("Update iloom-cli to the latest version").
 });
 program.command("test-github").description("Test GitHub integration (Issue #3)").argument("<identifier>", "Issue number or PR number").option("--no-claude", "Skip Claude for branch name generation").action(async (identifier, options) => {
   try {
-    const { GitHubService } = await import("./GitHubService-LWP4GKGH.js");
+    const { GitHubService } = await import("./GitHubService-EBOETDIW.js");
+    const { DefaultBranchNamingService: DefaultBranchNamingService2 } = await import("./BranchNamingService-3OQPRSWT.js");
     logger.info("Testing GitHub Integration\n");
-    const service = new GitHubService(options.claude !== void 0 ? { useClaude: options.claude } : {});
+    const service = new GitHubService();
+    const branchNaming = new DefaultBranchNamingService2({ useClaude: options.claude !== false });
     logger.info("Detecting input type...");
     const detection = await service.detectInputType(identifier);
     logger.info(`   Type: ${detection.type}`);
-    logger.info(`   Number: ${detection.number}`);
+    logger.info(`   Identifier: ${detection.identifier}`);
     if (detection.type === "unknown") {
       logger.error("Could not detect if input is an issue or PR");
       process.exit(1);
     }
     logger.info("Fetching from GitHub...");
     if (detection.type === "issue") {
-      if (!detection.number) {
+      if (!detection.identifier) {
         throw new Error("Issue number not detected");
       }
-      const issue = await service.fetchIssue(detection.number);
+      const issueNumber = parseInt(detection.identifier, 10);
+      const issue = await service.fetchIssue(issueNumber);
       logger.success(`   Issue #${issue.number}: ${issue.title}`);
       logger.info(`   State: ${issue.state}`);
       logger.info(`   Labels: ${issue.labels.join(", ") || "none"}`);
       logger.info(`   URL: ${issue.url}`);
       logger.info("Generating branch name...");
-      const branchName = await service.generateBranchName({
+      const branchName = await branchNaming.generateBranchName({
         issueNumber: issue.number,
         title: issue.title
       });
@@ -356,10 +2804,11 @@ program.command("test-github").description("Test GitHub integration (Issue #3)")
       const context = service.extractContext(issue);
       logger.info(`   ${context.split("\n").join("\n   ")}`);
     } else {
-      if (!detection.number) {
+      if (!detection.identifier) {
         throw new Error("PR number not detected");
       }
-      const pr = await service.fetchPR(detection.number);
+      const prNumber = parseInt(detection.identifier, 10);
+      const pr = await service.fetchPR(prNumber);
       logger.success(`   PR #${pr.number}: ${pr.title}`);
       logger.info(`   State: ${pr.state}`);
       logger.info(`   Branch: ${pr.branch}`);
@@ -380,14 +2829,14 @@ program.command("test-github").description("Test GitHub integration (Issue #3)")
 });
 program.command("test-claude").description("Test Claude integration (Issue #10)").option("--detect", "Test Claude CLI detection").option("--version", "Get Claude CLI version").option("--branch <title>", "Test branch name generation with given title").option("--issue <number>", "Issue number for branch generation", "123").option("--launch <prompt>", "Launch Claude with a prompt (headless)").option("--interactive", "Launch Claude interactively (requires --launch)").option("--template <name>", "Test template loading").action(async (options) => {
   try {
-    const { detectClaudeCli, getClaudeVersion, generateBranchName, launchClaude } = await import("./claude-7LUVDZZ4.js");
-    const { PromptTemplateManager } = await import("./PromptTemplateManager-WII75TKH.js");
-    const { ClaudeService } = await import("./ClaudeService-55DQGB7T.js");
-    const { ClaudeContextManager } = await import("./ClaudeContextManager-JKR4WGNU.js");
+    const { detectClaudeCli: detectClaudeCli2, getClaudeVersion, generateBranchName, launchClaude: launchClaude2 } = await import("./claude-GOP6PFC7.js");
+    const { PromptTemplateManager } = await import("./PromptTemplateManager-A52RUAMS.js");
+    const { ClaudeService } = await import("./ClaudeService-HG4VQ7AW.js");
+    const { ClaudeContextManager: ClaudeContextManager2 } = await import("./ClaudeContextManager-MUQSDY2E.js");
     logger.info("Testing Claude Integration\n");
     if (options.detect) {
       logger.info("Detecting Claude CLI...");
-      const isAvailable = await detectClaudeCli();
+      const isAvailable = await detectClaudeCli2();
       if (isAvailable) {
         logger.success("   Claude CLI is available");
       } else {
@@ -416,11 +2865,11 @@ program.command("test-claude").description("Test Claude integration (Issue #10)"
       logger.info(`   Mode: ${options.interactive ? "Interactive" : "Headless"}`);
       if (options.interactive) {
         logger.info("   Launching Claude in new terminal...");
-        await launchClaude(options.launch, { headless: false });
+        await launchClaude2(options.launch, { headless: false });
         logger.info("   (Claude should open in a separate process)");
       } else {
         logger.info("   Waiting for response...");
-        const result = await launchClaude(options.launch, { headless: true });
+        const result = await launchClaude2(options.launch, { headless: true });
         if (result) {
           logger.success("   Response:");
           logger.info(`   ${result.split("\n").join("\n   ")}`);
@@ -443,7 +2892,7 @@ program.command("test-claude").description("Test Claude integration (Issue #10)"
     if (!options.detect && !options.version && !options.branch && !options.launch && !options.template) {
       logger.info("Running full Claude integration test suite...\n");
       logger.info("1. Testing Claude CLI detection...");
-      const isAvailable = await detectClaudeCli();
+      const isAvailable = await detectClaudeCli2();
       if (isAvailable) {
         logger.success("   Claude CLI is available");
       } else {
@@ -468,7 +2917,7 @@ program.command("test-claude").description("Test Claude integration (Issue #10)"
       new ClaudeService();
       logger.success("   Service initialized");
       logger.info("\n5. Testing ClaudeContextManager...");
-      const contextManager = new ClaudeContextManager();
+      const contextManager = new ClaudeContextManager2();
       await contextManager.prepareContext({
         type: "issue",
         identifier: 123,
@@ -494,7 +2943,7 @@ program.command("test-claude").description("Test Claude integration (Issue #10)"
       logger.info("\n7. Testing Claude launch (headless)...");
       logger.info('   Sending test prompt: "Say hello"');
       try {
-        const result = await launchClaude("Say hello", { headless: true });
+        const result = await launchClaude2("Say hello", { headless: true });
         if (result) {
           logger.success("   Claude responded successfully");
           logger.info(`   Response preview: ${result.substring(0, 100)}...`);
@@ -518,7 +2967,7 @@ program.command("test-claude").description("Test Claude integration (Issue #10)"
 });
 program.command("test-webserver").description("Test if a web server is running on a workspace port").argument("<issue-number>", "Issue number (port will be calculated as 3000 + issue number)", parseInt).option("--kill", "Kill the web server if detected").action(async (issueNumber, options) => {
   try {
-    const { TestWebserverCommand } = await import("./test-webserver-M2I3EV4J.js");
+    const { TestWebserverCommand } = await import("./test-webserver-DAHONWCS.js");
     const command = new TestWebserverCommand();
     await command.execute({ issueNumber, options });
   } catch (error) {
@@ -531,7 +2980,7 @@ program.command("test-webserver").description("Test if a web server is running o
 });
 program.command("test-git").description("Test Git integration - findMainWorktreePath() function (reads .iloom/settings.json)").action(async () => {
   try {
-    const { TestGitCommand } = await import("./test-git-MKZATGZN.js");
+    const { TestGitCommand } = await import("./test-git-3WDLNQCA.js");
     const command = new TestGitCommand();
     await command.execute();
   } catch (error) {
@@ -544,7 +2993,7 @@ program.command("test-git").description("Test Git integration - findMainWorktree
 });
 program.command("test-tabs").description("Test iTerm2 dual tab functionality - opens two tabs with test commands").action(async () => {
   try {
-    const { TestTabsCommand } = await import("./test-tabs-JRKY3QMM.js");
+    const { TestTabsCommand } = await import("./test-tabs-RXDBZ6J7.js");
     const command = new TestTabsCommand();
     await command.execute();
   } catch (error) {
@@ -557,7 +3006,7 @@ program.command("test-tabs").description("Test iTerm2 dual tab functionality - o
 });
 program.command("test-prefix").description("Test worktree prefix configuration - preview worktree paths (reads .iloom/settings.json)").action(async () => {
   try {
-    const { TestPrefixCommand } = await import("./test-prefix-ZNLWDI3K.js");
+    const { TestPrefixCommand } = await import("./test-prefix-EVGAWAJW.js");
     const command = new TestPrefixCommand();
     await command.execute();
   } catch (error) {
@@ -571,18 +3020,18 @@ program.command("test-prefix").description("Test worktree prefix configuration -
 program.command("test-neon").description("Test Neon integration and debug configuration").action(async () => {
   var _a;
   try {
-    const { SettingsManager } = await import("./SettingsManager-SKLUVE3K.js");
-    const { createNeonProviderFromSettings } = await import("./neon-helpers-ZVIRPKCI.js");
+    const { SettingsManager: SettingsManager2 } = await import("./SettingsManager-WHHFGSL7.js");
+    const { createNeonProviderFromSettings: createNeonProviderFromSettings2 } = await import("./neon-helpers-WPUACUVC.js");
     logger.info("Testing Neon Integration\n");
     logger.info("1. Settings Configuration:");
-    const settingsManager = new SettingsManager();
+    const settingsManager = new SettingsManager2();
     const settings = await settingsManager.loadSettings();
     const neonConfig = (_a = settings.databaseProviders) == null ? void 0 : _a.neon;
     logger.info(`   projectId: ${(neonConfig == null ? void 0 : neonConfig.projectId) ?? "(not configured)"}`);
     logger.info(`   parentBranch: ${(neonConfig == null ? void 0 : neonConfig.parentBranch) ?? "(not configured)"}`);
     logger.info("\n2. Creating NeonProvider...");
     try {
-      const neonProvider = createNeonProviderFromSettings(settings);
+      const neonProvider = createNeonProviderFromSettings2(settings);
       logger.success("   NeonProvider created successfully");
       logger.info("\n3. Testing Neon CLI availability...");
       const isAvailable = await neonProvider.isCliAvailable();