@iloom/cli 0.3.4 → 0.4.1

package/dist/{chunk-2IJEMXOB.js → chunk-IARWMDAX.js}

@@ -5,23 +5,31 @@ import {
 import {
   installDependencies,
   runScript
-} from "./chunk-ZT3YZB4K.js";
+} from "./chunk-VBFDVGAE.js";
 import {
   hasScript,
   readPackageJson
 } from "./chunk-2ZPFJQ3B.js";
 import {
   branchExists,
+  checkRemoteBranchStatus,
   ensureRepositoryHasCommits,
   executeGitCommand,
   extractIssueNumber,
+  extractPRNumber,
   findMainWorktreePathWithSettings,
+  findWorktreeForBranch,
+  getMergeTargetBranch,
   hasUncommittedChanges,
+  isBranchMergedIntoMain,
   isFileTrackedByGit
-} from "./chunk-5Q3NDNNV.js";
+} from "./chunk-2W2FBL5G.js";
+import {
+  MetadataManager
+} from "./chunk-IJ7IGJT3.js";
 import {
   SettingsManager
-} from "./chunk-CDZERT7Z.js";
+} from "./chunk-VWNS6DH5.js";
 import {
   calculateForegroundColor,
   generateColorFromBranchName,
@@ -29,201 +37,33 @@ import {
   lightenColor,
   rgbToHex,
   selectDistinctColor
-} from "./chunk-CFFQ2Z7A.js";
+} from "./chunk-WUQQNE63.js";
+import {
+  generateDeterministicSessionId
+} from "./chunk-RUC7OULH.js";
 import {
   findEnvFileForDatabaseUrl,
   formatEnvLine,
   hasVariableInAnyEnvFile,
+  isNoEnvFilesFoundError,
   loadEnvIntoProcess,
   parseEnvFile,
   validateEnvVariable
-} from "./chunk-UJL4HI2R.js";
+} from "./chunk-Z5NXYJIG.js";
+import {
+  getLogger
+} from "./chunk-6UIGZD2N.js";
 import {
-  createLogger,
   logger
-} from "./chunk-GEHQXLEI.js";
-
-// src/lib/MetadataManager.ts
-import path from "path";
-import os from "os";
-import fs from "fs-extra";
-var MetadataManager = class {
-  constructor() {
-    this.loomsDir = path.join(os.homedir(), ".config", "iloom-ai", "looms");
-  }
-  /**
-   * Convert worktree path to filename slug per spec section 2.2
-   *
-   * Algorithm:
-   * 1. Trim trailing slashes
-   * 2. Replace all path separators (/ or \) with __ (double underscore)
-   * 3. Replace any other non-alphanumeric characters (except _ and -) with -
-   * 4. Append .json
-   *
-   * Example:
-   * - Worktree: /Users/jane/dev/repo
-   * - Filename: _Users__jane__dev__repo.json
-   */
-  slugifyPath(worktreePath) {
-    let slug = worktreePath.replace(/[/\\]+$/, "");
-    slug = slug.replace(/[/\\]/g, "___");
-    slug = slug.replace(/[^a-zA-Z0-9_-]/g, "-");
-    return `${slug}.json`;
-  }
-  /**
-   * Get the full path to the metadata file for a worktree
-   */
-  getFilePath(worktreePath) {
-    const filename = this.slugifyPath(worktreePath);
-    return path.join(this.loomsDir, filename);
-  }
-  /**
-   * Write metadata for a worktree (spec section 3.1)
-   *
-   * @param worktreePath - Absolute path to the worktree (used for file naming)
-   * @param input - Metadata to write (description plus additional fields)
-   */
-  async writeMetadata(worktreePath, input) {
-    try {
-      await fs.ensureDir(this.loomsDir, { mode: 493 });
-      const content = {
-        description: input.description,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        version: 1,
-        branchName: input.branchName,
-        worktreePath: input.worktreePath,
-        issueType: input.issueType,
-        issue_numbers: input.issue_numbers,
-        pr_numbers: input.pr_numbers,
-        issueTracker: input.issueTracker,
-        colorHex: input.colorHex
-      };
-      const filePath = this.getFilePath(worktreePath);
-      await fs.writeFile(filePath, JSON.stringify(content, null, 2), { mode: 420 });
-      logger.debug(`Metadata written for worktree: ${worktreePath}`);
-    } catch (error) {
-      logger.warn(
-        `Failed to write metadata for worktree: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  /**
-   * Read metadata for a worktree (spec section 3.2)
-   *
-   * @param worktreePath - Absolute path to the worktree
-   * @returns The metadata object with all fields, or null if not found/invalid
-   */
-  async readMetadata(worktreePath) {
-    try {
-      const filePath = this.getFilePath(worktreePath);
-      if (!await fs.pathExists(filePath)) {
-        return null;
-      }
-      const content = await fs.readFile(filePath, "utf8");
-      const data = JSON.parse(content);
-      if (!data.description) {
-        return null;
-      }
-      return {
-        description: data.description,
-        created_at: data.created_at ?? null,
-        branchName: data.branchName ?? null,
-        worktreePath: data.worktreePath ?? null,
-        issueType: data.issueType ?? null,
-        issue_numbers: data.issue_numbers ?? [],
-        pr_numbers: data.pr_numbers ?? [],
-        issueTracker: data.issueTracker ?? null,
-        colorHex: data.colorHex ?? null
-      };
-    } catch (error) {
-      logger.debug(
-        `Could not read metadata for worktree ${worktreePath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return null;
-    }
-  }
-  /**
-   * List all stored loom metadata files
-   *
-   * Returns an array of LoomMetadata objects for all valid metadata files
-   * in the looms directory. Invalid or unreadable files are skipped.
-   *
-   * @returns Array of LoomMetadata objects from all stored files
-   */
-  async listAllMetadata() {
-    const results = [];
-    try {
-      if (!await fs.pathExists(this.loomsDir)) {
-        return results;
-      }
-      const files = await fs.readdir(this.loomsDir);
-      for (const file of files) {
-        if (!file.endsWith(".json")) {
-          continue;
-        }
-        try {
-          const filePath = path.join(this.loomsDir, file);
-          const content = await fs.readFile(filePath, "utf8");
-          const data = JSON.parse(content);
-          if (!data.description) {
-            continue;
-          }
-          results.push({
-            description: data.description,
-            created_at: data.created_at ?? null,
-            branchName: data.branchName ?? null,
-            worktreePath: data.worktreePath ?? null,
-            issueType: data.issueType ?? null,
-            issue_numbers: data.issue_numbers ?? [],
-            pr_numbers: data.pr_numbers ?? [],
-            issueTracker: data.issueTracker ?? null,
-            colorHex: data.colorHex ?? null
-          });
-        } catch (error) {
-          logger.debug(
-            `Skipping metadata file ${file}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    } catch (error) {
-      logger.debug(
-        `Could not list metadata files: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    return results;
-  }
-  /**
-   * Delete metadata for a worktree (spec section 3.3)
-   *
-   * Idempotent: silently succeeds if file doesn't exist
-   * Non-fatal: logs warning on permission errors but doesn't throw
-   *
-   * @param worktreePath - Absolute path to the worktree
-   */
-  async deleteMetadata(worktreePath) {
-    try {
-      const filePath = this.getFilePath(worktreePath);
-      if (!await fs.pathExists(filePath)) {
-        logger.debug(`No metadata file to delete for worktree: ${worktreePath}`);
-        return;
-      }
-      await fs.unlink(filePath);
-      logger.debug(`Metadata deleted for worktree: ${worktreePath}`);
-    } catch (error) {
-      logger.warn(
-        `Failed to delete metadata for worktree: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-};
+} from "./chunk-UYVWLISQ.js";
 
 // src/lib/LoomManager.ts
-import path3 from "path";
-import fs3 from "fs-extra";
+import path2 from "path";
+import fs2 from "fs-extra";
 
 // src/lib/VSCodeIntegration.ts
-import fs2 from "fs-extra";
-import path2 from "path";
+import fs from "fs-extra";
+import path from "path";
 import { parse, modify, applyEdits } from "jsonc-parser";
 var VSCodeIntegration = class {
   /**
@@ -233,10 +73,10 @@ var VSCodeIntegration = class {
    * @param hexColor - Hex color string (e.g., "#dcebf8")
    */
   async setTitleBarColor(workspacePath, hexColor) {
-    const vscodeDir = path2.join(workspacePath, ".vscode");
-    const settingsPath = path2.join(vscodeDir, "settings.json");
+    const vscodeDir = path.join(workspacePath, ".vscode");
+    const settingsPath = path.join(vscodeDir, "settings.json");
     try {
-      await fs2.ensureDir(vscodeDir);
+      await fs.ensureDir(vscodeDir);
       const settings = await this.readSettings(settingsPath);
       const updatedSettings = this.mergeColorSettings(settings, hexColor);
       await this.writeSettings(settingsPath, updatedSettings);
@@ -256,10 +96,10 @@ var VSCodeIntegration = class {
    */
   async readSettings(settingsPath) {
     try {
-      if (!await fs2.pathExists(settingsPath)) {
+      if (!await fs.pathExists(settingsPath)) {
         return {};
       }
-      const content = await fs2.readFile(settingsPath, "utf8");
+      const content = await fs.readFile(settingsPath, "utf8");
       const errors = [];
       const settings = parse(content, errors, { allowTrailingComma: true });
       if (errors.length > 0) {
@@ -283,8 +123,8 @@ var VSCodeIntegration = class {
   async writeSettings(settingsPath, settings) {
     try {
       let content;
-      if (await fs2.pathExists(settingsPath)) {
-        const existingContent = await fs2.readFile(settingsPath, "utf8");
+      if (await fs.pathExists(settingsPath)) {
+        const existingContent = await fs.readFile(settingsPath, "utf8");
         if (existingContent.includes("//") || existingContent.includes("/*")) {
           content = await this.modifyWithCommentsPreserved(existingContent, settings);
         } else {
@@ -294,8 +134,8 @@ var VSCodeIntegration = class {
         content = JSON.stringify(settings, null, 2) + "\n";
       }
       const tempPath = `${settingsPath}.tmp`;
-      await fs2.writeFile(tempPath, content, "utf8");
-      await fs2.rename(tempPath, settingsPath);
+      await fs.writeFile(tempPath, content, "utf8");
+      await fs.rename(tempPath, settingsPath);
     } catch (error) {
       throw new Error(
         `Failed to write settings.json: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -373,7 +213,7 @@ var LoomManager = class {
       return null;
     }
     try {
-      const envFilePath = path3.join(loomPath, ".env");
+      const envFilePath = path2.join(loomPath, ".env");
       const settings = await this.settings.loadSettings();
       const databaseUrlVarName = ((_b = (_a = settings.capabilities) == null ? void 0 : _a.database) == null ? void 0 : _b.databaseUrlEnvVarName) ?? "DATABASE_URL";
       const connectionString = await this.environment.getEnvVariable(envFilePath, databaseUrlVarName);
@@ -382,7 +222,7 @@ var LoomManager = class {
       }
       return await this.database.getBranchNameFromConnectionString(connectionString, loomPath);
     } catch (error) {
-      logger.debug(`Could not get database branch for loom at ${loomPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      getLogger().debug(`Could not get database branch for loom at ${loomPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
       return null;
     }
   }
@@ -392,28 +232,29 @@ var LoomManager = class {
    * NEW: Checks for existing worktrees and reuses them if found
    */
   async createIloom(input) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
-    logger.info("Fetching issue data...");
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    getLogger().info("Fetching issue data...");
     const issueData = await this.fetchIssueData(input);
     if (input.type === "issue" || input.type === "pr" || input.type === "branch") {
-      logger.info("Checking for existing worktree...");
+      getLogger().info("Checking for existing worktree...");
       const existing = await this.findExistingIloom(input, issueData);
       if (existing) {
-        logger.success(`Found existing worktree, reusing: ${existing.path}`);
+        getLogger().success(`Found existing worktree, reusing: ${existing.path}`);
         return await this.reuseIloom(existing, input, issueData);
       }
-      logger.info("No existing worktree found, creating new one...");
+      getLogger().info("No existing worktree found, creating new one...");
     }
-    logger.info("Preparing branch name...");
+    getLogger().info("Preparing branch name...");
     const branchName = await this.prepareBranchName(input, issueData);
-    logger.info("Creating git worktree...");
+    getLogger().info("Creating git worktree...");
     const worktreePath = await this.createWorktreeOnly(input, branchName);
     this.loadMainEnvFile();
     const { capabilities, binEntries } = await this.capabilityDetector.detectCapabilities(worktreePath);
     await this.copyEnvironmentFiles(worktreePath);
-    await this.copyIloomSettings(worktreePath, (_a = input.parentLoom) == null ? void 0 : _a.branchName);
+    await this.copyIloomSettings(worktreePath);
+    await this.copyClaudeSettings(worktreePath);
     const settingsData = await this.settings.loadSettings();
-    const basePort = ((_c = (_b = settingsData.capabilities) == null ? void 0 : _b.web) == null ? void 0 : _c.basePort) ?? 3e3;
+    const basePort = ((_b = (_a = settingsData.capabilities) == null ? void 0 : _a.web) == null ? void 0 : _b.basePort) ?? 3e3;
     let port = basePort;
     if (capabilities.includes("web")) {
       port = await this.setupPortForWeb(worktreePath, input, basePort);
@@ -421,10 +262,10 @@ var LoomManager = class {
     try {
       await installDependencies(worktreePath, true, true);
     } catch (error) {
-      logger.warn(`Failed to install dependencies: ${error instanceof Error ? error.message : "Unknown error"}`, error);
+      getLogger().warn(`Failed to install dependencies: ${error instanceof Error ? error.message : "Unknown error"}`, error);
     }
     let databaseBranch = void 0;
-    if (this.database && !((_d = input.options) == null ? void 0 : _d.skipDatabase)) {
+    if (this.database && !((_c = input.options) == null ? void 0 : _c.skipDatabase)) {
       try {
         const connectionString = await this.database.createBranchIfConfigured(
           branchName,
@@ -432,7 +273,7 @@ var LoomManager = class {
           // workspace path - checks all dotenv-flow files
           void 0,
           // cwd
-          (_e = input.parentLoom) == null ? void 0 : _e.databaseBranch
+          (_d = input.parentLoom) == null ? void 0 : _d.databaseBranch
           // fromBranch - use parent's database branch for child looms
         );
         if (connectionString) {
@@ -441,26 +282,26 @@ var LoomManager = class {
             worktreePath,
             varName,
             isFileTrackedByGit,
-            async (p) => fs3.pathExists(p),
+            async (p) => fs2.pathExists(p),
             async (p, v) => this.environment.getEnvVariable(p, v)
           );
           await this.environment.setEnvVar(
-            path3.join(worktreePath, targetFile),
+            path2.join(worktreePath, targetFile),
             varName,
             connectionString
           );
-          logger.success("Database branch configured");
+          getLogger().success("Database branch configured");
           databaseBranch = branchName;
         }
       } catch (error) {
-        logger.error(
+        getLogger().error(
           `Failed to setup database branch: ${error instanceof Error ? error.message : "Unknown error"}`
         );
         throw error;
       }
     }
     let cliSymlinks = void 0;
-    if (capabilities.includes("cli")) {
+    if (capabilities.includes("cli") && input.type !== "branch") {
       try {
         cliSymlinks = await this.cliIsolation.setupCLIIsolation(
           worktreePath,
@@ -468,7 +309,7 @@ var LoomManager = class {
           binEntries
         );
       } catch (error) {
-        logger.warn(
+        getLogger().warn(
           `Failed to setup CLI isolation: ${error instanceof Error ? error.message : "Unknown error"}`,
           error
         );
@@ -477,38 +318,38 @@ var LoomManager = class {
     const allMetadata = await this.metadataManager.listAllMetadata();
     const usedHexColors = allMetadata.filter((metadata) => metadata.colorHex !== null).map((metadata) => metadata.colorHex);
     const colorData = selectDistinctColor(branchName, usedHexColors);
-    logger.debug(`Selected color ${colorData.hex} for branch ${branchName} (${usedHexColors.length} colors in use globally)`);
+    getLogger().debug(`Selected color ${colorData.hex} for branch ${branchName} (${usedHexColors.length} colors in use globally)`);
     try {
       await this.applyColorSynchronization(worktreePath, branchName, colorData, settingsData, input.options);
     } catch (error) {
-      logger.warn(
+      getLogger().warn(
         `Failed to apply color synchronization: ${error instanceof Error ? error.message : "Unknown error"}`,
         error
       );
     }
     if (input.type === "issue") {
       try {
-        logger.info("Moving issue to In Progress...");
+        getLogger().info("Moving issue to In Progress...");
         if (this.issueTracker.moveIssueToInProgress) {
           await this.issueTracker.moveIssueToInProgress(input.identifier);
         }
       } catch (error) {
-        logger.warn(
+        getLogger().warn(
           `Failed to move issue to In Progress: ${error instanceof Error ? error.message : "Unknown error"}`,
           error
         );
       }
     }
-    const enableClaude = ((_f = input.options) == null ? void 0 : _f.enableClaude) !== false;
-    const enableCode = ((_g = input.options) == null ? void 0 : _g.enableCode) !== false;
-    const enableDevServer = ((_h = input.options) == null ? void 0 : _h.enableDevServer) !== false;
-    const enableTerminal = ((_i = input.options) == null ? void 0 : _i.enableTerminal) ?? false;
-    const oneShot = ((_j = input.options) == null ? void 0 : _j.oneShot) ?? "default";
-    const setArguments = (_k = input.options) == null ? void 0 : _k.setArguments;
-    const executablePath = (_l = input.options) == null ? void 0 : _l.executablePath;
+    const enableClaude = ((_e = input.options) == null ? void 0 : _e.enableClaude) !== false;
+    const enableCode = ((_f = input.options) == null ? void 0 : _f.enableCode) !== false;
+    const enableDevServer = ((_g = input.options) == null ? void 0 : _g.enableDevServer) !== false;
+    const enableTerminal = ((_h = input.options) == null ? void 0 : _h.enableTerminal) ?? false;
+    const oneShot = ((_i = input.options) == null ? void 0 : _i.oneShot) ?? "default";
+    const setArguments = (_j = input.options) == null ? void 0 : _j.setArguments;
+    const executablePath = (_k = input.options) == null ? void 0 : _k.executablePath;
     if (enableClaude || enableCode || enableDevServer || enableTerminal) {
-      const { LoomLauncher } = await import("./LoomLauncher-ZV3ZZIBA.js");
-      const { ClaudeContextManager } = await import("./ClaudeContextManager-BN7RE5ZQ.js");
+      const { LoomLauncher } = await import("./LoomLauncher-S3YGJRJQ.js");
+      const { ClaudeContextManager } = await import("./ClaudeContextManager-DK77227F.js");
       const claudeContext = new ClaudeContextManager(void 0, void 0, this.settings);
       const launcher = new LoomLauncher(claudeContext, this.settings);
       await launcher.launchLoom({
@@ -527,13 +368,14 @@ var LoomManager = class {
         ...setArguments && { setArguments },
         ...executablePath && { executablePath },
         sourceEnvOnStart: settingsData.sourceEnvOnStart ?? false,
-        colorTerminal: ((_m = input.options) == null ? void 0 : _m.colorTerminal) ?? ((_n = settingsData.colors) == null ? void 0 : _n.terminal) ?? true,
+        colorTerminal: ((_l = input.options) == null ? void 0 : _l.colorTerminal) ?? ((_m = settingsData.colors) == null ? void 0 : _m.terminal) ?? true,
         colorHex: colorData.hex
       });
     }
     const description = (issueData == null ? void 0 : issueData.title) ?? branchName;
     const issue_numbers = input.type === "issue" ? [String(input.identifier)] : [];
     const pr_numbers = input.type === "pr" ? [String(input.identifier)] : [];
+    const sessionId = generateDeterministicSessionId(worktreePath);
     const metadataInput = {
       description,
       branchName,
@@ -542,7 +384,10 @@ var LoomManager = class {
       issue_numbers,
       pr_numbers,
       issueTracker: this.issueTracker.providerName,
-      colorHex: colorData.hex
+      colorHex: colorData.hex,
+      sessionId,
+      projectPath: this.gitWorktree.workingDirectory,
+      ...input.parentLoom && { parentLoom: input.parentLoom }
     };
     await this.metadataManager.writeMetadata(worktreePath, metadataInput);
     const loom = {
@@ -568,7 +413,7 @@ var LoomManager = class {
         }
       }
     };
-    logger.success(`Created loom: ${loom.id} at ${loom.path}`);
+    getLogger().success(`Created loom: ${loom.id} at ${loom.path}`);
     return loom;
   }
   /**
@@ -616,7 +461,7 @@ var LoomManager = class {
       const pattern = `${sanitizedBranchName}-looms/`;
       return worktrees.filter((wt) => wt.path.includes(pattern));
     } catch (error) {
-      logger.debug(`Failed to find child looms: ${error instanceof Error ? error.message : "Unknown error"}`);
+      getLogger().debug(`Failed to find child looms: ${error instanceof Error ? error.message : "Unknown error"}`);
       return [];
     }
   }
@@ -630,7 +475,7 @@ var LoomManager = class {
   async checkAndWarnChildLooms(branchName) {
     let targetBranch = branchName;
     if (!targetBranch) {
-      const { getCurrentBranch } = await import("./git-IYA53VIC.js");
+      const { getCurrentBranch } = await import("./git-4BVOOOOV.js");
       targetBranch = await getCurrentBranch();
     }
     if (!targetBranch) {
@@ -638,19 +483,19 @@ var LoomManager = class {
     }
     const childLooms = await this.findChildLooms(targetBranch);
     if (childLooms.length > 0) {
-      logger.warn(`Found ${childLooms.length} child loom(s) that should be finished first:`);
+      getLogger().warn(`Found ${childLooms.length} child loom(s) that should be finished first:`);
       for (const child of childLooms) {
-        logger.warn(`  - ${child.path}`);
+        getLogger().warn(`  - ${child.path}`);
       }
-      logger.warn("");
-      logger.warn("To finish child looms:");
+      getLogger().warn("");
+      getLogger().warn("To finish child looms:");
       for (const child of childLooms) {
         const prMatch = child.branch.match(/_pr_(\d+)/);
         const issueId = extractIssueNumber(child.branch);
         const childIdentifier = prMatch ? prMatch[1] : issueId ?? child.branch;
-        logger.warn(`  il finish ${childIdentifier}`);
+        getLogger().warn(`  il finish ${childIdentifier}`);
       }
-      logger.warn("");
+      getLogger().warn("");
       return true;
     }
     return false;
@@ -696,14 +541,14 @@ var LoomManager = class {
    */
   async createWorktreeOnly(input, branchName) {
     var _a;
-    logger.info("Ensuring repository has initial commit...");
+    getLogger().info("Ensuring repository has initial commit...");
     await ensureRepositoryHasCommits(this.gitWorktree.workingDirectory);
     const settingsData = await this.settings.loadSettings();
     let worktreePrefix = settingsData.worktreePrefix;
     if (input.parentLoom) {
       const sanitizedBranchName = input.parentLoom.branchName.replace(/\//g, "-").replace(/[^a-zA-Z0-9-_]/g, "-");
       worktreePrefix = `${sanitizedBranchName}-looms/`;
-      logger.info(`Creating child loom with prefix: ${worktreePrefix}`);
+      getLogger().info(`Creating child loom with prefix: ${worktreePrefix}`);
     }
     const pathOptions = input.type === "pr" ? { isPR: true, prNumber: input.identifier } : {};
     if (worktreePrefix !== void 0) {
@@ -715,10 +560,10 @@ var LoomManager = class {
       pathOptions
     );
     if (input.type === "pr") {
-      logger.info("Fetching all remote branches...");
+      getLogger().info("Fetching all remote branches...");
       try {
         await executeGitCommand(["fetch", "origin"], { cwd: this.gitWorktree.workingDirectory });
-        logger.success("Successfully fetched from remote");
+        getLogger().success("Successfully fetched from remote");
       } catch (error) {
         throw new Error(
           `Failed to fetch from remote: ${error instanceof Error ? error.message : "Unknown error"}. Make sure you have access to the repository.`
@@ -740,13 +585,13 @@ var LoomManager = class {
       ...baseBranch && { baseBranch }
     });
     if (input.type === "pr" && !branchExistedLocally) {
-      logger.info("Resetting new PR branch to match remote exactly...");
+      getLogger().info("Resetting new PR branch to match remote exactly...");
       try {
         await executeGitCommand(["reset", "--hard", `origin/${branchName}`], { cwd: worktreePath });
         await executeGitCommand(["branch", "--set-upstream-to", `origin/${branchName}`], { cwd: worktreePath });
-        logger.success("Successfully reset to match remote");
+        getLogger().success("Successfully reset to match remote");
       } catch (error) {
-        logger.warn(`Failed to reset to match remote: ${error instanceof Error ? error.message : "Unknown error"}`);
+        getLogger().warn(`Failed to reset to match remote: ${error instanceof Error ? error.message : "Unknown error"}`);
       }
     }
     return worktreePath;
@@ -768,23 +613,23 @@ var LoomManager = class {
     ];
     for (const pattern of envFilePatterns) {
       try {
-        const mainEnvPath = path3.join(mainWorkspacePath, pattern);
-        const worktreeEnvPath = path3.join(worktreePath, pattern);
-        if (!await fs3.pathExists(mainEnvPath)) {
+        const mainEnvPath = path2.join(mainWorkspacePath, pattern);
+        const worktreeEnvPath = path2.join(worktreePath, pattern);
+        if (!await fs2.pathExists(mainEnvPath)) {
           continue;
         }
         if (await isFileTrackedByGit(pattern, mainWorkspacePath)) {
-          logger.debug(`Skipping ${pattern} (tracked by git, already in worktree)`);
+          getLogger().debug(`Skipping ${pattern} (tracked by git, already in worktree)`);
           continue;
         }
-        if (await fs3.pathExists(worktreeEnvPath)) {
-          logger.warn(`${pattern} already exists in worktree, skipping copy`);
+        if (await fs2.pathExists(worktreeEnvPath)) {
+          getLogger().warn(`${pattern} already exists in worktree, skipping copy`);
           continue;
         }
         await this.environment.copyIfExists(mainEnvPath, worktreeEnvPath);
-        logger.debug(`Copied ${pattern} to worktree`);
+        getLogger().debug(`Copied ${pattern} to worktree`);
       } catch (error) {
-        logger.warn(`Warning: Failed to copy ${pattern}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        getLogger().warn(`Warning: Failed to copy ${pattern}: ${error instanceof Error ? error.message : "Unknown error"}`);
       }
     }
   }
@@ -792,35 +637,41 @@ var LoomManager = class {
    * Copy iloom configuration (settings.local.json) from main repo to worktree
    * Always called regardless of project capabilities
    * @param worktreePath Path to the worktree
-   * @param parentBranchName Optional parent branch name for child looms (sets mainBranch)
    */
-  async copyIloomSettings(worktreePath, parentBranchName) {
-    const mainSettingsLocalPath = path3.join(process.cwd(), ".iloom", "settings.local.json");
+  async copyIloomSettings(worktreePath) {
+    const mainSettingsLocalPath = path2.join(process.cwd(), ".iloom", "settings.local.json");
     try {
-      const worktreeIloomDir = path3.join(worktreePath, ".iloom");
-      await fs3.ensureDir(worktreeIloomDir);
-      const worktreeSettingsLocalPath = path3.join(worktreeIloomDir, "settings.local.json");
-      if (await fs3.pathExists(worktreeSettingsLocalPath)) {
-        logger.warn("settings.local.json already exists in worktree, skipping copy");
+      const worktreeIloomDir = path2.join(worktreePath, ".iloom");
+      await fs2.ensureDir(worktreeIloomDir);
+      const worktreeSettingsLocalPath = path2.join(worktreeIloomDir, "settings.local.json");
+      if (await fs2.pathExists(worktreeSettingsLocalPath)) {
+        getLogger().warn("settings.local.json already exists in worktree, skipping copy");
       } else {
         await this.environment.copyIfExists(mainSettingsLocalPath, worktreeSettingsLocalPath);
       }
-      if (parentBranchName) {
-        let existingSettings = {};
-        try {
-          const content = await fs3.readFile(worktreeSettingsLocalPath, "utf8");
-          existingSettings = JSON.parse(content);
-        } catch {
-        }
-        const updatedSettings = {
-          ...existingSettings,
-          mainBranch: parentBranchName
-        };
-        await fs3.writeFile(worktreeSettingsLocalPath, JSON.stringify(updatedSettings, null, 2));
-        logger.info(`Set mainBranch to ${parentBranchName} for child loom`);
+    } catch (error) {
+      getLogger().warn(`Warning: Failed to copy settings.local.json: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Copy Claude settings (settings.local.json) from main repo to worktree
+   * Always called regardless of project capabilities
+   * Follows the same pattern as copyIloomSettings()
+   * @param worktreePath Path to the worktree
+   */
+  async copyClaudeSettings(worktreePath) {
+    const mainClaudeSettingsPath = path2.join(process.cwd(), ".claude", "settings.local.json");
+    try {
+      const worktreeClaudeDir = path2.join(worktreePath, ".claude");
+      await fs2.ensureDir(worktreeClaudeDir);
+      const worktreeClaudeSettingsPath = path2.join(worktreeClaudeDir, "settings.local.json");
+      if (await fs2.pathExists(worktreeClaudeSettingsPath)) {
+        getLogger().debug(".claude/settings.local.json already exists in worktree, skipping copy");
+      } else {
+        await this.environment.copyIfExists(mainClaudeSettingsPath, worktreeClaudeSettingsPath);
       }
     } catch (error) {
-      logger.warn(`Warning: Failed to copy settings.local.json: ${error instanceof Error ? error.message : "Unknown error"}`);
+      getLogger().warn(`Warning: Failed to copy .claude/settings.local.json: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
   /**
@@ -828,7 +679,7 @@ var LoomManager = class {
    * Only called when project has web capabilities
    */
   async setupPortForWeb(worktreePath, input, basePort) {
-    const envFilePath = path3.join(worktreePath, ".env.local");
+    const envFilePath = path2.join(worktreePath, ".env.local");
     const options = { basePort };
     if (input.type === "issue") {
       options.issueNumber = input.identifier;
@@ -848,11 +699,15 @@ var LoomManager = class {
   loadMainEnvFile() {
     const result = loadEnvIntoProcess({ path: process.cwd() });
     if (result.error) {
-      logger.warn(`Warning: Could not load .env files: ${result.error.message}`);
+      if (isNoEnvFilesFoundError(result.error)) {
+        getLogger().debug("No .env files found (this is normal for projects without environment files)");
+      } else {
+        getLogger().warn(`Warning: Could not load .env files: ${result.error.message}`);
+      }
     } else {
-      logger.info("Loaded environment variables using dotenv-flow");
+      getLogger().info("Loaded environment variables using dotenv-flow");
       if (result.parsed && Object.keys(result.parsed).length > 0) {
-        logger.debug(`Loaded ${Object.keys(result.parsed).length} environment variables`);
+        getLogger().debug(`Loaded ${Object.keys(result.parsed).length} environment variables`);
       }
     }
   }
@@ -871,8 +726,12 @@ var LoomManager = class {
     var _a, _b;
     const settingsData = await this.settings.loadSettings();
     const basePort = ((_b = (_a = settingsData.capabilities) == null ? void 0 : _a.web) == null ? void 0 : _b.basePort) ?? 3e3;
-    if (input.type === "issue" && typeof input.identifier === "number") {
-      return this.environment.calculatePort({ basePort, issueNumber: input.identifier });
+    if (input.type === "issue") {
+      if (typeof input.identifier === "number") {
+        return this.environment.calculatePort({ basePort, issueNumber: input.identifier });
+      } else if (typeof input.identifier === "string") {
+        return this.environment.calculatePort({ basePort, branchName: input.identifier });
+      }
     }
     if (input.type === "pr" && typeof input.identifier === "number") {
       return this.environment.calculatePort({ basePort, prNumber: input.identifier });
@@ -880,7 +739,7 @@ var LoomManager = class {
     if (input.type === "branch" && typeof input.identifier === "string") {
       return this.environment.calculatePort({ basePort, branchName: input.identifier });
     }
-    throw new Error(`Unknown input type: ${input.type}`);
+    throw new Error(`Unknown input type: ${input.type} with identifier type: ${typeof input.identifier}`);
   }
   /**
    * Apply color synchronization to both VSCode and terminal
@@ -898,34 +757,56 @@ var LoomManager = class {
     const colorVscode = (options == null ? void 0 : options.colorVscode) ?? ((_a = settings.colors) == null ? void 0 : _a.vscode) ?? false;
     const colorTerminal = (options == null ? void 0 : options.colorTerminal) ?? ((_b = settings.colors) == null ? void 0 : _b.terminal) ?? true;
     if (!colorVscode && !colorTerminal) {
-      logger.debug("Color synchronization disabled for both VSCode and terminal");
+      getLogger().debug("Color synchronization disabled for both VSCode and terminal");
       return;
     }
     if (colorVscode) {
       const vscode = new VSCodeIntegration();
       await vscode.setTitleBarColor(worktreePath, colorData.hex);
-      logger.info(`Applied VSCode title bar color: ${colorData.hex} for branch: ${branchName}`);
+      getLogger().info(`Applied VSCode title bar color: ${colorData.hex} for branch: ${branchName}`);
     } else {
-      logger.debug("VSCode color sync disabled (default: false for safety)");
+      getLogger().debug("VSCode color sync disabled (default: false for safety)");
     }
   }
   /**
    * Map worktrees to loom objects
-   * This is a simplified conversion - in production we'd store loom metadata
-   * Now reads metadata from MetadataManager (spec section 3.2)
+   * Reads loom metadata from MetadataManager with branch name parsing as fallback
    */
   async mapWorktreesToLooms(worktrees) {
     return await Promise.all(worktrees.map(async (wt) => {
+      var _a, _b;
+      const loomMetadata = await this.metadataManager.readMetadata(wt.path);
       let type = "branch";
       let identifier = wt.branch;
-      if (wt.branch.startsWith("issue-")) {
-        type = "issue";
-        identifier = parseInt(wt.branch.replace("issue-", ""), 10);
-      } else if (wt.branch.startsWith("pr-")) {
-        type = "pr";
-        identifier = parseInt(wt.branch.replace("pr-", ""), 10);
+      if (loomMetadata == null ? void 0 : loomMetadata.issueType) {
+        type = loomMetadata.issueType;
+        if (type === "issue" && ((_a = loomMetadata.issue_numbers) == null ? void 0 : _a[0])) {
+          const issueId = loomMetadata.issue_numbers[0];
+          const numericId = parseInt(issueId, 10);
+          identifier = isNaN(numericId) ? issueId : numericId;
+        } else if (type === "pr" && ((_b = loomMetadata.pr_numbers) == null ? void 0 : _b[0])) {
+          const prId = loomMetadata.pr_numbers[0];
+          identifier = parseInt(prId, 10);
+        } else if (type === "branch") {
+          identifier = wt.branch;
+        }
+      } else {
+        const prNumber = extractPRNumber(wt.branch);
+        if (prNumber !== null) {
+          type = "pr";
+          identifier = prNumber;
+        } else {
+          const issueNumber = extractIssueNumber(wt.branch);
+          if (issueNumber !== null) {
+            type = "issue";
+            const numericId = parseInt(issueNumber, 10);
+            identifier = isNaN(numericId) ? issueNumber : numericId;
+          } else {
+            type = "branch";
+            identifier = wt.branch;
+          }
+        }
       }
-      const loomMetadata = await this.metadataManager.readMetadata(wt.path);
       return {
         id: `${type}-${identifier}`,
         path: wt.path,
@@ -969,41 +850,42 @@ var LoomManager = class {
     const { capabilities, binEntries } = await this.capabilityDetector.detectCapabilities(worktreePath);
     await this.copyEnvironmentFiles(worktreePath);
     await this.copyIloomSettings(worktreePath);
+    await this.copyClaudeSettings(worktreePath);
     const settingsData = await this.settings.loadSettings();
     const basePort = ((_b = (_a = settingsData.capabilities) == null ? void 0 : _a.web) == null ? void 0 : _b.basePort) ?? 3e3;
     let port = basePort;
     if (capabilities.includes("web")) {
       port = await this.setupPortForWeb(worktreePath, input, basePort);
     }
-    logger.info("Database branch assumed to be already configured for existing worktree");
+    getLogger().info("Database branch assumed to be already configured for existing worktree");
     const databaseBranch = void 0;
     const existingMetadata = await this.metadataManager.readMetadata(worktreePath);
     let colorHex;
     if (existingMetadata == null ? void 0 : existingMetadata.colorHex) {
       colorHex = existingMetadata.colorHex;
-      logger.debug(`Reusing stored color ${colorHex} for branch ${branchName}`);
+      getLogger().debug(`Reusing stored color ${colorHex} for branch ${branchName}`);
     } else {
       const colorData = generateColorFromBranchName(branchName);
       colorHex = colorData.hex;
-      logger.debug(`No stored color, using hash-based color ${colorHex} for branch ${branchName}`);
+      getLogger().debug(`No stored color, using hash-based color ${colorHex} for branch ${branchName}`);
     }
     try {
       const colorData = { hex: colorHex, rgb: hexToRgb(colorHex), index: 0 };
       await this.applyColorSynchronization(worktreePath, branchName, colorData, settingsData, input.options);
     } catch (error) {
-      logger.warn(
+      getLogger().warn(
         `Failed to apply color synchronization: ${error instanceof Error ? error.message : "Unknown error"}`,
         error
       );
     }
     if (input.type === "issue") {
       try {
-        logger.info("Moving issue to In Progress...");
+        getLogger().info("Moving issue to In Progress...");
         if (this.issueTracker.moveIssueToInProgress) {
           await this.issueTracker.moveIssueToInProgress(input.identifier);
         }
       } catch (error) {
-        logger.warn(
+        getLogger().warn(
           `Failed to move issue to In Progress: ${error instanceof Error ? error.message : "Unknown error"}`,
           error
         );
@@ -1017,9 +899,9 @@ var LoomManager = class {
     const setArguments = (_h = input.options) == null ? void 0 : _h.setArguments;
     const executablePath = (_i = input.options) == null ? void 0 : _i.executablePath;
     if (enableClaude || enableCode || enableDevServer || enableTerminal) {
-      logger.info("Launching workspace components...");
-      const { LoomLauncher } = await import("./LoomLauncher-ZV3ZZIBA.js");
-      const { ClaudeContextManager } = await import("./ClaudeContextManager-BN7RE5ZQ.js");
+      getLogger().info("Launching workspace components...");
+      const { LoomLauncher } = await import("./LoomLauncher-S3YGJRJQ.js");
+      const { ClaudeContextManager } = await import("./ClaudeContextManager-DK77227F.js");
       const claudeContext = new ClaudeContextManager(void 0, void 0, this.settings);
       const launcher = new LoomLauncher(claudeContext, this.settings);
       await launcher.launchLoom({
@@ -1046,6 +928,7 @@ var LoomManager = class {
     if (!existingMetadata) {
       const issue_numbers = input.type === "issue" ? [String(input.identifier)] : [];
       const pr_numbers = input.type === "pr" ? [String(input.identifier)] : [];
+      const sessionId = generateDeterministicSessionId(worktreePath);
       const metadataInput = {
         description,
         branchName,
@@ -1054,7 +937,10 @@ var LoomManager = class {
         issue_numbers,
         pr_numbers,
         issueTracker: this.issueTracker.providerName,
-        colorHex
+        colorHex,
+        sessionId,
+        projectPath: this.gitWorktree.workingDirectory,
+        ...input.parentLoom && { parentLoom: input.parentLoom }
       };
       await this.metadataManager.writeMetadata(worktreePath, metadataInput);
     }
@@ -1081,14 +967,13 @@ var LoomManager = class {
         }
       }
     };
-    logger.success(`Reused existing loom: ${loom.id} at ${loom.path}`);
+    getLogger().success(`Reused existing loom: ${loom.id} at ${loom.path}`);
     return loom;
   }
 };
 
 // src/lib/EnvironmentManager.ts
-import fs4 from "fs-extra";
-var logger2 = createLogger({ prefix: "\u{1F4DD}" });
+import fs3 from "fs-extra";
 var EnvironmentManager = class {
   constructor() {
     this.backupSuffix = ".backup";
@@ -1103,15 +988,15 @@ var EnvironmentManager = class {
     if (!validation.valid) {
       throw new Error(validation.error ?? "Invalid variable name");
     }
-    const fileExists = await fs4.pathExists(filePath);
+    const fileExists = await fs3.pathExists(filePath);
     if (!fileExists) {
-      logger2.info(`Creating ${filePath} with ${key}...`);
+      getLogger().info(`Creating ${filePath} with ${key}...`);
       const content = formatEnvLine(key, value);
-      await fs4.writeFile(filePath, content, "utf8");
-      logger2.success(`${filePath} created with ${key}`);
+      await fs3.writeFile(filePath, content, "utf8");
+      getLogger().success(`${filePath} created with ${key}`);
       return;
     }
-    const existingContent = await fs4.readFile(filePath, "utf8");
+    const existingContent = await fs3.readFile(filePath, "utf8");
     const envMap = parseEnvFile(existingContent);
     let backupPath;
     if (backup) {
@@ -1140,15 +1025,15 @@ var EnvironmentManager = class {
       newLines.push(line);
     }
     if (!variableUpdated) {
-      logger2.info(`Adding ${key} to ${filePath}...`);
+      getLogger().info(`Adding ${key} to ${filePath}...`);
       newLines.push(formatEnvLine(key, value));
-      logger2.success(`${key} added successfully`);
+      getLogger().success(`${key} added successfully`);
     } else {
-      logger2.info(`Updating ${key} in ${filePath}...`);
-      logger2.success(`${key} updated successfully`);
+      getLogger().info(`Updating ${key} in ${filePath}...`);
+      getLogger().success(`${key} updated successfully`);
     }
     const newContent = newLines.join("\n");
-    await fs4.writeFile(filePath, newContent, "utf8");
+    await fs3.writeFile(filePath, newContent, "utf8");
     return backupPath;
   }
   /**
@@ -1156,10 +1041,10 @@ var EnvironmentManager = class {
    */
   async readEnvFile(filePath) {
     try {
-      const content = await fs4.readFile(filePath, "utf8");
+      const content = await fs3.readFile(filePath, "utf8");
       return parseEnvFile(content);
     } catch (error) {
-      logger2.debug(
+      getLogger().debug(
         `Could not read env file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
       );
       return /* @__PURE__ */ new Map();
@@ -1179,13 +1064,13 @@ var EnvironmentManager = class {
    * @private
    */
   async copyIfExists(source, destination) {
-    const sourceExists = await fs4.pathExists(source);
+    const sourceExists = await fs3.pathExists(source);
     if (!sourceExists) {
-      logger2.debug(`Source file ${source} does not exist, skipping copy`);
+      getLogger().debug(`Source file ${source} does not exist, skipping copy`);
       return;
     }
-    await fs4.copy(source, destination, { overwrite: false });
-    logger2.success(`Copied ${source} to ${destination}`);
+    await fs3.copy(source, destination, { overwrite: false });
+    getLogger().success(`Copied ${source} to ${destination}`);
   }
   /**
    * Calculate unique port for workspace
@@ -1245,7 +1130,7 @@ var EnvironmentManager = class {
    */
   async validateEnvFile(filePath) {
     try {
-      const content = await fs4.readFile(filePath, "utf8");
+      const content = await fs3.readFile(filePath, "utf8");
       const envMap = parseEnvFile(content);
       const errors = [];
       for (const [key, value] of envMap.entries()) {
@@ -1273,19 +1158,19 @@ var EnvironmentManager = class {
   async createBackup(filePath) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const backupPath = `${filePath}${this.backupSuffix}-${timestamp}`;
-    await fs4.copy(filePath, backupPath);
-    logger2.debug(`Created backup at ${backupPath}`);
+    await fs3.copy(filePath, backupPath);
+    getLogger().debug(`Created backup at ${backupPath}`);
     return backupPath;
   }
 };
 
 // src/lib/CLIIsolationManager.ts
-import fs5 from "fs-extra";
-import path4 from "path";
-import os2 from "os";
+import fs4 from "fs-extra";
+import path3 from "path";
+import os from "os";
 var CLIIsolationManager = class {
   constructor() {
-    this.iloomBinDir = path4.join(os2.homedir(), ".iloom", "bin");
+    this.iloomBinDir = path3.join(os.homedir(), ".iloom", "bin");
   }
   /**
    * Setup CLI isolation for a worktree
@@ -1300,7 +1185,7 @@ var CLIIsolationManager = class {
   async setupCLIIsolation(worktreePath, identifier, binEntries) {
     await this.buildProject(worktreePath);
     await this.verifyBinTargets(worktreePath, binEntries);
-    await fs5.ensureDir(this.iloomBinDir);
+    await fs4.ensureDir(this.iloomBinDir);
     const symlinkNames = await this.createVersionedSymlinks(
       worktreePath,
       identifier,
@@ -1316,12 +1201,12 @@ var CLIIsolationManager = class {
   async buildProject(worktreePath) {
     const pkgJson = await readPackageJson(worktreePath);
     if (!hasScript(pkgJson, "build")) {
-      logger.warn("No build script found in package.json - skipping build");
+      getLogger().warn("No build script found in package.json - skipping build");
       return;
     }
-    logger.info("Building CLI tool...");
+    getLogger().info("Building CLI tool...");
     await runScript("build", worktreePath, [], { quiet: true });
-    logger.success("Build completed");
+    getLogger().success("Build completed");
   }
   /**
    * Verify bin targets exist and are executable
@@ -1330,13 +1215,13 @@ var CLIIsolationManager = class {
    */
   async verifyBinTargets(worktreePath, binEntries) {
     for (const binPath of Object.values(binEntries)) {
-      const targetPath = path4.resolve(worktreePath, binPath);
-      const exists = await fs5.pathExists(targetPath);
+      const targetPath = path3.resolve(worktreePath, binPath);
+      const exists = await fs4.pathExists(targetPath);
       if (!exists) {
         throw new Error(`Bin target does not exist: ${targetPath}`);
       }
       try {
-        await fs5.access(targetPath, fs5.constants.X_OK);
+        await fs4.access(targetPath, fs4.constants.X_OK);
       } catch {
       }
     }
@@ -1352,10 +1237,10 @@ var CLIIsolationManager = class {
     const symlinkNames = [];
     for (const [binName, binPath] of Object.entries(binEntries)) {
       const versionedName = `${binName}-${identifier}`;
-      const targetPath = path4.resolve(worktreePath, binPath);
-      const symlinkPath = path4.join(this.iloomBinDir, versionedName);
-      await fs5.symlink(targetPath, symlinkPath);
-      logger.success(`CLI available: ${versionedName}`);
+      const targetPath = path3.resolve(worktreePath, binPath);
+      const symlinkPath = path3.join(this.iloomBinDir, versionedName);
+      await fs4.symlink(targetPath, symlinkPath);
+      getLogger().success(`CLI available: ${versionedName}`);
       symlinkNames.push(versionedName);
     }
     return symlinkNames;
@@ -1370,10 +1255,10 @@ var CLIIsolationManager = class {
     }
     const shell = this.detectShell();
     const rcFile = this.getShellRcFile(shell);
-    logger.warn("\n\u26A0\uFE0F  One-time PATH setup required:");
-    logger.warn(`   Add to ${rcFile}:`);
-    logger.warn(`   export PATH="$HOME/.iloom/bin:$PATH"`);
-    logger.warn(`   Then run: source ${rcFile}
+    getLogger().warn("\n\u26A0\uFE0F  One-time PATH setup required:");
+    getLogger().warn(`   Add to ${rcFile}:`);
+    getLogger().warn(`   export PATH="$HOME/.iloom/bin:$PATH"`);
+    getLogger().warn(`   Then run: source ${rcFile}
 `);
   }
   /**
@@ -1407,12 +1292,12 @@ var CLIIsolationManager = class {
   async cleanupVersionedExecutables(identifier) {
     const removed = [];
     try {
-      const files = await fs5.readdir(this.iloomBinDir);
+      const files = await fs4.readdir(this.iloomBinDir);
       for (const file of files) {
         if (this.matchesIdentifier(file, identifier)) {
-          const symlinkPath = path4.join(this.iloomBinDir, file);
+          const symlinkPath = path3.join(this.iloomBinDir, file);
           try {
-            await fs5.unlink(symlinkPath);
+            await fs4.unlink(symlinkPath);
             removed.push(file);
           } catch (error) {
             const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
@@ -1420,7 +1305,7 @@ var CLIIsolationManager = class {
               removed.push(file);
               continue;
             }
-            logger.warn(
+            getLogger().warn(
               `Failed to remove symlink ${file}: ${error instanceof Error ? error.message : "Unknown error"}`
             );
           }
@@ -1429,13 +1314,13 @@ var CLIIsolationManager = class {
     } catch (error) {
       const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
       if (isEnoent) {
-        logger.warn("No CLI executables directory found - nothing to cleanup");
+        getLogger().warn("No CLI executables directory found - nothing to cleanup");
         return [];
       }
       throw error;
     }
     if (removed.length > 0) {
-      logger.success(`Removed CLI executables: ${removed.join(", ")}`);
+      getLogger().success(`Removed CLI executables: ${removed.join(", ")}`);
     }
     return removed;
   }
@@ -1448,15 +1333,15 @@ var CLIIsolationManager = class {
   async findOrphanedSymlinks() {
     const orphaned = [];
     try {
-      const files = await fs5.readdir(this.iloomBinDir);
+      const files = await fs4.readdir(this.iloomBinDir);
       for (const file of files) {
-        const symlinkPath = path4.join(this.iloomBinDir, file);
+        const symlinkPath = path3.join(this.iloomBinDir, file);
         try {
-          const stats = await fs5.lstat(symlinkPath);
+          const stats = await fs4.lstat(symlinkPath);
           if (stats.isSymbolicLink()) {
-            const target = await fs5.readlink(symlinkPath);
+            const target = await fs4.readlink(symlinkPath);
             try {
-              await fs5.access(target);
+              await fs4.access(target);
             } catch {
               orphaned.push({
                 name: file,
@@ -1466,7 +1351,7 @@ var CLIIsolationManager = class {
             }
           }
         } catch (error) {
-          logger.warn(
+          getLogger().warn(
             `Failed to check symlink ${file}: ${error instanceof Error ? error.message : "Unknown error"}`
           );
         }
@@ -1491,11 +1376,11 @@ var CLIIsolationManager = class {
     let removedCount = 0;
     for (const symlink of orphaned) {
       try {
-        await fs5.unlink(symlink.path);
+        await fs4.unlink(symlink.path);
         removedCount++;
-        logger.success(`Removed orphaned symlink: ${symlink.name}`);
+        getLogger().success(`Removed orphaned symlink: ${symlink.name}`);
       } catch (error) {
-        logger.warn(
+        getLogger().warn(
           `Failed to remove orphaned symlink ${symlink.name}: ${error instanceof Error ? error.message : "Unknown error"}`
         );
       }
@@ -1517,17 +1402,16 @@ var CLIIsolationManager = class {
 };
 
 // src/lib/DatabaseManager.ts
-import fs6 from "fs-extra";
-var logger3 = createLogger({ prefix: "\u{1F5C2}\uFE0F" });
+import fs5 from "fs-extra";
 var DatabaseManager = class {
   constructor(provider, environment, databaseUrlEnvVarName = "DATABASE_URL") {
     this.provider = provider;
     this.environment = environment;
     this.databaseUrlEnvVarName = databaseUrlEnvVarName;
     if (databaseUrlEnvVarName !== "DATABASE_URL") {
-      logger3.debug(`\u{1F527} DatabaseManager configured with custom variable: ${databaseUrlEnvVarName}`);
+      getLogger().debug(`DatabaseManager configured with custom variable: ${databaseUrlEnvVarName}`);
     } else {
-      logger3.debug("\u{1F527} DatabaseManager using default variable: DATABASE_URL");
+      getLogger().debug("DatabaseManager using default variable: DATABASE_URL");
     }
   }
   /**
@@ -1544,12 +1428,12 @@ var DatabaseManager = class {
    */
   async shouldUseDatabaseBranching(workspacePath) {
     if (!this.provider.isConfigured()) {
-      logger3.debug("Skipping database branching: Database provider not configured");
+      getLogger().debug("Skipping database branching: Database provider not configured");
       return false;
     }
     const hasDatabaseUrl = await this.hasDatabaseUrlInEnv(workspacePath);
     if (!hasDatabaseUrl) {
-      logger3.debug(
+      getLogger().debug(
         "Skipping database branching: configured database URL variable not found in any env file"
       );
       return false;
@@ -1570,28 +1454,28 @@ var DatabaseManager = class {
       return null;
     }
     if (!await this.provider.isCliAvailable()) {
-      logger3.warn("Skipping database branch creation: Neon CLI not available");
-      logger3.warn("Install with: npm install -g neonctl");
+      getLogger().warn("Skipping database branch creation: Neon CLI not available");
+      getLogger().warn("Install with: npm install -g neonctl");
       return null;
     }
     try {
       const isAuth = await this.provider.isAuthenticated(cwd);
       if (!isAuth) {
-        logger3.warn("Skipping database branch creation: Not authenticated with Neon CLI");
-        logger3.warn("Run: neon auth");
+        getLogger().warn("Skipping database branch creation: Not authenticated with Neon CLI");
+        getLogger().warn("Run: neon auth");
         return null;
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger3.error(`Database authentication check failed: ${errorMessage}`);
+      getLogger().error(`Database authentication check failed: ${errorMessage}`);
       throw error;
     }
     try {
       const connectionString = await this.provider.createBranch(branchName, fromBranch, cwd);
-      logger3.success(`Database branch ready: ${this.provider.sanitizeBranchName(branchName)}`);
+      getLogger().success(`Database branch ready: ${this.provider.sanitizeBranchName(branchName)}`);
       return connectionString;
     } catch (error) {
-      logger3.error(
+      getLogger().error(
         `Failed to create database branch: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
@@ -1617,7 +1501,7 @@ var DatabaseManager = class {
       };
     }
     if (!this.provider.isConfigured()) {
-      logger3.debug("Skipping database branch deletion: Database provider not configured");
+      getLogger().debug("Skipping database branch deletion: Database provider not configured");
       return {
         success: true,
         deleted: false,
@@ -1626,7 +1510,7 @@ var DatabaseManager = class {
       };
     }
     if (!await this.provider.isCliAvailable()) {
-      logger3.info("Skipping database branch deletion: CLI tool not available");
+      getLogger().info("Skipping database branch deletion: CLI tool not available");
       return {
         success: false,
         deleted: false,
@@ -1638,7 +1522,7 @@ var DatabaseManager = class {
     try {
       const isAuth = await this.provider.isAuthenticated(cwd);
       if (!isAuth) {
-        logger3.warn("Skipping database branch deletion: Not authenticated with DB Provider");
+        getLogger().warn("Skipping database branch deletion: Not authenticated with DB Provider");
         return {
           success: false,
           deleted: false,
@@ -1649,7 +1533,7 @@ var DatabaseManager = class {
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger3.error(`Database authentication check failed: ${errorMessage}`);
+      getLogger().error(`Database authentication check failed: ${errorMessage}`);
       return {
         success: false,
         deleted: false,
@@ -1662,7 +1546,7 @@ var DatabaseManager = class {
       const result = await this.provider.deleteBranch(branchName, isPreview, cwd);
       return result;
     } catch (error) {
-      logger3.warn(
+      getLogger().warn(
         `Unexpected error in database deletion: ${error instanceof Error ? error.message : String(error)}`
       );
       return {
@@ -1683,13 +1567,13 @@ var DatabaseManager = class {
    */
   async getBranchNameFromConnectionString(connectionString, cwd) {
     if (!this.provider.isConfigured()) {
-      logger3.debug("Provider not configured, skipping reverse lookup");
+      getLogger().debug("Provider not configured, skipping reverse lookup");
       return null;
     }
     if ("getBranchNameFromConnectionString" in this.provider && typeof this.provider.getBranchNameFromConnectionString === "function") {
       return this.provider.getBranchNameFromConnectionString(connectionString, cwd);
     }
-    logger3.debug("Provider does not support reverse lookup");
+    getLogger().debug("Provider does not support reverse lookup");
     return null;
   }
   /**
@@ -1700,26 +1584,26 @@ var DatabaseManager = class {
   async hasDatabaseUrlInEnv(workspacePath) {
     try {
       if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
-        logger3.debug(`Looking for custom database URL variable: ${this.databaseUrlEnvVarName}`);
+        getLogger().debug(`Looking for custom database URL variable: ${this.databaseUrlEnvVarName}`);
       } else {
-        logger3.debug("Looking for default database URL variable: DATABASE_URL");
+        getLogger().debug("Looking for default database URL variable: DATABASE_URL");
       }
       const hasConfiguredVar = await hasVariableInAnyEnvFile(
         workspacePath,
         this.databaseUrlEnvVarName,
-        async (p) => fs6.pathExists(p),
+        async (p) => fs5.pathExists(p),
         async (p, v) => this.environment.getEnvVariable(p, v)
       );
       if (hasConfiguredVar) {
         if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
-          logger3.debug(`\u2705 Found custom database URL variable: ${this.databaseUrlEnvVarName}`);
+          getLogger().debug(`\u2705 Found custom database URL variable: ${this.databaseUrlEnvVarName}`);
         } else {
-          logger3.debug(`\u2705 Found default database URL variable: DATABASE_URL`);
+          getLogger().debug(`\u2705 Found default database URL variable: DATABASE_URL`);
         }
         return true;
       }
       if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
-        logger3.debug(`\u274C Custom database URL variable '${this.databaseUrlEnvVarName}' not found in any env file`);
+        getLogger().debug(`\u274C Custom database URL variable '${this.databaseUrlEnvVarName}' not found in any env file`);
         throw new Error(
           `Configured database URL environment variable '${this.databaseUrlEnvVarName}' not found in any dotenv-flow file. Please add it to an .env file or update your iloom configuration.`
         );
@@ -1727,13 +1611,13 @@ var DatabaseManager = class {
       const hasDefaultVar = await hasVariableInAnyEnvFile(
         workspacePath,
         "DATABASE_URL",
-        async (p) => fs6.pathExists(p),
+        async (p) => fs5.pathExists(p),
         async (p, v) => this.environment.getEnvVariable(p, v)
       );
       if (hasDefaultVar) {
-        logger3.debug("\u2705 Found fallback DATABASE_URL variable");
+        getLogger().debug("\u2705 Found fallback DATABASE_URL variable");
       } else {
-        logger3.debug("\u274C No DATABASE_URL variable found in any env file");
+        getLogger().debug("\u274C No DATABASE_URL variable found in any env file");
       }
       return hasDefaultVar;
     } catch (error) {
@@ -1746,7 +1630,7 @@ var DatabaseManager = class {
 };
 
 // src/lib/ResourceCleanup.ts
-import path5 from "path";
+import path4 from "path";
 var ResourceCleanup = class {
   constructor(gitWorktree, processManager, database, cliIsolation, settingsManager) {
     this.gitWorktree = gitWorktree;
@@ -1768,7 +1652,7 @@ var ResourceCleanup = class {
     const operations = [];
     const errors = [];
     const displayIdentifier = parsed.branchName ?? ((_a = parsed.number) == null ? void 0 : _a.toString()) ?? parsed.originalInput;
-    logger.info(`Starting cleanup for: ${displayIdentifier}`);
+    getLogger().info(`Starting cleanup for: ${displayIdentifier}`);
     const number = parsed.number;
     if (number !== void 0) {
       const port = this.processManager.calculatePort(number);
@@ -1814,7 +1698,7 @@ var ResourceCleanup = class {
       if (!worktree) {
         throw new Error(`No worktree found for identifier: ${displayIdentifier}`);
       }
-      logger.debug(`Found worktree: path="${worktree.path}", branch="${worktree.branch}"`);
+      getLogger().debug(`Found worktree: path="${worktree.path}", branch="${worktree.branch}"`);
     } catch (error) {
       const err = error instanceof Error ? error : new Error("Unknown error");
       errors.push(err);
@@ -1827,7 +1711,9 @@ var ResourceCleanup = class {
       };
     }
     if (!options.force) {
-      const safety = await this.validateWorktreeSafety(worktree, parsed.originalInput);
+      const shouldCheckMergeSafety = options.checkMergeSafety ?? options.deleteBranch === true;
+      const shouldCheckRemoteBranch = options.checkRemoteBranch ?? false;
+      const safety = await this.validateWorktreeSafety(worktree, parsed.originalInput, shouldCheckMergeSafety, shouldCheckRemoteBranch);
       if (!safety.isSafe) {
         const blockerMessage = safety.blockers.join("\n\n");
         throw new Error(`Cannot cleanup:
@@ -1836,18 +1722,18 @@ ${blockerMessage}`);
       }
       if (safety.warnings.length > 0) {
         safety.warnings.forEach((warning) => {
-          logger.warn(warning);
+          getLogger().warn(warning);
         });
       }
     }
     let databaseConfig = null;
     if (!options.keepDatabase && worktree) {
-      const envFilePath = path5.join(worktree.path, ".env");
+      const envFilePath = path4.join(worktree.path, ".env");
       try {
         const shouldCleanup = this.database ? await this.database.shouldUseDatabaseBranching(envFilePath) : false;
         databaseConfig = { shouldCleanup, envFilePath };
       } catch (error) {
-        logger.warn(
+        getLogger().warn(
           `Failed to read database config from ${envFilePath}, skipping database cleanup: ${error instanceof Error ? error.message : String(error)}`
         );
         databaseConfig = { shouldCleanup: false, envFilePath };
@@ -1858,11 +1744,25 @@ ${blockerMessage}`);
       try {
         mainWorktreePath = await findMainWorktreePathWithSettings(worktree.path, this.settingsManager);
       } catch (error) {
-        logger.warn(
+        getLogger().warn(
           `Failed to find main worktree path: ${error instanceof Error ? error.message : String(error)}`
         );
       }
     }
+    let mergeTargetBranch = null;
+    if (options.deleteBranch && worktree && !options.dryRun) {
+      try {
+        mergeTargetBranch = await getMergeTargetBranch(worktree.path, {
+          settingsManager: this.settingsManager,
+          metadataManager: this.metadataManager
+        });
+        getLogger().debug(`Pre-fetched merge target branch: ${mergeTargetBranch}`);
+      } catch (error) {
+        getLogger().warn(
+          `Failed to pre-fetch merge target branch: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
     if (options.dryRun) {
       operations.push({
         type: "worktree",
@@ -1886,7 +1786,7 @@ ${blockerMessage}`);
           message: `Worktree removed: ${worktree.path}`
         });
         await this.metadataManager.deleteMetadata(worktree.path);
-        logger.debug(`Metadata file cleanup attempted for: ${worktree.path}`);
+        getLogger().debug(`Metadata file cleanup attempted for: ${worktree.path}`);
       } catch (error) {
         const err = error instanceof Error ? error : new Error("Unknown error");
         errors.push(err);
@@ -1907,7 +1807,12 @@ ${blockerMessage}`);
         });
       } else {
         try {
-          const branchOptions = { dryRun: false };
+          const branchOptions = {
+            dryRun: false
+          };
+          if (mergeTargetBranch !== null) {
+            branchOptions.mergeTargetBranch = mergeTargetBranch;
+          }
           if (options.force !== void 0) {
             branchOptions.force = options.force;
           }
@@ -1948,7 +1853,7 @@ ${blockerMessage}`);
         } catch (error) {
           const err = error instanceof Error ? error : new Error("Unknown error");
           errors.push(err);
-          logger.warn(
+          getLogger().warn(
             `CLI symlink cleanup failed: ${err.message}`
           );
           operations.push({
@@ -1978,7 +1883,7 @@ ${blockerMessage}`);
                 mainWorktreePath ?? void 0
               );
               if (deletionResult.deleted) {
-                logger.info(`Database branch deleted: ${worktree.branch}`);
+                getLogger().info(`Database branch deleted: ${worktree.branch}`);
                 operations.push({
                   type: "database",
                   success: true,
@@ -1986,7 +1891,7 @@ ${blockerMessage}`);
                   deleted: true
                 });
               } else if (deletionResult.notFound) {
-                logger.debug(`No database branch found for: ${worktree.branch}`);
+                getLogger().debug(`No database branch found for: ${worktree.branch}`);
                 operations.push({
                   type: "database",
                   success: true,
@@ -1994,7 +1899,7 @@ ${blockerMessage}`);
                   deleted: false
                 });
               } else if (deletionResult.userDeclined) {
-                logger.info("Preview database deletion declined by user");
+                getLogger().info("Preview database deletion declined by user");
                 operations.push({
                   type: "database",
                   success: true,
@@ -2004,7 +1909,7 @@ ${blockerMessage}`);
               } else if (!deletionResult.success) {
                 const errorMsg = deletionResult.error ?? "Unknown error";
                 errors.push(new Error(errorMsg));
-                logger.warn(`Database cleanup failed: ${errorMsg}`);
+                getLogger().warn(`Database cleanup failed: ${errorMsg}`);
                 operations.push({
                   type: "database",
                   success: false,
@@ -2015,7 +1920,7 @@ ${blockerMessage}`);
                 });
               } else {
                 errors.push(new Error("Database cleanup in an unknown state"));
-                logger.warn("Database deletion returned unexpected result state");
+                getLogger().warn("Database deletion returned unexpected result state");
                 operations.push({
                   type: "database",
                   success: false,
@@ -2025,7 +1930,7 @@ ${blockerMessage}`);
               }
             } catch (error) {
               errors.push(error instanceof Error ? error : new Error(String(error)));
-              logger.warn(
+              getLogger().warn(
                 `Unexpected database cleanup exception: ${error instanceof Error ? error.message : String(error)}`
               );
               operations.push({
@@ -2072,19 +1977,19 @@ ${blockerMessage}`);
    * Terminate dev server on specified port
    */
   async terminateDevServer(port) {
-    logger.debug(`Checking for dev server on port ${port}`);
+    getLogger().debug(`Checking for dev server on port ${port}`);
     const processInfo = await this.processManager.detectDevServer(port);
     if (!processInfo) {
-      logger.debug(`No process found on port ${port}`);
+      getLogger().debug(`No process found on port ${port}`);
       return false;
     }
     if (!processInfo.isDevServer) {
-      logger.warn(
+      getLogger().warn(
         `Process on port ${port} (${processInfo.name}) doesn't appear to be a dev server, skipping`
       );
       return false;
     }
-    logger.info(`Terminating dev server: ${processInfo.name} (PID: ${processInfo.pid})`);
+    getLogger().info(`Terminating dev server: ${processInfo.name} (PID: ${processInfo.pid})`);
     await this.processManager.terminateProcess(processInfo.pid);
     const isFree = await this.processManager.verifyPortFree(port);
     if (!isFree) {
@@ -2104,23 +2009,75 @@ ${blockerMessage}`);
     if (protectedBranches.includes(branchName)) {
       throw new Error(`Cannot delete protected branch: ${branchName}`);
     }
+    const workingDir = cwd ?? await findMainWorktreePathWithSettings(void 0, this.settingsManager);
+    try {
+      await executeGitCommand(["rev-parse", "--verify", `refs/heads/${branchName}`], {
+        cwd: workingDir
+      });
+    } catch {
+      getLogger().debug(`Branch ${branchName} does not exist, skipping deletion`);
+      return true;
+    }
     if (options.dryRun) {
-      logger.info(`[DRY RUN] Would delete branch: ${branchName}`);
+      getLogger().info(`[DRY RUN] Would delete branch: ${branchName}`);
       return true;
     }
     try {
-      let workingDir = cwd ?? await findMainWorktreePathWithSettings(void 0, this.settingsManager);
-      const deleteFlag = options.force ? "-D" : "-d";
+      let deleteFlag = "-d";
+      let deleteCwd = workingDir;
+      if (options.force) {
+        deleteFlag = "-D";
+      } else if (options.mergeTargetBranch) {
+        const mergeTarget = options.mergeTargetBranch;
+        try {
+          const targetWorktreePath = await findWorktreeForBranch(mergeTarget, workingDir);
+          getLogger().debug(`Running branch delete from worktree where '${mergeTarget}' is checked out: ${targetWorktreePath}`);
+          deleteCwd = targetWorktreePath;
+        } catch {
+          getLogger().debug(`Could not find worktree for branch '${mergeTarget}', falling back to merge check`);
+          const isMerged = await isBranchMergedIntoMain(branchName, mergeTarget, workingDir);
+          if (isMerged) {
+            getLogger().debug(`Branch '${branchName}' verified merged into '${mergeTarget}', using force delete`);
+            deleteFlag = "-D";
+          }
+        }
+      } else if (options.worktreePath) {
+        getLogger().warn("deleteBranch called with worktreePath but no mergeTargetBranch - this may fail if worktree was deleted");
+        try {
+          const mergeTarget = await getMergeTargetBranch(options.worktreePath, {
+            settingsManager: this.settingsManager,
+            metadataManager: this.metadataManager
+          });
+          try {
+            const targetWorktreePath = await findWorktreeForBranch(mergeTarget, workingDir);
+            getLogger().debug(`Running branch delete from worktree where '${mergeTarget}' is checked out: ${targetWorktreePath}`);
+            deleteCwd = targetWorktreePath;
+          } catch {
+            getLogger().debug(`Could not find worktree for branch '${mergeTarget}', falling back to merge check`);
+            const isMerged = await isBranchMergedIntoMain(branchName, mergeTarget, workingDir);
+            if (isMerged) {
+              getLogger().debug(`Branch '${branchName}' verified merged into '${mergeTarget}', using force delete`);
+              deleteFlag = "-D";
+            }
+          }
+        } catch (error) {
+          getLogger().debug(`Could not read merge target from worktreePath: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
       await executeGitCommand(["branch", deleteFlag, branchName], {
-        cwd: workingDir
+        cwd: deleteCwd
       });
-      logger.info(`Branch deleted: ${branchName}`);
+      getLogger().info(`Branch deleted: ${branchName}`);
       return true;
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("not found") || errorMessage.includes("does not exist")) {
+        getLogger().debug(`Branch ${branchName} already deleted`);
+        return true;
+      }
       if (options.force) {
         throw error;
       }
-      const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("not fully merged")) {
         throw new Error(
           `Cannot delete unmerged branch '${branchName}'. Use --force to delete anyway.`
@@ -2143,17 +2100,17 @@ ${blockerMessage}`);
    */
   async cleanupDatabase(branchName, worktreePath) {
     if (!this.database) {
-      logger.debug("Database manager not available, skipping database cleanup");
+      getLogger().debug("Database manager not available, skipping database cleanup");
       return false;
     }
     try {
-      const envFilePath = path5.join(worktreePath, ".env");
+      const envFilePath = path4.join(worktreePath, ".env");
       const shouldCleanup = await this.database.shouldUseDatabaseBranching(envFilePath);
       let cwd;
       try {
         cwd = await findMainWorktreePathWithSettings(worktreePath, this.settingsManager);
       } catch (error) {
-        logger.debug(
+        getLogger().debug(
           `Could not find main worktree path, using current directory: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -2165,23 +2122,23 @@ ${blockerMessage}`);
         cwd
       );
       if (result.deleted) {
-        logger.info(`Database branch deleted: ${branchName}`);
+        getLogger().info(`Database branch deleted: ${branchName}`);
         return true;
       } else if (result.notFound) {
-        logger.debug(`No database branch found for: ${branchName}`);
+        getLogger().debug(`No database branch found for: ${branchName}`);
         return false;
       } else if (result.userDeclined) {
-        logger.info("Preview database deletion declined by user");
+        getLogger().info("Preview database deletion declined by user");
         return false;
       } else if (!result.success) {
-        logger.warn(`Database cleanup failed: ${result.error ?? "Unknown error"}`);
+        getLogger().warn(`Database cleanup failed: ${result.error ?? "Unknown error"}`);
         return false;
       } else {
-        logger.debug("Database deletion returned unexpected result");
+        getLogger().debug("Database deletion returned unexpected result");
         return false;
       }
     } catch (error) {
-      logger.warn(
+      getLogger().warn(
         `Unexpected database cleanup error: ${error instanceof Error ? error.message : String(error)}`
       );
       return false;
@@ -2202,8 +2159,13 @@ ${blockerMessage}`);
   /**
    * Validate worktree safety given a worktree object
    * Private method used internally when worktree is already known
+   *
+   * @param worktree - The worktree to validate
+   * @param identifier - The original identifier used (for error messages)
+   * @param checkBranchMerge - Whether to check if branch is merged into main (for branch deletion)
+   * @param checkRemoteBranch - Whether to check if branch exists on remote (for GitHub-PR mode)
    */
-  async validateWorktreeSafety(worktree, identifier) {
+  async validateWorktreeSafety(worktree, identifier, checkBranchMerge = false, checkRemoteBranch = false) {
     const warnings = [];
     const blockers = [];
     const isMain = await this.gitWorktree.isMainWorktree(worktree, this.settingsManager);
@@ -2220,6 +2182,44 @@ Please resolve before cleanup - you have some options:
   \u2022 Force cleanup: il cleanup ${identifier} --force (WARNING: will discard changes)`;
       blockers.push(blockerMessage);
     }
+    if ((checkBranchMerge || checkRemoteBranch) && worktree.branch) {
+      const mainBranch = await getMergeTargetBranch(worktree.path, {
+        settingsManager: this.settingsManager,
+        metadataManager: this.metadataManager
+      });
+      const remoteStatus = await checkRemoteBranchStatus(worktree.branch, worktree.path);
+      if (remoteStatus.networkError) {
+        const blockerMessage = `Cannot verify remote branch status due to network error.
+
+Error: ${remoteStatus.errorMessage ?? "Unknown network error"}
+
+Unable to determine if branch '${worktree.branch}' is safely backed up.
+Use --force to proceed without verification.`;
+        blockers.push(blockerMessage);
+      } else if (remoteStatus.exists && remoteStatus.localAhead) {
+        const blockerMessage = `Branch '${worktree.branch}' has unpushed commits that would be lost.
+The remote branch exists but your local branch is ahead.
+
+Please resolve before cleanup:
+  \u2022 Push your commits: git push origin ${worktree.branch}
+  \u2022 Force cleanup: il cleanup ${identifier} --force (WARNING: will lose commits)`;
+        blockers.push(blockerMessage);
+      } else if (remoteStatus.exists && !remoteStatus.localAhead) {
+      } else if (!remoteStatus.exists) {
+        const isMerged = await isBranchMergedIntoMain(worktree.branch, mainBranch, worktree.path);
+        if (isMerged) {
+        } else {
+          const blockerMessage = `Branch '${worktree.branch}' has not been pushed to remote and is not merged into '${mainBranch}'.
+Deleting this branch would result in data loss.
+
+Please resolve before cleanup - you have some options:
+  \u2022 Push to remote: git push -u origin ${worktree.branch}
+  \u2022 Merge to ${mainBranch}: git checkout ${mainBranch} && git merge ${worktree.branch}
+  \u2022 Force cleanup: il cleanup ${identifier} --force (WARNING: will lose commits)`;
+          blockers.push(blockerMessage);
+        }
+      }
+    }
     return {
       isSafe: blockers.length === 0,
       warnings,
@@ -2282,11 +2282,10 @@ Please resolve before cleanup - you have some options:
 };
 
 export {
-  MetadataManager,
   LoomManager,
   EnvironmentManager,
   CLIIsolationManager,
   DatabaseManager,
   ResourceCleanup
 };
-//# sourceMappingURL=chunk-2IJEMXOB.js.map
+//# sourceMappingURL=chunk-IARWMDAX.js.map