@iloom/cli 0.3.4 → 0.4.0

package/dist/index.js

@@ -9,12 +9,6 @@ var __export = (target, all) => {
 };
 
 // src/utils/logger.ts
-var logger_exports = {};
-__export(logger_exports, {
-  createLogger: () => createLogger,
-  default: () => logger_default,
-  logger: () => logger
-});
 import chalk, { Chalk } from "chalk";
 function formatMessage(message, ...args) {
   const formattedArgs = args.map(
@@ -52,7 +46,8 @@ function createLogger(options = {}) {
       },
       isDebugEnabled: () => {
         return false;
-      }
+      },
+      stdout: process.stdout
     };
   }
   return {
@@ -93,7 +88,57 @@ function createLogger(options = {}) {
     },
     isDebugEnabled: () => {
       return globalDebugEnabled;
-    }
+    },
+    stdout: process.stdout
+  };
+}
+function createStderrLogger(options = {}) {
+  const { prefix = "", timestamp = false, forceColor, debug = globalDebugEnabled } = options;
+  let localDebugEnabled = debug;
+  const customChalk = forceColor !== void 0 ? new Chalk({ level: forceColor ? 3 : 0 }) : stderrChalk;
+  const prefixStr = prefix ? `[${prefix}] ` : "";
+  const getTimestamp = () => timestamp ? `[${(/* @__PURE__ */ new Date()).toISOString()}] ` : "";
+  return {
+    info: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u{1F5C2}\uFE0F ", customChalk.blue);
+      console.error(output);
+    },
+    success: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u2705", customChalk.green);
+      console.error(output);
+    },
+    warn: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u26A0\uFE0F ", customChalk.yellow);
+      console.error(output);
+    },
+    error: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u274C", customChalk.red);
+      console.error(output);
+    },
+    debug: (message, ...args) => {
+      if (localDebugEnabled) {
+        const formatted = formatMessage(message, ...args);
+        const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+        const output = formatWithEmoji(fullMessage, "\u{1F50D}", customChalk.gray);
+        console.error(output);
+      }
+    },
+    setDebug: (enabled) => {
+      localDebugEnabled = enabled;
+    },
+    isDebugEnabled: () => {
+      return globalDebugEnabled;
+    },
+    stdout: process.stderr
+    // Use stderr for progress output in JSON mode
   };
 }
 var stdoutChalk, stderrChalk, globalDebugEnabled, logger, logger_default;
@@ -136,7 +181,8 @@ var init_logger = __esm({
       },
       isDebugEnabled: () => {
         return globalDebugEnabled;
-      }
+      },
+      stdout: process.stdout
     };
     logger_default = logger;
   }
@@ -153,6 +199,8 @@ __export(SettingsManager_exports, {
   IloomSettingsSchemaNoDefaults: () => IloomSettingsSchemaNoDefaults,
   NeonSettingsSchema: () => NeonSettingsSchema,
   SettingsManager: () => SettingsManager,
+  SpinAgentSettingsSchema: () => SpinAgentSettingsSchema,
+  SummarySettingsSchema: () => SummarySettingsSchema,
   WorkflowPermissionSchema: () => WorkflowPermissionSchema,
   WorkflowPermissionSchemaNoDefaults: () => WorkflowPermissionSchemaNoDefaults,
   WorkflowsSettingsSchema: () => WorkflowsSettingsSchema,
@@ -163,7 +211,7 @@ import path from "path";
 import os from "os";
 import { z } from "zod";
 import deepmerge from "deepmerge";
-var AgentSettingsSchema, WorkflowPermissionSchema, WorkflowPermissionSchemaNoDefaults, WorkflowsSettingsSchema, WorkflowsSettingsSchemaNoDefaults, CapabilitiesSettingsSchema, CapabilitiesSettingsSchemaNoDefaults, NeonSettingsSchema, DatabaseProvidersSettingsSchema, IloomSettingsSchema, IloomSettingsSchemaNoDefaults, SettingsManager;
+var AgentSettingsSchema, SpinAgentSettingsSchema, SummarySettingsSchema, WorkflowPermissionSchema, WorkflowPermissionSchemaNoDefaults, WorkflowsSettingsSchema, WorkflowsSettingsSchemaNoDefaults, CapabilitiesSettingsSchema, CapabilitiesSettingsSchemaNoDefaults, NeonSettingsSchema, DatabaseProvidersSettingsSchema, IloomSettingsSchema, IloomSettingsSchemaNoDefaults, SettingsManager;
 var init_SettingsManager = __esm({
   "src/lib/SettingsManager.ts"() {
     "use strict";
@@ -172,13 +220,20 @@ var init_SettingsManager = __esm({
       model: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Claude model shorthand: sonnet, opus, or haiku")
       // Future: could add other per-agent overrides
     });
+    SpinAgentSettingsSchema = z.object({
+      model: z.enum(["sonnet", "opus", "haiku"]).default("opus").describe("Claude model shorthand for spin orchestrator")
+    });
+    SummarySettingsSchema = z.object({
+      model: z.enum(["sonnet", "opus", "haiku"]).default("sonnet").describe("Claude model shorthand for session summary generation")
+    });
     WorkflowPermissionSchema = z.object({
       permissionMode: z.enum(["plan", "acceptEdits", "bypassPermissions", "default"]).optional().describe("Permission mode for Claude CLI in this workflow type"),
       noVerify: z.boolean().optional().describe("Skip pre-commit hooks (--no-verify) when committing during finish workflow"),
       startIde: z.boolean().default(true).describe("Launch IDE (code) when starting this workflow type"),
       startDevServer: z.boolean().default(true).describe("Launch development server when starting this workflow type"),
       startAiAgent: z.boolean().default(true).describe("Launch Claude Code agent when starting this workflow type"),
-      startTerminal: z.boolean().default(false).describe("Launch terminal window without dev server when starting this workflow type")
+      startTerminal: z.boolean().default(false).describe("Launch terminal window without dev server when starting this workflow type"),
+      generateSummary: z.boolean().default(true).describe("Generate and post Claude session summary when finishing this workflow type")
     });
     WorkflowPermissionSchemaNoDefaults = z.object({
       permissionMode: z.enum(["plan", "acceptEdits", "bypassPermissions", "default"]).optional().describe("Permission mode for Claude CLI in this workflow type"),
@@ -186,7 +241,8 @@ var init_SettingsManager = __esm({
       startIde: z.boolean().optional().describe("Launch IDE (code) when starting this workflow type"),
       startDevServer: z.boolean().optional().describe("Launch development server when starting this workflow type"),
       startAiAgent: z.boolean().optional().describe("Launch Claude Code agent when starting this workflow type"),
-      startTerminal: z.boolean().optional().describe("Launch terminal window without dev server when starting this workflow type")
+      startTerminal: z.boolean().optional().describe("Launch terminal window without dev server when starting this workflow type"),
+      generateSummary: z.boolean().optional().describe("Generate and post Claude session summary when finishing this workflow type")
     });
     WorkflowsSettingsSchema = z.object({
       issue: WorkflowPermissionSchema.optional(),
@@ -254,6 +310,12 @@ var init_SettingsManager = __esm({
       agents: z.record(z.string(), AgentSettingsSchema).optional().nullable().describe(
         "Per-agent configuration overrides. Available agents: iloom-issue-analyzer (analyzes issues), iloom-issue-planner (creates implementation plans), iloom-issue-analyze-and-plan (combined analysis and planning), iloom-issue-complexity-evaluator (evaluates complexity), iloom-issue-enhancer (enhances issue descriptions), iloom-issue-implementer (implements code changes), iloom-issue-reviewer (reviews code changes against requirements)"
       ),
+      spin: SpinAgentSettingsSchema.optional().describe(
+        "Spin orchestrator configuration. Model defaults to opus when not configured."
+      ),
+      summary: SummarySettingsSchema.optional().describe(
+        "Session summary generation configuration. Model defaults to sonnet when not configured."
+      ),
       capabilities: CapabilitiesSettingsSchema.describe("Project capability configurations"),
       databaseProviders: DatabaseProvidersSettingsSchema.describe("Database provider configurations"),
       issueManagement: z.object({
@@ -316,6 +378,12 @@ var init_SettingsManager = __esm({
       agents: z.record(z.string(), AgentSettingsSchema).optional().nullable().describe(
         "Per-agent configuration overrides. Available agents: iloom-issue-analyzer (analyzes issues), iloom-issue-planner (creates implementation plans), iloom-issue-analyze-and-plan (combined analysis and planning), iloom-issue-complexity-evaluator (evaluates complexity), iloom-issue-enhancer (enhances issue descriptions), iloom-issue-implementer (implements code changes), iloom-issue-reviewer (reviews code changes against requirements)"
       ),
+      spin: z.object({
+        model: z.enum(["sonnet", "opus", "haiku"]).optional()
+      }).optional().describe("Spin orchestrator configuration"),
+      summary: z.object({
+        model: z.enum(["sonnet", "opus", "haiku"]).optional()
+      }).optional().describe("Session summary generation configuration"),
       capabilities: CapabilitiesSettingsSchemaNoDefaults.describe("Project capability configurations"),
       databaseProviders: DatabaseProvidersSettingsSchema.describe("Database provider configurations"),
       issueManagement: z.object({
@@ -445,8 +513,8 @@ Note: CLI overrides were applied. Check your --set arguments.`);
        */
       formatAllZodErrors(error, settingsPath) {
         const errorMessages = error.issues.map((issue) => {
-          const path6 = issue.path.length > 0 ? issue.path.join(".") : "root";
-          return `  - ${path6}: ${issue.message}`;
+          const path7 = issue.path.length > 0 ? issue.path.join(".") : "root";
+          return `  - ${path7}: ${issue.message}`;
         });
         return new Error(
           `Settings validation failed at ${settingsPath}:
@@ -548,6 +616,28 @@ ${errorMessages.join("\n")}`
         }
         return protectedBranches;
       }
+      /**
+       * Get the spin orchestrator model with default applied
+       * Default is defined in SpinAgentSettingsSchema
+       *
+       * @param settings - Pre-loaded settings object
+       * @returns Model shorthand ('opus', 'sonnet', or 'haiku')
+       */
+      getSpinModel(settings) {
+        var _a;
+        return ((_a = settings == null ? void 0 : settings.spin) == null ? void 0 : _a.model) ?? SpinAgentSettingsSchema.parse({}).model;
+      }
+      /**
+       * Get the session summary model with default applied
+       * Default is defined in SummarySettingsSchema
+       *
+       * @param settings - Pre-loaded settings object
+       * @returns Model shorthand ('opus', 'sonnet', or 'haiku')
+       */
+      getSummaryModel(settings) {
+        var _a;
+        return ((_a = settings == null ? void 0 : settings.summary) == null ? void 0 : _a.model) ?? SummarySettingsSchema.parse({}).model;
+      }
     };
   }
 });
@@ -728,14 +818,206 @@ var WorkspaceManager = class {
 };
 
 // src/lib/GitWorktreeManager.ts
+import path4 from "path";
+import fs2 from "fs-extra";
+
+// src/utils/git.ts
+init_SettingsManager();
 import path3 from "path";
+import { execa } from "execa";
+
+// src/lib/MetadataManager.ts
+import path2 from "path";
+import os2 from "os";
 import fs from "fs-extra";
 
+// src/utils/logger-context.ts
+init_logger();
+import { AsyncLocalStorage } from "async_hooks";
+var loggerStorage = new AsyncLocalStorage();
+function getLogger() {
+  return loggerStorage.getStore() ?? logger;
+}
+
+// src/lib/MetadataManager.ts
+var MetadataManager = class {
+  constructor() {
+    this.loomsDir = path2.join(os2.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 path2.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,
+        sessionId: input.sessionId,
+        ...input.parentLoom && { parentLoom: input.parentLoom }
+      };
+      const filePath = this.getFilePath(worktreePath);
+      await fs.writeFile(filePath, JSON.stringify(content, null, 2), { mode: 420 });
+      getLogger().debug(`Metadata written for worktree: ${worktreePath}`);
+    } catch (error) {
+      getLogger().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,
+        sessionId: data.sessionId ?? null,
+        parentLoom: data.parentLoom ?? null
+      };
+    } catch (error) {
+      getLogger().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 = path2.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,
+            sessionId: data.sessionId ?? null,
+            parentLoom: data.parentLoom ?? null
+          });
+        } catch (error) {
+          getLogger().debug(
+            `Skipping metadata file ${file}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    } catch (error) {
+      getLogger().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)) {
+        getLogger().debug(`No metadata file to delete for worktree: ${worktreePath}`);
+        return;
+      }
+      await fs.unlink(filePath);
+      getLogger().debug(`Metadata deleted for worktree: ${worktreePath}`);
+    } catch (error) {
+      getLogger().warn(
+        `Failed to delete metadata for worktree: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+
 // src/utils/git.ts
-init_SettingsManager();
 init_logger();
-import path2 from "path";
-import { execa } from "execa";
 async function executeGitCommand(args, options) {
   try {
     const result = await execa("git", args, {
@@ -743,7 +1025,9 @@ async function executeGitCommand(args, options) {
       timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
       encoding: "utf8",
       stdio: (options == null ? void 0 : options.stdio) ?? "pipe",
-      verbose: logger.isDebugEnabled()
+      verbose: logger.isDebugEnabled(),
+      // Spread env conditionally - only include if defined
+      ...(options == null ? void 0 : options.env) && { env: options.env }
     });
     return result.stdout;
   } catch (error) {
@@ -879,7 +1163,7 @@ function extractIssueNumber(branchName) {
   }
   return null;
 }
-function isWorktreePath(path6) {
+function isWorktreePath(path7) {
   const worktreePatterns = [
     /\/worktrees?\//i,
     // Contains /worktree/ or /worktrees/
@@ -894,17 +1178,17 @@ function isWorktreePath(path6) {
     /\.worktree$/i
     // ends with .worktree
   ];
-  return worktreePatterns.some((pattern) => pattern.test(path6));
+  return worktreePatterns.some((pattern) => pattern.test(path7));
 }
 function generateWorktreePath(branchName, rootDir = process.cwd(), options) {
   let sanitized = branchName.replace(/\//g, "-");
   if ((options == null ? void 0 : options.isPR) && (options == null ? void 0 : options.prNumber)) {
     sanitized = `${sanitized}_pr_${options.prNumber}`;
   }
-  const parentDir = path2.dirname(rootDir);
+  const parentDir = path3.dirname(rootDir);
   let prefix;
   if ((options == null ? void 0 : options.prefix) === void 0) {
-    const mainFolderName = path2.basename(rootDir);
+    const mainFolderName = path3.basename(rootDir);
     prefix = mainFolderName ? `${mainFolderName}-looms/` : "looms/";
   } else if (options.prefix === "") {
     prefix = "";
@@ -924,43 +1208,43 @@ function generateWorktreePath(branchName, rootDir = process.cwd(), options) {
     }
   }
   if (prefix === "") {
-    return path2.join(parentDir, sanitized);
+    return path3.join(parentDir, sanitized);
   } else if (prefix.endsWith("/")) {
-    return path2.join(parentDir, prefix, sanitized);
+    return path3.join(parentDir, prefix, sanitized);
   } else if (prefix.includes("/")) {
     const lastSlashIndex = prefix.lastIndexOf("/");
     const dirPath = prefix.substring(0, lastSlashIndex);
     const prefixWithSeparator = prefix.substring(lastSlashIndex + 1);
-    return path2.join(parentDir, dirPath, `${prefixWithSeparator}${sanitized}`);
+    return path3.join(parentDir, dirPath, `${prefixWithSeparator}${sanitized}`);
   } else {
-    return path2.join(parentDir, `${prefix}${sanitized}`);
+    return path3.join(parentDir, `${prefix}${sanitized}`);
   }
 }
-async function isValidGitRepo(path6) {
+async function isValidGitRepo(path7) {
   try {
-    await executeGitCommand(["rev-parse", "--git-dir"], { cwd: path6 });
+    await executeGitCommand(["rev-parse", "--git-dir"], { cwd: path7 });
     return true;
   } catch {
     return false;
   }
 }
-async function getCurrentBranch(path6 = process.cwd()) {
+async function getCurrentBranch(path7 = process.cwd()) {
   try {
-    const result = await executeGitCommand(["branch", "--show-current"], { cwd: path6 });
+    const result = await executeGitCommand(["branch", "--show-current"], { cwd: path7 });
     return result.trim();
   } catch {
     return null;
   }
 }
-async function branchExists(branchName, path6 = process.cwd(), includeRemote = true) {
+async function branchExists(branchName, path7 = process.cwd(), includeRemote = true) {
   try {
-    const localResult = await executeGitCommand(["branch", "--list", branchName], { cwd: path6 });
+    const localResult = await executeGitCommand(["branch", "--list", branchName], { cwd: path7 });
     if (localResult.trim()) {
       return true;
     }
     if (includeRemote) {
       const remoteResult = await executeGitCommand(["branch", "-r", "--list", `*/${branchName}`], {
-        cwd: path6
+        cwd: path7
       });
       if (remoteResult.trim()) {
         return true;
@@ -971,31 +1255,31 @@ async function branchExists(branchName, path6 = process.cwd(), includeRemote = t
     return false;
   }
 }
-async function getWorktreeRoot(path6 = process.cwd()) {
+async function getWorktreeRoot(path7 = process.cwd()) {
   try {
-    const result = await executeGitCommand(["rev-parse", "--show-toplevel"], { cwd: path6 });
+    const result = await executeGitCommand(["rev-parse", "--show-toplevel"], { cwd: path7 });
     return result.trim();
   } catch {
     return null;
   }
 }
-async function getRepoRoot(path6 = process.cwd()) {
+async function getRepoRoot(path7 = process.cwd()) {
   try {
     const gitCommonDir = await executeGitCommand(
       ["rev-parse", "--path-format=absolute", "--git-common-dir"],
-      { cwd: path6 }
+      { cwd: path7 }
     );
     const trimmedPath = gitCommonDir.trim();
     const repoRoot = trimmedPath.replace(/\/\.git\/worktrees\/[^/]+$/, "").replace(/\/\.git$/, "");
     return repoRoot;
   } catch (error) {
-    logger.warn(`Failed to determine repo root from git-common-dir: ${path6}`, error instanceof Error ? error.message : String(error));
+    logger.warn(`Failed to determine repo root from git-common-dir: ${path7}`, error instanceof Error ? error.message : String(error));
     return null;
   }
 }
-async function findMainWorktreePath(path6 = process.cwd(), options) {
+async function findMainWorktreePath(path7 = process.cwd(), options) {
   try {
-    const output = await executeGitCommand(["worktree", "list", "--porcelain"], { cwd: path6 });
+    const output = await executeGitCommand(["worktree", "list", "--porcelain"], { cwd: path7 });
     const worktrees = parseWorktreeList(output, options == null ? void 0 : options.mainBranch);
     if (worktrees.length === 0) {
       throw new Error("No worktrees found in repository");
@@ -1025,30 +1309,51 @@ async function findMainWorktreePath(path6 = process.cwd(), options) {
     throw new Error(`Failed to find main worktree: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
-async function findMainWorktreePathWithSettings(path6, settingsManager) {
+async function findMainWorktreePathWithSettings(path7, settingsManager) {
   settingsManager ??= new SettingsManager();
-  const settings = await settingsManager.loadSettings(path6);
+  const settings = await settingsManager.loadSettings(path7);
   const findOptions = settings.mainBranch ? { mainBranch: settings.mainBranch } : void 0;
-  return findMainWorktreePath(path6, findOptions);
+  return findMainWorktreePath(path7, findOptions);
 }
-async function hasUncommittedChanges(path6 = process.cwd()) {
+async function findWorktreeForBranch(branchName, path7 = process.cwd()) {
   try {
-    const result = await executeGitCommand(["status", "--porcelain"], { cwd: path6 });
+    const output = await executeGitCommand(["worktree", "list", "--porcelain"], { cwd: path7 });
+    const worktrees = parseWorktreeList(output, branchName);
+    if (worktrees.length === 0) {
+      throw new Error("No worktrees found in repository");
+    }
+    const targetWorktree = worktrees.find((wt) => wt.branch === branchName);
+    if (!(targetWorktree == null ? void 0 : targetWorktree.path)) {
+      throw new Error(
+        `No worktree found with branch '${branchName}' checked out. Available worktrees: ${worktrees.map((wt) => `${wt.path} (${wt.branch})`).join(", ")}`
+      );
+    }
+    return targetWorktree.path;
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("No worktree found with branch") || error.message.includes("No worktrees found"))) {
+      throw error;
+    }
+    throw new Error(`Failed to find worktree for branch '${branchName}': ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function hasUncommittedChanges(path7 = process.cwd()) {
+  try {
+    const result = await executeGitCommand(["status", "--porcelain"], { cwd: path7 });
     return result.trim().length > 0;
   } catch {
     return false;
   }
 }
-async function getDefaultBranch(path6 = process.cwd()) {
+async function getDefaultBranch(path7 = process.cwd()) {
   try {
     const remoteResult = await executeGitCommand(["symbolic-ref", "refs/remotes/origin/HEAD"], {
-      cwd: path6
+      cwd: path7
     });
     const match = remoteResult.match(/refs\/remotes\/origin\/(.+)/);
     if (match) return match[1] ?? "main";
     const commonDefaults = ["main", "master", "develop"];
     for (const branch of commonDefaults) {
-      if (await branchExists(branch, path6)) {
+      if (await branchExists(branch, path7)) {
         return branch;
       }
     }
@@ -1057,13 +1362,13 @@ async function getDefaultBranch(path6 = process.cwd()) {
     return "main";
   }
 }
-async function findAllBranchesForIssue(issueNumber, path6 = process.cwd(), settingsManager) {
+async function findAllBranchesForIssue(issueNumber, path7 = process.cwd(), settingsManager) {
   if (!settingsManager) {
     const { SettingsManager: SM } = await Promise.resolve().then(() => (init_SettingsManager(), SettingsManager_exports));
     settingsManager = new SM();
   }
-  const protectedBranches = await settingsManager.getProtectedBranches(path6);
-  const output = await executeGitCommand(["branch", "-a"], { cwd: path6 });
+  const protectedBranches = await settingsManager.getProtectedBranches(path7);
+  const output = await executeGitCommand(["branch", "-a"], { cwd: path7 });
   const branches = [];
   const lines = output.split("\n").filter(Boolean);
   for (const line of lines) {
@@ -1120,18 +1425,18 @@ async function findAllBranchesForIssue(issueNumber, path6 = process.cwd(), setti
   }
   return branches;
 }
-async function isEmptyRepository(path6 = process.cwd()) {
+async function isEmptyRepository(path7 = process.cwd()) {
   try {
-    await executeGitCommand(["rev-parse", "--verify", "HEAD"], { cwd: path6 });
+    await executeGitCommand(["rev-parse", "--verify", "HEAD"], { cwd: path7 });
     return false;
   } catch {
     return true;
   }
 }
-async function ensureRepositoryHasCommits(path6 = process.cwd()) {
-  const isEmpty = await isEmptyRepository(path6);
+async function ensureRepositoryHasCommits(path7 = process.cwd()) {
+  const isEmpty = await isEmptyRepository(path7);
   if (isEmpty) {
-    await executeGitCommand(["commit", "--no-verify", "--allow-empty", "-m", "Initial commit"], { cwd: path6 });
+    await executeGitCommand(["commit", "--no-verify", "--allow-empty", "-m", "Initial commit"], { cwd: path7 });
   }
 }
 async function pushBranchToRemote(branchName, worktreePath, options) {
@@ -1199,6 +1504,122 @@ async function isFileGitignored(filePath, cwd = process.cwd()) {
     return false;
   }
 }
+async function isBranchMergedIntoMain(branchName, mainBranch = "main", cwd = process.cwd()) {
+  try {
+    await executeGitCommand(["merge-base", "--is-ancestor", branchName, mainBranch], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isRemoteBranchUpToDate(branchName, cwd) {
+  try {
+    const remoteResult = await executeGitCommand(["ls-remote", "--heads", "origin", branchName], { cwd });
+    if (remoteResult.trim().length === 0) {
+      return false;
+    }
+    const remoteCommit = remoteResult.trim().split("	")[0];
+    const localCommit = await executeGitCommand(["rev-parse", branchName], { cwd });
+    return localCommit.trim() === remoteCommit;
+  } catch {
+    return false;
+  }
+}
+async function checkRemoteBranchStatus(branchName, cwd) {
+  try {
+    try {
+      await executeGitCommand(["fetch", "origin", branchName], { cwd, timeout: 3e4 });
+    } catch (fetchError) {
+      const fetchErrorMessage = fetchError instanceof Error ? fetchError.message : String(fetchError);
+      if (fetchErrorMessage.includes("Could not resolve host") || fetchErrorMessage.includes("unable to access") || fetchErrorMessage.includes("network") || fetchErrorMessage.includes("Connection refused") || fetchErrorMessage.includes("Connection timed out")) {
+        return {
+          exists: false,
+          remoteAhead: false,
+          localAhead: false,
+          networkError: true,
+          errorMessage: fetchErrorMessage
+        };
+      }
+    }
+    const remoteResult = await executeGitCommand(["ls-remote", "--heads", "origin", branchName], { cwd });
+    if (remoteResult.trim().length === 0) {
+      return {
+        exists: false,
+        remoteAhead: false,
+        localAhead: false,
+        networkError: false
+      };
+    }
+    const remoteCommit = remoteResult.trim().split("	")[0];
+    if (!remoteCommit) {
+      return {
+        exists: false,
+        remoteAhead: false,
+        localAhead: false,
+        networkError: false
+      };
+    }
+    const localCommit = await executeGitCommand(["rev-parse", branchName], { cwd });
+    const localCommitTrimmed = localCommit.trim();
+    if (remoteCommit === localCommitTrimmed) {
+      return {
+        exists: true,
+        remoteAhead: false,
+        localAhead: false,
+        networkError: false
+      };
+    }
+    try {
+      await executeGitCommand(["merge-base", "--is-ancestor", localCommitTrimmed, remoteCommit], { cwd });
+      return {
+        exists: true,
+        remoteAhead: true,
+        localAhead: false,
+        networkError: false
+      };
+    } catch {
+      return {
+        exists: true,
+        remoteAhead: false,
+        localAhead: true,
+        networkError: false
+      };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("Could not resolve host") || errorMessage.includes("unable to access") || errorMessage.includes("network") || errorMessage.includes("Connection refused") || errorMessage.includes("Connection timed out")) {
+      return {
+        exists: false,
+        remoteAhead: false,
+        localAhead: false,
+        networkError: true,
+        errorMessage
+      };
+    }
+    return {
+      exists: false,
+      remoteAhead: false,
+      localAhead: false,
+      networkError: false
+    };
+  }
+}
+async function getMergeTargetBranch(worktreePath = process.cwd(), options) {
+  var _a;
+  const settingsManager = (options == null ? void 0 : options.settingsManager) ?? new SettingsManager();
+  const metadataManager = (options == null ? void 0 : options.metadataManager) ?? new MetadataManager();
+  logger.debug(`Checking for parent loom metadata at: ${worktreePath}`);
+  const metadata = await metadataManager.readMetadata(worktreePath);
+  if ((_a = metadata == null ? void 0 : metadata.parentLoom) == null ? void 0 : _a.branchName) {
+    logger.debug(`Using parent branch as merge target: ${metadata.parentLoom.branchName}`);
+    return metadata.parentLoom.branchName;
+  }
+  logger.debug("No parent loom metadata found, falling back to settings");
+  const settings = await settingsManager.loadSettings(worktreePath);
+  const mainBranch = settings.mainBranch ?? "main";
+  logger.debug(`Using configured main branch as merge target: ${mainBranch}`);
+  return mainBranch;
+}
 
 // src/lib/GitWorktreeManager.ts
 var GitWorktreeManager = class {
@@ -1266,12 +1687,12 @@ var GitWorktreeManager = class {
     if (!options.branch) {
       throw new Error("Branch name is required");
     }
-    const absolutePath = path3.resolve(options.path);
-    if (await fs.pathExists(absolutePath)) {
+    const absolutePath = path4.resolve(options.path);
+    if (await fs2.pathExists(absolutePath)) {
       if (!options.force) {
         throw new Error(`Path already exists: ${absolutePath}`);
       }
-      await fs.remove(absolutePath);
+      await fs2.remove(absolutePath);
     }
     const args = ["worktree", "add"];
     if (options.createBranch) {
@@ -1298,11 +1719,10 @@ var GitWorktreeManager = class {
     const worktrees = await this.listWorktrees({ porcelain: true });
     const worktree = worktrees.find((wt) => wt.path === worktreePath);
     if (!worktree) {
-      const { logger: logger4 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
-      logger4.debug(`Looking for worktree path: ${worktreePath}`);
-      logger4.debug(`Found ${worktrees.length} worktrees:`);
+      getLogger().debug(`Looking for worktree path: ${worktreePath}`);
+      getLogger().debug(`Found ${worktrees.length} worktrees:`);
       worktrees.forEach((wt, i) => {
-        logger4.debug(`  ${i}: path="${wt.path}", branch="${wt.branch}"`);
+        getLogger().debug(`  ${i}: path="${wt.path}", branch="${wt.branch}"`);
       });
       throw new Error(`Worktree not found: ${worktreePath}`);
     }
@@ -1322,8 +1742,8 @@ var GitWorktreeManager = class {
     if (options.force) args.push("--force");
     args.push(worktreePath);
     await executeGitCommand(args, { cwd: this._workingDirectory });
-    if (options.removeDirectory && await fs.pathExists(worktreePath)) {
-      await fs.remove(worktreePath);
+    if (options.removeDirectory && await fs2.pathExists(worktreePath)) {
+      await fs2.remove(worktreePath);
     }
     if (options.removeBranch && !worktree.bare) {
       try {
@@ -1346,7 +1766,7 @@ var GitWorktreeManager = class {
     let isValidRepo = false;
     let hasValidBranch = false;
     try {
-      existsOnDisk = await fs.pathExists(worktreePath);
+      existsOnDisk = await fs2.pathExists(worktreePath);
       if (!existsOnDisk) {
         issues.push("Worktree directory does not exist on disk");
       }
@@ -1764,42 +2184,35 @@ async function createIssue(title, body, options) {
   };
 }
 
-// src/lib/GitHubService.ts
-init_logger();
-
 // src/utils/prompt.ts
 init_logger();
 import * as readline from "readline";
 async function promptConfirmation(message, defaultValue = false) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
   const suffix = defaultValue ? "[Y/n]" : "[y/N]";
   const fullMessage = `${message} ${suffix}: `;
-  return new Promise((resolve) => {
-    rl.question(fullMessage, (answer) => {
-      rl.close();
-      const normalized = answer.trim().toLowerCase();
-      if (normalized === "") {
-        resolve(defaultValue);
-        return;
-      }
-      if (normalized === "y" || normalized === "yes") {
-        resolve(true);
-        return;
-      }
-      if (normalized === "n" || normalized === "no") {
-        resolve(false);
-        return;
-      }
-      logger.warn("Invalid input, using default value", {
-        input: answer,
-        defaultValue
+  while (true) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(fullMessage, (ans) => {
+        rl.close();
+        resolve(ans);
       });
-      resolve(defaultValue);
     });
-  });
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === "") {
+      return defaultValue;
+    }
+    if (normalized === "y" || normalized === "yes") {
+      return true;
+    }
+    if (normalized === "n" || normalized === "no") {
+      return false;
+    }
+    logger.warn("Invalid input. Please enter y/yes or n/no.");
+  }
 }
 
 // src/lib/GitHubService.ts
@@ -1829,12 +2242,12 @@ var GitHubService = class {
       return { type: "unknown", identifier: null, rawInput: input };
     }
     const number = parseInt(numberMatch[1], 10);
-    logger.debug("Checking if input is a PR", { number });
+    getLogger().debug("Checking if input is a PR", { number });
     const pr = await this.isValidPR(number, repo);
     if (pr) {
       return { type: "pr", identifier: number.toString(), rawInput: input };
     }
-    logger.debug("Checking if input is an issue", { number });
+    getLogger().debug("Checking if input is an issue", { number });
     const issue = await this.isValidIssue(number, repo);
     if (issue) {
       return { type: "issue", identifier: number.toString(), rawInput: input };
@@ -1938,17 +2351,17 @@ var GitHubService = class {
     return createIssue(title, body, { repo: repository, labels });
   }
   async getIssueUrl(issueNumber, repo) {
-    logger.debug("Fetching issue URL", { issueNumber, repo });
+    getLogger().debug("Fetching issue URL", { issueNumber, repo });
     const issue = await fetchGhIssue(issueNumber, repo);
     return issue.url;
   }
   // GitHub Projects integration
   async moveIssueToInProgress(issueNumber) {
-    logger.info("Moving issue to In Progress in GitHub Projects", {
+    getLogger().info("Moving issue to In Progress in GitHub Projects", {
       issueNumber
     });
     if (!await hasProjectScope()) {
-      logger.warn("Missing project scope in GitHub CLI auth");
+      getLogger().warn("Missing project scope in GitHub CLI auth");
       throw new GitHubError(
         "MISSING_SCOPE" /* MISSING_SCOPE */,
         "GitHub CLI lacks project scope. Run: gh auth refresh -s project"
@@ -1959,18 +2372,18 @@ var GitHubService = class {
       const repoInfo = await executeGhCommand(["repo", "view", "--json", "owner,name"]);
       owner = repoInfo.owner.login;
     } catch (error) {
-      logger.warn("Could not determine repository info", { error });
+      getLogger().warn("Could not determine repository info", { error });
       return;
     }
     let projects;
     try {
       projects = await fetchProjectList(owner);
     } catch (error) {
-      logger.warn("Could not fetch projects", { owner, error });
+      getLogger().warn("Could not fetch projects", { owner, error });
       return;
     }
     if (!projects.length) {
-      logger.warn("No projects found", { owner });
+      getLogger().warn("No projects found", { owner });
       return;
     }
     for (const project of projects) {
@@ -1983,14 +2396,14 @@ var GitHubService = class {
     try {
       items = await fetchProjectItems(project.number, owner);
     } catch (error) {
-      logger.debug("Could not fetch project items", { project: project.number, error });
+      getLogger().debug("Could not fetch project items", { project: project.number, error });
       return;
     }
     const item = items.find(
       (i) => i.content.type === "Issue" && i.content.number === issueNumber
     );
     if (!item) {
-      logger.debug("Issue not found in project", {
+      getLogger().debug("Issue not found in project", {
         issueNumber,
         projectNumber: project.number
       });
@@ -2000,19 +2413,19 @@ var GitHubService = class {
     try {
       fieldsData = await fetchProjectFields(project.number, owner);
     } catch (error) {
-      logger.debug("Could not fetch project fields", { project: project.number, error });
+      getLogger().debug("Could not fetch project fields", { project: project.number, error });
       return;
     }
     const statusField = fieldsData.fields.find((f) => f.name === "Status");
     if (!statusField) {
-      logger.debug("No Status field found in project", { projectNumber: project.number });
+      getLogger().debug("No Status field found in project", { projectNumber: project.number });
       return;
     }
     const inProgressOption = (_a = statusField.options) == null ? void 0 : _a.find(
       (o) => o.name === "In Progress" || o.name === "In progress"
     );
     if (!inProgressOption) {
-      logger.debug("No In Progress option found in Status field", { projectNumber: project.number });
+      getLogger().debug("No In Progress option found in Status field", { projectNumber: project.number });
       return;
     }
     try {
@@ -2022,12 +2435,12 @@ var GitHubService = class {
         statusField.id,
         inProgressOption.id
       );
-      logger.info("Updated issue status in project", {
+      getLogger().info("Updated issue status in project", {
         issueNumber,
         projectNumber: project.number
       });
     } catch (error) {
-      logger.debug("Could not update project item", { item: item.id, error });
+      getLogger().debug("Could not update project item", { item: item.id, error });
     }
   }
   // Utility methods
@@ -2388,7 +2801,6 @@ ${issue.body}`;
 };
 
 // src/lib/IssueTrackerFactory.ts
-init_logger();
 var IssueTrackerFactory = class {
   /**
    * Create an IssueTracker instance based on settings configuration
@@ -2401,11 +2813,11 @@ var IssueTrackerFactory = class {
   static create(settings) {
     var _a, _b;
     const provider = ((_a = settings.issueManagement) == null ? void 0 : _a.provider) ?? "github";
-    logger.debug(`IssueTrackerFactory: Creating tracker for provider "${provider}"`);
-    logger.debug(`IssueTrackerFactory: issueManagement settings:`, JSON.stringify(settings.issueManagement, null, 2));
+    getLogger().debug(`IssueTrackerFactory: Creating tracker for provider "${provider}"`);
+    getLogger().debug(`IssueTrackerFactory: issueManagement settings:`, JSON.stringify(settings.issueManagement, null, 2));
     switch (provider) {
       case "github":
-        logger.debug("IssueTrackerFactory: Creating GitHubService");
+        getLogger().debug("IssueTrackerFactory: Creating GitHubService");
         return new GitHubService();
       case "linear": {
         const linearSettings = (_b = settings.issueManagement) == null ? void 0 : _b.linear;
@@ -2416,7 +2828,7 @@ var IssueTrackerFactory = class {
         if (linearSettings == null ? void 0 : linearSettings.branchFormat) {
           linearConfig.branchFormat = linearSettings.branchFormat;
         }
-        logger.debug(`IssueTrackerFactory: Creating LinearService with config:`, JSON.stringify(linearConfig, null, 2));
+        getLogger().debug(`IssueTrackerFactory: Creating LinearService with config:`, JSON.stringify(linearConfig, null, 2));
         return new LinearService(linearConfig);
       }
       default:
@@ -2437,12 +2849,11 @@ var IssueTrackerFactory = class {
 };
 
 // src/lib/EnvironmentManager.ts
-init_logger();
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 
 // src/utils/env.ts
 init_logger();
-import path4 from "path";
+import path5 from "path";
 import dotenvFlow from "dotenv-flow";
 function parseEnvFile(content) {
   const envMap = /* @__PURE__ */ new Map();
@@ -2509,7 +2920,7 @@ async function buildEnvSourceCommands(workspacePath, fileExists) {
   const files = getDotenvFlowFiles();
   const commands = [];
   for (const file of files) {
-    const fullPath = path4.join(workspacePath, file);
+    const fullPath = path5.join(workspacePath, file);
     const exists = await fileExists(fullPath);
     if (exists) {
       commands.push(`source ${file}`);
@@ -2520,7 +2931,7 @@ async function buildEnvSourceCommands(workspacePath, fileExists) {
 async function findEnvFileContainingVariable(workspacePath, variableName, fileExists, getEnvVariable) {
   const files = getDotenvFlowFiles().reverse();
   for (const file of files) {
-    const fullPath = path4.join(workspacePath, file);
+    const fullPath = path5.join(workspacePath, file);
     if (!await fileExists(fullPath)) {
       continue;
     }
@@ -2560,7 +2971,6 @@ function calculatePortForBranch(branchName, basePort = 3e3) {
 }
 
 // src/lib/EnvironmentManager.ts
-var logger2 = createLogger({ prefix: "\u{1F4DD}" });
 var EnvironmentManager = class {
   constructor() {
     this.backupSuffix = ".backup";
@@ -2575,15 +2985,15 @@ var EnvironmentManager = class {
     if (!validation.valid) {
       throw new Error(validation.error ?? "Invalid variable name");
     }
-    const fileExists = await fs2.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 fs2.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 fs2.readFile(filePath, "utf8");
+    const existingContent = await fs3.readFile(filePath, "utf8");
     const envMap = parseEnvFile(existingContent);
     let backupPath;
     if (backup) {
@@ -2612,15 +3022,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 fs2.writeFile(filePath, newContent, "utf8");
+    await fs3.writeFile(filePath, newContent, "utf8");
     return backupPath;
   }
   /**
@@ -2628,10 +3038,10 @@ var EnvironmentManager = class {
    */
   async readEnvFile(filePath) {
     try {
-      const content = await fs2.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();
@@ -2651,13 +3061,13 @@ var EnvironmentManager = class {
    * @private
    */
   async copyIfExists(source, destination) {
-    const sourceExists = await fs2.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 fs2.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
@@ -2717,7 +3127,7 @@ var EnvironmentManager = class {
    */
   async validateEnvFile(filePath) {
     try {
-      const content = await fs2.readFile(filePath, "utf8");
+      const content = await fs3.readFile(filePath, "utf8");
       const envMap = parseEnvFile(content);
       const errors = [];
       for (const [key, value] of envMap.entries()) {
@@ -2745,25 +3155,23 @@ var EnvironmentManager = class {
   async createBackup(filePath) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const backupPath = `${filePath}${this.backupSuffix}-${timestamp}`;
-    await fs2.copy(filePath, backupPath);
-    logger2.debug(`Created backup at ${backupPath}`);
+    await fs3.copy(filePath, backupPath);
+    getLogger().debug(`Created backup at ${backupPath}`);
     return backupPath;
   }
 };
 
 // src/lib/DatabaseManager.ts
-init_logger();
-import fs3 from "fs-extra";
-var logger3 = createLogger({ prefix: "\u{1F5C2}\uFE0F" });
+import fs4 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");
     }
   }
   /**
@@ -2780,12 +3188,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;
@@ -2806,28 +3214,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;
@@ -2853,7 +3261,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,
@@ -2862,7 +3270,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,
@@ -2874,7 +3282,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,
@@ -2885,7 +3293,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,
@@ -2898,7 +3306,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 {
@@ -2919,13 +3327,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;
   }
   /**
@@ -2936,26 +3344,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) => fs3.pathExists(p),
+        async (p) => fs4.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.`
         );
@@ -2963,13 +3371,13 @@ var DatabaseManager = class {
       const hasDefaultVar = await hasVariableInAnyEnvFile(
         workspacePath,
         "DATABASE_URL",
-        async (p) => fs3.pathExists(p),
+        async (p) => fs4.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) {
@@ -2986,6 +3394,7 @@ init_logger();
 import { execa as execa4 } from "execa";
 import { existsSync as existsSync2 } from "fs";
 import { join } from "path";
+import { createHash as createHash3 } from "crypto";
 
 // src/utils/terminal.ts
 import { execa as execa3 } from "execa";
@@ -3062,8 +3471,8 @@ async function buildAppleScript(options) {
   script += `end tell`;
   return script;
 }
-function escapePathForAppleScript(path6) {
-  return path6.replace(/'/g, "'\\''");
+function escapePathForAppleScript(path7) {
+  return path7.replace(/'/g, "'\\''");
 }
 function escapeForAppleScript(command) {
   return command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
@@ -3152,7 +3561,8 @@ function parseJsonStreamOutput(output) {
   }
 }
 async function launchClaude(prompt, options = {}) {
-  const { model, permissionMode, addDir, headless = false, appendSystemPrompt, mcpConfig, allowedTools, disallowedTools, agents } = options;
+  const { model, permissionMode, addDir, headless = false, appendSystemPrompt, mcpConfig, allowedTools, disallowedTools, agents, sessionId } = options;
+  const log = getLogger();
   const args = [];
   if (headless) {
     args.push("-p");
@@ -3186,6 +3596,9 @@ async function launchClaude(prompt, options = {}) {
   if (agents) {
     args.push("--agents", JSON.stringify(agents));
   }
+  if (sessionId) {
+    args.push("--session-id", sessionId);
+  }
   try {
     if (headless) {
       const isDebugMode = logger.isDebugEnabled();
@@ -3210,13 +3623,13 @@ async function launchClaude(prompt, options = {}) {
           const text = chunk.toString();
           outputBuffer += text;
           if (isDebugMode) {
-            process.stdout.write(text);
+            log.stdout.write(text);
           } else {
             if (isFirstProgress) {
-              process.stdout.write("\u{1F916} .");
+              log.stdout.write("\u{1F916} .");
               isFirstProgress = false;
             } else {
-              process.stdout.write(".");
+              log.stdout.write(".");
             }
           }
         });
@@ -3225,36 +3638,137 @@ async function launchClaude(prompt, options = {}) {
       if (isStreaming) {
         const rawOutput = outputBuffer.trim();
         if (!isDebugMode) {
-          process.stdout.write("\n");
+          log.stdout.write("\n");
         }
         return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
       } else {
         if (isDebugMode) {
-          process.stdout.write(result.stdout);
+          log.stdout.write(result.stdout);
           if (result.stdout && !result.stdout.endsWith("\n")) {
-            process.stdout.write("\n");
+            log.stdout.write("\n");
           }
         } else {
-          process.stdout.write("\u{1F916} .");
-          process.stdout.write("\n");
+          log.stdout.write("\u{1F916} .");
+          log.stdout.write("\n");
         }
         const rawOutput = result.stdout.trim();
         return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
       }
     } else {
-      await execa4("claude", [...args, "--", prompt], {
-        ...addDir && { cwd: addDir },
-        stdio: "inherit",
-        // Let user interact directly in current terminal
-        timeout: 0,
-        // Disable timeout
-        verbose: logger.isDebugEnabled()
-      });
-      return;
+      try {
+        await execa4("claude", [...args, "--", prompt], {
+          ...addDir && { cwd: addDir },
+          stdio: ["inherit", "inherit", "pipe"],
+          // Capture stderr to detect session conflicts
+          timeout: 0,
+          // Disable timeout
+          verbose: logger.isDebugEnabled()
+        });
+        return;
+      } catch (interactiveError) {
+        const interactiveExecaError = interactiveError;
+        const interactiveErrorMessage = interactiveExecaError.stderr ?? interactiveExecaError.message ?? "";
+        const sessionMatch = interactiveErrorMessage.match(/Session ID ([0-9a-f-]+) is already in use/i);
+        const conflictSessionId = sessionMatch == null ? void 0 : sessionMatch[1];
+        if (sessionMatch && sessionId && conflictSessionId) {
+          log.debug(`Session ID ${conflictSessionId} already in use, retrying with --resume`);
+          const resumeArgs = args.filter((arg, idx) => {
+            if (arg === "--session-id") return false;
+            if (idx > 0 && args[idx - 1] === "--session-id") return false;
+            return true;
+          });
+          resumeArgs.push("--resume", conflictSessionId);
+          await execa4("claude", resumeArgs, {
+            ...addDir && { cwd: addDir },
+            stdio: "inherit",
+            timeout: 0,
+            verbose: logger.isDebugEnabled()
+          });
+          return;
+        }
+        throw interactiveError;
+      }
     }
   } catch (error) {
     const execaError = error;
     const errorMessage = execaError.stderr ?? execaError.message ?? "Unknown Claude CLI error";
+    const sessionInUseMatch = errorMessage.match(/Session ID ([0-9a-f-]+) is already in use/i);
+    const extractedSessionId = sessionInUseMatch == null ? void 0 : sessionInUseMatch[1];
+    if (sessionInUseMatch && sessionId && extractedSessionId) {
+      log.debug(`Session ID ${extractedSessionId} already in use, retrying with --resume`);
+      const resumeArgs = args.filter((arg, idx) => {
+        if (arg === "--session-id") return false;
+        if (idx > 0 && args[idx - 1] === "--session-id") return false;
+        return true;
+      });
+      resumeArgs.push("--resume", extractedSessionId);
+      try {
+        if (headless) {
+          const isDebugMode = logger.isDebugEnabled();
+          const execaOptions = {
+            input: prompt,
+            timeout: 0,
+            ...addDir && { cwd: addDir },
+            verbose: isDebugMode,
+            ...isDebugMode && { stdio: ["pipe", "pipe", "pipe"] }
+          };
+          const subprocess = execa4("claude", resumeArgs, execaOptions);
+          const isJsonStreamFormat = resumeArgs.includes("--output-format") && resumeArgs.includes("stream-json");
+          let outputBuffer = "";
+          let isStreaming = false;
+          let isFirstProgress = true;
+          if (subprocess.stdout && typeof subprocess.stdout.on === "function") {
+            isStreaming = true;
+            subprocess.stdout.on("data", (chunk) => {
+              const text = chunk.toString();
+              outputBuffer += text;
+              if (isDebugMode) {
+                log.stdout.write(text);
+              } else {
+                if (isFirstProgress) {
+                  log.stdout.write("\u{1F916} .");
+                  isFirstProgress = false;
+                } else {
+                  log.stdout.write(".");
+                }
+              }
+            });
+          }
+          const result = await subprocess;
+          if (isStreaming) {
+            const rawOutput = outputBuffer.trim();
+            if (!isDebugMode) {
+              log.stdout.write("\n");
+            }
+            return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
+          } else {
+            if (isDebugMode) {
+              log.stdout.write(result.stdout);
+              if (result.stdout && !result.stdout.endsWith("\n")) {
+                log.stdout.write("\n");
+              }
+            } else {
+              log.stdout.write("\u{1F916} .");
+              log.stdout.write("\n");
+            }
+            const rawOutput = result.stdout.trim();
+            return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
+          }
+        } else {
+          await execa4("claude", resumeArgs, {
+            ...addDir && { cwd: addDir },
+            stdio: "inherit",
+            timeout: 0,
+            verbose: logger.isDebugEnabled()
+          });
+          return;
+        }
+      } catch (retryError) {
+        const retryExecaError = retryError;
+        const retryErrorMessage = retryExecaError.stderr ?? retryExecaError.message ?? "Unknown Claude CLI error";
+        throw new Error(`Claude CLI error: ${retryErrorMessage}`);
+      }
+    }
     throw new Error(`Claude CLI error: ${errorMessage}`);
   }
 }
@@ -3300,7 +3814,7 @@ async function launchClaudeInNewTerminalWindow(_prompt, options) {
 init_logger();
 import { readFile as readFile2 } from "fs/promises";
 import { accessSync } from "fs";
-import path5 from "path";
+import path6 from "path";
 import { fileURLToPath } from "url";
 var PromptTemplateManager = class {
   constructor(templateDir) {
@@ -3309,17 +3823,17 @@ var PromptTemplateManager = class {
     } else {
       const currentFileUrl = import.meta.url;
       const currentFilePath = fileURLToPath(currentFileUrl);
-      const distDir = path5.dirname(currentFilePath);
-      let templateDir2 = path5.join(distDir, "prompts");
+      const distDir = path6.dirname(currentFilePath);
+      let templateDir2 = path6.join(distDir, "prompts");
       let currentDir = distDir;
-      while (currentDir !== path5.dirname(currentDir)) {
-        const candidatePath = path5.join(currentDir, "prompts");
+      while (currentDir !== path6.dirname(currentDir)) {
+        const candidatePath = path6.join(currentDir, "prompts");
         try {
           accessSync(candidatePath);
           templateDir2 = candidatePath;
           break;
         } catch {
-          currentDir = path5.dirname(currentDir);
+          currentDir = path6.dirname(currentDir);
         }
       }
       this.templateDir = templateDir2;
@@ -3334,7 +3848,7 @@ var PromptTemplateManager = class {
    * Load a template file by name
    */
   async loadTemplate(templateName) {
-    const templatePath = path5.join(this.templateDir, `${templateName}-prompt.txt`);
+    const templatePath = path6.join(this.templateDir, `${templateName}-prompt.txt`);
     logger.debug("Loading template", {
       templateName,
       templateDir: this.templateDir,
@@ -3419,6 +3933,18 @@ var PromptTemplateManager = class {
     if (variables.VSCODE_SETTINGS_GITIGNORED !== void 0) {
       result = result.replace(/VSCODE_SETTINGS_GITIGNORED/g, variables.VSCODE_SETTINGS_GITIGNORED);
     }
+    if (variables.SESSION_CONTEXT !== void 0) {
+      result = result.replace(/SESSION_CONTEXT/g, variables.SESSION_CONTEXT);
+    }
+    if (variables.BRANCH_NAME !== void 0) {
+      result = result.replace(/BRANCH_NAME/g, variables.BRANCH_NAME);
+    }
+    if (variables.LOOM_TYPE !== void 0) {
+      result = result.replace(/LOOM_TYPE/g, variables.LOOM_TYPE);
+    }
+    if (variables.COMPACT_SUMMARIES !== void 0) {
+      result = result.replace(/COMPACT_SUMMARIES/g, variables.COMPACT_SUMMARIES);
+    }
     return result;
   }
   /**
@@ -3477,6 +4003,18 @@ var PromptTemplateManager = class {
     } else {
       result = result.replace(firstTimeUserRegex, "");
     }
+    const interactiveModeRegex = /\{\{#IF INTERACTIVE_MODE\}\}(.*?)\{\{\/IF INTERACTIVE_MODE\}\}/gs;
+    if (variables.INTERACTIVE_MODE === true) {
+      result = result.replace(interactiveModeRegex, "$1");
+    } else {
+      result = result.replace(interactiveModeRegex, "");
+    }
+    const compactSummariesRegex = /\{\{#IF COMPACT_SUMMARIES\}\}(.*?)\{\{\/IF COMPACT_SUMMARIES\}\}/gs;
+    if (variables.COMPACT_SUMMARIES !== void 0 && variables.COMPACT_SUMMARIES !== "") {
+      result = result.replace(compactSummariesRegex, "$1");
+    } else {
+      result = result.replace(compactSummariesRegex, "");
+    }
     return result;
   }
   /**
@@ -3502,15 +4040,6 @@ var ClaudeService = class {
   async isAvailable() {
     return detectClaudeCli();
   }
-  /**
-   * Get the appropriate model for a workflow type
-   */
-  getModelForWorkflow(type) {
-    if (type === "issue") {
-      return "claude-sonnet-4-20250514";
-    }
-    return void 0;
-  }
   /**
    * Get the appropriate permission mode for a workflow type
    */
@@ -3554,7 +4083,6 @@ var ClaudeService = class {
         variables.PORT = port;
       }
       const prompt = await this.templateManager.getPrompt(type, variables);
-      const model = this.getModelForWorkflow(type);
       const permissionMode = this.getPermissionModeForWorkflow(type);
       if (permissionMode === "bypassPermissions") {
         logger.warn(
@@ -3565,9 +4093,6 @@ var ClaudeService = class {
         addDir: workspacePath,
         headless
       };
-      if (model !== void 0) {
-        claudeOptions.model = model;
-      }
       if (permissionMode !== void 0 && permissionMode !== "default") {
         claudeOptions.permissionMode = permissionMode;
       }
@@ -3585,7 +4110,6 @@ var ClaudeService = class {
       }
       logger.debug("Launching Claude for workflow", {
         type,
-        model,
         permissionMode,
         headless,
         workspacePath
@@ -3987,7 +4511,9 @@ export {
   UserAbortedCommitError,
   WorkspaceManager,
   branchExists,
+  checkRemoteBranchStatus,
   createLogger,
+  createStderrLogger,
   ensureRepositoryHasCommits,
   executeGitCommand,
   extractIssueNumber,
@@ -3995,16 +4521,20 @@ export {
   findAllBranchesForIssue,
   findMainWorktreePath,
   findMainWorktreePathWithSettings,
+  findWorktreeForBranch,
   generateWorktreePath,
   getCurrentBranch,
   getDefaultBranch,
+  getMergeTargetBranch,
   getRepoRoot,
   getWorktreeRoot,
   hasUncommittedChanges,
+  isBranchMergedIntoMain,
   isEmptyRepository,
   isFileGitignored,
   isFileTrackedByGit,
   isPRBranch,
+  isRemoteBranchUpToDate,
   isValidGitRepo,
   isWorktreePath,
   logger,