@iloom/cli 0.3.4 → 0.4.1

package/dist/cli.js

@@ -1,63 +1,62 @@
 #!/usr/bin/env node
+import {
+  SessionSummaryService
+} from "./chunk-TMZAVPGF.js";
 import {
   CLIIsolationManager,
   DatabaseManager,
   EnvironmentManager,
   LoomManager,
-  MetadataManager,
   ResourceCleanup
-} from "./chunk-2IJEMXOB.js";
-import {
-  IdentifierParser
-} from "./chunk-OXAM2WVC.js";
-import {
-  ProcessManager
-} from "./chunk-VU3QMIP2.js";
+} from "./chunk-IARWMDAX.js";
 import {
   InitCommand,
   ShellCompletion
-} from "./chunk-UAN4A3YU.js";
-import {
-  getConfiguredRepoFromSettings,
-  getEffectivePRTargetRemote,
-  hasMultipleRemotes,
-  parseGitRemotes
-} from "./chunk-PA6Q6AWM.js";
-import "./chunk-OSCLCMDG.js";
+} from "./chunk-G6CIIJLT.js";
+import "./chunk-UYWAESOT.js";
 import {
   IssueEnhancementService,
   capitalizeFirstLetter
-} from "./chunk-IFB4Z76W.js";
-import {
-  openBrowser
-} from "./chunk-YETJNRQM.js";
+} from "./chunk-VTXCGKV5.js";
 import {
   MergeManager
-} from "./chunk-2MAIX45J.js";
+} from "./chunk-BIIQHEXJ.js";
 import {
   FirstRunManager,
   IssueTrackerFactory,
   generateIssueManagementMcpConfig
-} from "./chunk-DLHA5VQ3.js";
+} from "./chunk-HD5SUKI2.js";
+import "./chunk-QHA67Q7A.js";
 import {
   AgentManager
-} from "./chunk-OC4H6HJD.js";
+} from "./chunk-O7WHXLCB.js";
+import {
+  IdentifierParser
+} from "./chunk-55TB3FSG.js";
+import {
+  ProcessManager
+} from "./chunk-VU3QMIP2.js";
+import {
+  openBrowser
+} from "./chunk-YETJNRQM.js";
 import {
   GitWorktreeManager
-} from "./chunk-2CXREBLZ.js";
+} from "./chunk-JC5HXN75.js";
 import {
   detectPackageManager,
   installDependencies,
   runScript
-} from "./chunk-ZT3YZB4K.js";
+} from "./chunk-VBFDVGAE.js";
 import {
   ClaudeContextManager
-} from "./chunk-AKUJXDNW.js";
-import "./chunk-PGPI5LR4.js";
-import "./chunk-RIEO2WML.js";
+} from "./chunk-UPUAQYAW.js";
+import "./chunk-POI7KLBH.js";
+import {
+  extractSettingsOverrides
+} from "./chunk-GYCR2LOU.js";
 import {
   DefaultBranchNamingService
-} from "./chunk-SUOXY5WJ.js";
+} from "./chunk-QIUJPPJQ.js";
 import {
   ProjectCapabilityDetector
 } from "./chunk-EBISESAP.js";
@@ -65,45 +64,58 @@ import {
   hasScript,
   readPackageJson
 } from "./chunk-2ZPFJQ3B.js";
-import {
-  extractSettingsOverrides
-} from "./chunk-GYCR2LOU.js";
 import {
   createNeonProviderFromSettings
-} from "./chunk-5VK4NRSF.js";
+} from "./chunk-UNXRACJ7.js";
+import {
+  getConfiguredRepoFromSettings,
+  getEffectivePRTargetRemote,
+  hasMultipleRemotes,
+  parseGitRemotes
+} from "./chunk-PSFVTBM7.js";
 import {
   executeGitCommand,
   extractIssueNumber,
   findMainWorktreePathWithSettings,
+  getMergeTargetBranch,
   getRepoRoot,
   pushBranchToRemote
-} 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 {
   GitHubService
-} from "./chunk-M7JJCX53.js";
+} from "./chunk-OEGECBFS.js";
 import {
   executeGhCommand
-} from "./chunk-3RUPPQRG.js";
+} from "./chunk-KO2FOMHL.js";
 import {
   promptCommitAction,
   promptConfirmation,
   waitForKeypress
-} from "./chunk-CE26YH2U.js";
-import "./chunk-CFFQ2Z7A.js";
+} from "./chunk-SJ2GZ6RF.js";
+import "./chunk-WUQQNE63.js";
 import {
   detectClaudeCli,
   launchClaude
-} from "./chunk-OYF4VIFI.js";
-import "./chunk-RW54ZMBM.js";
+} from "./chunk-RUC7OULH.js";
+import "./chunk-VAYGNQTE.js";
 import {
   loadEnvIntoProcess
-} from "./chunk-UJL4HI2R.js";
+} from "./chunk-Z5NXYJIG.js";
+import {
+  getLogger,
+  withLogger
+} from "./chunk-6UIGZD2N.js";
+import "./chunk-74VMN2KC.js";
 import {
+  createStderrLogger,
   logger
-} from "./chunk-GEHQXLEI.js";
+} from "./chunk-UYVWLISQ.js";
 
 // src/cli.ts
 import { program, Option } from "commander";
@@ -158,7 +170,7 @@ async function launchFirstRunSetup() {
   logger.info(
     "iloom will now launch an interactive configuration session with Claude."
   );
-  const { waitForKeypress: waitForKeypress2 } = await import("./prompt-QALMYTVC.js");
+  const { waitForKeypress: waitForKeypress2 } = await import("./prompt-A7GGRHSY.js");
   await waitForKeypress2("Press any key to start configuration...");
   const initCommand = new InitCommand();
   await initCommand.execute(
@@ -181,10 +193,10 @@ var StartCommand = class {
     this.providedLoomManager = loomManager;
     const envResult = loadEnvIntoProcess();
     if (envResult.error) {
-      logger.debug(`Environment loading warning: ${envResult.error.message}`);
+      getLogger().debug(`Environment loading warning: ${envResult.error.message}`);
     }
     if (envResult.parsed) {
-      logger.debug(`Loaded ${Object.keys(envResult.parsed).length} environment variables`);
+      getLogger().debug(`Loaded ${Object.keys(envResult.parsed).length} environment variables`);
     }
   }
   /**
@@ -228,36 +240,40 @@ var StartCommand = class {
    * Main entry point for the start command
    */
   async execute(input) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
+    const isJsonMode = input.options.json === true;
     try {
       const initialSettings = await this.settingsManager.loadSettings();
-      if (process.env.FORCE_FIRST_TIME_SETUP === "true" || await needsFirstRunSetup()) {
+      if (!isJsonMode && (process.env.FORCE_FIRST_TIME_SETUP === "true" || await needsFirstRunSetup())) {
         await launchFirstRunSetup();
         const newSettings = await this.settingsManager.loadSettings();
         const newProvider = ((_a = newSettings.issueManagement) == null ? void 0 : _a.provider) ?? "github";
         if (newProvider !== this.issueTracker.providerName) {
-          logger.debug(`Reinitializing issue tracker: provider changed to "${newProvider}"`);
+          getLogger().debug(`Reinitializing issue tracker: provider changed to "${newProvider}"`);
           this.issueTracker = IssueTrackerFactory.create(newSettings);
         }
       }
       let repo;
       if (this.issueTracker.providerName === "github" && await hasMultipleRemotes()) {
         repo = await getConfiguredRepoFromSettings(initialSettings);
-        logger.info(`Using GitHub repository: ${repo}`);
+        getLogger().info(`Using GitHub repository: ${repo}`);
       }
       const loomManager = await this.initializeLoomManager();
       let parentLoom = await this.detectParentLoom(loomManager);
       const parsed = await this.parseInput(input.identifier, repo);
       await this.validateInput(parsed, repo);
       if (parentLoom) {
-        const { isInteractiveEnvironment, promptConfirmation: promptConfirmation2 } = await import("./prompt-QALMYTVC.js");
+        const { isInteractiveEnvironment, promptConfirmation: promptConfirmation2 } = await import("./prompt-A7GGRHSY.js");
         const parentDisplay = parentLoom.type === "issue" ? `issue #${parentLoom.identifier}` : parentLoom.type === "pr" ? `PR #${parentLoom.identifier}` : `branch ${parentLoom.identifier}`;
         if (input.options.childLoom === true) {
-          logger.info(`Creating as child loom of ${parentDisplay} (--child-loom flag)`);
+          getLogger().info(`Creating as child loom of ${parentDisplay} (--child-loom flag)`);
         } else if (input.options.childLoom === false) {
           parentLoom = null;
-          logger.info("Creating as independent loom (--no-child-loom flag)");
+          getLogger().info("Creating as independent loom (--no-child-loom flag)");
         } else {
+          if (isJsonMode) {
+            throw new Error("JSON mode requires explicit --child-loom or --no-child-loom flag when running from inside a loom");
+          }
           let createAsChild = true;
           if (isInteractiveEnvironment()) {
             createAsChild = await promptConfirmation2(
@@ -266,19 +282,19 @@ var StartCommand = class {
               // Default yes
             );
           } else {
-            logger.error(`Non-interactive environment detected, use either --child-loom or --no-child-loom to specify behavior`);
+            getLogger().error(`Non-interactive environment detected, use either --child-loom or --no-child-loom to specify behavior`);
             process.exit(1);
           }
           if (!createAsChild) {
             parentLoom = null;
-            logger.info("Creating as independent loom");
+            getLogger().info("Creating as independent loom");
           }
         }
       } else if (input.options.childLoom === true) {
-        logger.debug("--child-loom flag provided but not running from inside an existing loom (ignored)");
+        getLogger().debug("--child-loom flag provided but not running from inside an existing loom (ignored)");
       }
       if (parsed.type === "description") {
-        logger.info("Creating GitHub issue from description...");
+        getLogger().info("Creating GitHub issue from description...");
         const title = capitalizeFirstLetter(parsed.originalInput);
         const body = input.options.body ? capitalizeFirstLetter(input.options.body) : "";
         const result = await this.issueTracker.createIssue(
@@ -287,17 +303,20 @@ var StartCommand = class {
           body
           // Use capitalized body or empty
         );
-        logger.success(`Created issue #${result.number}: ${result.url}`);
+        getLogger().success(`Created issue #${result.number}: ${result.url}`);
         parsed.type = "issue";
         parsed.number = result.number;
       }
       if (input.options.oneShot === "bypassPermissions") {
-        const { promptConfirmation: promptConfirmation2 } = await import("./prompt-QALMYTVC.js");
+        if (isJsonMode) {
+          throw new Error("JSON mode does not support bypassPermissions confirmation prompt");
+        }
+        const { promptConfirmation: promptConfirmation2 } = await import("./prompt-A7GGRHSY.js");
         const confirmed = await promptConfirmation2(
-          "\u26A0\uFE0F  WARNING: bypassPermissions mode will allow Claude to execute all tool calls without confirmation. This can be dangerous. Do you want to proceed?"
+          "WARNING: bypassPermissions mode will allow Claude to execute all tool calls without confirmation. This can be dangerous. Do you want to proceed?"
         );
         if (!confirmed) {
-          logger.info("Operation cancelled by user");
+          getLogger().info("Operation cancelled by user");
           process.exit(0);
         }
       }
@@ -308,13 +327,13 @@ var StartCommand = class {
       const { extractRawSetArguments, getExecutablePath } = await import("./cli-overrides-XFZWY7CM.js");
       const setArguments = extractRawSetArguments();
       const executablePath = getExecutablePath();
-      logger.info(`\u2705 Validated input: ${this.formatParsedInput(parsed)}`);
+      getLogger().info(`Validated input: ${this.formatParsedInput(parsed)}`);
       const identifier = parsed.type === "branch" ? parsed.branchName ?? "" : parsed.number ?? 0;
       const enableClaude = input.options.claude ?? (workflowConfig == null ? void 0 : workflowConfig.startAiAgent) ?? true;
       const enableCode = input.options.code ?? (workflowConfig == null ? void 0 : workflowConfig.startIde) ?? true;
       const enableDevServer = input.options.devServer ?? (workflowConfig == null ? void 0 : workflowConfig.startDevServer) ?? true;
       const enableTerminal = input.options.terminal ?? (workflowConfig == null ? void 0 : workflowConfig.startTerminal) ?? false;
-      logger.debug("Final workflow config values:", {
+      getLogger().debug("Final workflow config values:", {
         enableClaude,
         enableCode,
         enableDevServer,
@@ -335,19 +354,31 @@ var StartCommand = class {
           ...executablePath && { executablePath }
         }
       });
-      logger.success(`\u2705 Created loom: ${loom.id} at ${loom.path}`);
-      logger.info(`   Branch: ${loom.branch}`);
+      getLogger().success(`Created loom: ${loom.id} at ${loom.path}`);
+      getLogger().info(`   Branch: ${loom.branch}`);
       if ((_c = loom.capabilities) == null ? void 0 : _c.includes("web")) {
-        logger.info(`   Port: ${loom.port}`);
+        getLogger().info(`   Port: ${loom.port}`);
       }
       if ((_d = loom.issueData) == null ? void 0 : _d.title) {
-        logger.info(`   Title: ${loom.issueData.title}`);
+        getLogger().info(`   Title: ${loom.issueData.title}`);
+      }
+      if (isJsonMode) {
+        return {
+          id: loom.id,
+          path: loom.path,
+          branch: loom.branch,
+          type: parsed.type,
+          identifier: loom.identifier,
+          ...loom.port !== void 0 && { port: loom.port },
+          ...((_e = loom.issueData) == null ? void 0 : _e.title) && { title: loom.issueData.title },
+          ...loom.capabilities && { capabilities: loom.capabilities }
+        };
       }
     } catch (error) {
       if (error instanceof Error) {
-        logger.error(`\u274C ${error.message}`);
+        getLogger().error(`${error.message}`);
       } else {
-        logger.error("\u274C An unknown error occurred");
+        getLogger().error("An unknown error occurred");
       }
       throw error;
     }
@@ -440,7 +471,7 @@ var StartCommand = class {
         }
         const pr = await this.issueTracker.fetchPR(parsed.number, repo);
         await this.issueTracker.validatePRState(pr);
-        logger.debug(`Validated PR #${parsed.number}`);
+        getLogger().debug(`Validated PR #${parsed.number}`);
         break;
       }
       case "issue": {
@@ -449,7 +480,7 @@ var StartCommand = class {
         }
         const issue = await this.issueTracker.fetchIssue(parsed.number, repo);
         await this.issueTracker.validateIssueState(issue);
-        logger.debug(`Validated issue #${parsed.number}`);
+        getLogger().debug(`Validated issue #${parsed.number}`);
         break;
       }
       case "branch": {
@@ -461,11 +492,11 @@ var StartCommand = class {
             "Invalid branch name. Use only letters, numbers, hyphens, underscores, and slashes"
           );
         }
-        logger.debug(`Validated branch name: ${parsed.branchName}`);
+        getLogger().debug(`Validated branch name: ${parsed.branchName}`);
         break;
       }
       case "description": {
-        logger.debug("Detected description input", {
+        getLogger().debug("Detected description input", {
           length: parsed.originalInput.length
         });
         break;
@@ -520,7 +551,7 @@ var StartCommand = class {
       if (!parentLoom) {
         return null;
       }
-      logger.debug(`Detected parent loom: ${parentLoom.type} ${parentLoom.identifier} at ${parentLoom.path}`);
+      getLogger().debug(`Detected parent loom: ${parentLoom.type} ${parentLoom.identifier} at ${parentLoom.path}`);
       const result = {
         type: parentLoom.type,
         identifier: parentLoom.identifier,
@@ -534,12 +565,12 @@ var StartCommand = class {
         const databaseBranch = await loomManager.getDatabaseBranchForLoom(parentLoom.path);
         if (databaseBranch) {
           result.databaseBranch = databaseBranch;
-          logger.debug(`Detected parent database branch: ${databaseBranch}`);
+          getLogger().debug(`Detected parent database branch: ${databaseBranch}`);
         }
       }
       return result;
     } catch (error) {
-      logger.debug(`Failed to detect parent loom: ${error instanceof Error ? error.message : "Unknown error"}`);
+      getLogger().debug(`Failed to detect parent loom: ${error instanceof Error ? error.message : "Unknown error"}`);
       return null;
     }
   }
@@ -556,20 +587,23 @@ var AddIssueCommand = class {
    * 1. Validate description format
    * 2. Skip enhancement if body provided, otherwise enhance description with Claude Code
    * 3. Create GitHub issue
-   * 4. Wait for keypress and open browser for review
-   * 5. Return issue number
+   * 4. Wait for keypress and open browser for review (unless --json mode)
+   * 5. Return issue number or full result object (when --json)
    */
   async execute(input) {
     const description = capitalizeFirstLetter(input.description);
     const body = input.options.body ? capitalizeFirstLetter(input.options.body) : void 0;
-    if (process.env.FORCE_FIRST_TIME_SETUP === "true" || await needsFirstRunSetup()) {
+    const isJsonMode = input.options.json === true;
+    if (!isJsonMode && (process.env.FORCE_FIRST_TIME_SETUP === "true" || await needsFirstRunSetup())) {
       await launchFirstRunSetup();
     }
     const settings = await this.settingsManager.loadSettings();
     let repo;
     if (this.enhancementService.issueTracker.providerName === "github" && await hasMultipleRemotes()) {
       repo = await getConfiguredRepoFromSettings(settings);
-      logger.info(`Using GitHub repository: ${repo}`);
+      if (!isJsonMode) {
+        getLogger().info(`Using GitHub repository: ${repo}`);
+      }
     }
     if (!description || !this.enhancementService.validateDescription(description)) {
       throw new Error("Description is required and must be more than 30 characters with at least 3 words");
@@ -580,6 +614,15 @@ var AddIssueCommand = class {
       issueBody,
       repo
     );
+    if (isJsonMode) {
+      const resultData = {
+        url: result.url,
+        id: typeof result.number === "string" ? parseInt(result.number, 10) : result.number,
+        title: description,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return resultData;
+    }
     await this.enhancementService.waitForReviewAndOpen(result.number);
     return result.number;
   }
@@ -599,25 +642,31 @@ var EnhanceCommand = class {
    * 3. Load agent configurations
    * 4. Invoke Claude CLI with enhancer agent
    * 5. Parse response to determine outcome
-   * 6. Handle browser interaction based on outcome
+   * 6. Handle browser interaction based on outcome (unless --json mode)
+   * 7. Return result object when --json mode
    */
   async execute(input) {
     const { issueNumber, options } = input;
     const { author } = options;
-    if (process.env.FORCE_FIRST_TIME_SETUP === "true" || await needsFirstRunSetup()) {
+    const isJsonMode = options.json === true;
+    if (!isJsonMode && (process.env.FORCE_FIRST_TIME_SETUP === "true" || await needsFirstRunSetup())) {
       await launchFirstRunSetup();
     }
     const settings = await this.settingsManager.loadSettings();
     let repo;
     if (this.issueTracker.providerName === "github" && await hasMultipleRemotes()) {
       repo = await getConfiguredRepoFromSettings(settings);
-      logger.info(`Using GitHub repository: ${repo}`);
+      if (!isJsonMode) {
+        getLogger().info(`Using GitHub repository: ${repo}`);
+      }
     }
     this.validateIssueNumber(issueNumber);
-    logger.info(`Fetching issue #${issueNumber}...`);
+    if (!isJsonMode) {
+      getLogger().info(`Fetching issue #${issueNumber}...`);
+    }
     const issue = await this.issueTracker.fetchIssue(issueNumber, repo);
-    logger.debug("Issue fetched successfully", { number: issue.number, title: issue.title });
-    logger.debug("Loading agent configurations...");
+    getLogger().debug("Issue fetched successfully", { number: issue.number, title: issue.title });
+    getLogger().debug("Loading agent configurations...");
     const loadedAgents = await this.agentManager.loadAgents(settings);
     const agents = this.agentManager.formatForCli(loadedAgents);
     let mcpConfig;
@@ -626,7 +675,7 @@ var EnhanceCommand = class {
     try {
       const provider = this.issueTracker.providerName;
       mcpConfig = await generateIssueManagementMcpConfig("issue", repo, provider, settings);
-      logger.debug("Generated MCP configuration for issue management:", { mcpConfig });
+      getLogger().debug("Generated MCP configuration for issue management:", { mcpConfig });
       allowedTools = [
         "mcp__issue_management__get_issue",
         "mcp__issue_management__get_comment",
@@ -634,11 +683,13 @@ var EnhanceCommand = class {
         "mcp__issue_management__update_comment"
       ];
       disallowedTools = ["Bash(gh api:*)"];
-      logger.debug("Configured tool filtering for issue workflow", { allowedTools, disallowedTools });
+      getLogger().debug("Configured tool filtering for issue workflow", { allowedTools, disallowedTools });
     } catch (error) {
-      logger.warn(`Failed to generate MCP config: ${error instanceof Error ? error.message : "Unknown error"}`);
+      getLogger().warn(`Failed to generate MCP config: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    if (!isJsonMode) {
+      getLogger().info("Invoking enhancer agent. This may take a moment...");
     }
-    logger.info("Invoking enhancer agent. This may take a moment...");
     const prompt = this.constructPrompt(issueNumber, author);
     const response = await launchClaude(prompt, {
       headless: true,
@@ -649,16 +700,36 @@ var EnhanceCommand = class {
       ...disallowedTools && { disallowedTools }
     });
     const result = this.parseEnhancerResponse(response);
+    if (isJsonMode) {
+      const commentId = result.url ? this.extractCommentId(result.url) : 0;
+      const resultData = {
+        url: result.url ?? issue.url,
+        id: commentId,
+        title: issue.title,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        enhanced: result.enhanced
+      };
+      return resultData;
+    }
     if (!result.enhanced) {
-      logger.success("Issue already has thorough description. No enhancement needed.");
+      getLogger().success("Issue already has thorough description. No enhancement needed.");
       return;
     }
-    logger.success(`Issue #${issueNumber} enhanced successfully!`);
-    logger.info(`Enhanced specification available at: ${result.url}`);
+    getLogger().success(`Issue #${issueNumber} enhanced successfully!`);
+    getLogger().info(`Enhanced specification available at: ${result.url}`);
     if (!options.noBrowser && result.url) {
       await this.promptAndOpenBrowser(result.url);
     }
   }
+  /**
+   * Extract comment ID from GitHub comment URL
+   * @param url - GitHub comment URL (e.g., https://github.com/owner/repo/issues/123#issuecomment-456789)
+   * @returns Comment ID as number, or 0 if not found
+   */
+  extractCommentId(url) {
+    const match = url.match(/issuecomment-(\d+)/);
+    return (match == null ? void 0 : match[1]) ? parseInt(match[1], 10) : 0;
+  }
   /**
    * Validate that issue number is a valid positive integer
    */
@@ -702,7 +773,7 @@ IMPORTANT: When you create your analysis comment, tag @${author} in the "Questio
       throw new Error("No response from enhancer agent");
     }
     const trimmed = response.trim();
-    logger.debug(`RESPONSE FROM ENHANCER AGENT: '${trimmed}'`);
+    getLogger().debug(`RESPONSE FROM ENHANCER AGENT: '${trimmed}'`);
     if (trimmed.toLowerCase().startsWith("permission denied:")) {
       const errorMessage = trimmed.substring("permission denied:".length).trim();
       throw new Error(`Permission denied: ${errorMessage}`);
@@ -727,18 +798,20 @@ IMPORTANT: When you create your analysis comment, tag @${author} in the "Questio
         "Press q to quit or any other key to view the enhanced issue in a web browser..."
       );
       if (key.toLowerCase() === "q") {
-        logger.info("Skipping browser opening");
+        getLogger().info("Skipping browser opening");
         return;
       }
       await openBrowser(commentUrl);
     } catch (error) {
-      logger.warn(`Failed to open browser: ${error instanceof Error ? error.message : "Unknown error"}`);
+      getLogger().warn(`Failed to open browser: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
 };
 
 // src/lib/ValidationRunner.ts
 var ValidationRunner = class {
+  constructor() {
+  }
   /**
    * Run all validations in sequence: typecheck → lint → test
    * Fails fast on first error
@@ -781,14 +854,22 @@ var ValidationRunner = class {
   }
   /**
    * Run typecheck validation
+   * Prefers 'compile' script over 'typecheck' if both exist
    */
   async runTypecheck(worktreePath, dryRun) {
     const stepStartTime = Date.now();
+    let scriptToRun = null;
     try {
       const pkgJson = await readPackageJson(worktreePath);
+      const hasCompileScript = hasScript(pkgJson, "compile");
       const hasTypecheckScript = hasScript(pkgJson, "typecheck");
-      if (!hasTypecheckScript) {
-        logger.debug("Skipping typecheck - no typecheck script found");
+      if (hasCompileScript) {
+        scriptToRun = "compile";
+      } else if (hasTypecheckScript) {
+        scriptToRun = "typecheck";
+      }
+      if (!scriptToRun) {
+        getLogger().debug("Skipping typecheck - no compile or typecheck script found");
         return {
           step: "typecheck",
           passed: true,
@@ -798,7 +879,7 @@ var ValidationRunner = class {
       }
     } catch (error) {
       if (error instanceof Error && error.message.includes("package.json not found")) {
-        logger.debug("Skipping typecheck - no package.json found (non-Node.js project)");
+        getLogger().debug("Skipping typecheck - no package.json found (non-Node.js project)");
         return {
           step: "typecheck",
           passed: true,
@@ -810,42 +891,43 @@ var ValidationRunner = class {
     }
     const packageManager = await detectPackageManager(worktreePath);
     if (dryRun) {
-      const command = packageManager === "npm" ? "npm run typecheck" : `${packageManager} typecheck`;
-      logger.info(`[DRY RUN] Would run: ${command}`);
+      const command = packageManager === "npm" ? `npm run ${scriptToRun}` : `${packageManager} ${scriptToRun}`;
+      getLogger().info(`[DRY RUN] Would run: ${command}`);
       return {
-        step: "typecheck",
+        step: scriptToRun,
         passed: true,
         skipped: false,
         duration: Date.now() - stepStartTime
       };
     }
-    logger.info("Running typecheck...");
+    getLogger().info(`Running ${scriptToRun}...`);
     try {
-      await runScript("typecheck", worktreePath, [], { quiet: true });
-      logger.success("Typecheck passed");
+      await runScript(scriptToRun, worktreePath, [], { quiet: true });
+      getLogger().success(`${scriptToRun.charAt(0).toUpperCase() + scriptToRun.slice(1)} passed`);
       return {
-        step: "typecheck",
+        step: scriptToRun,
         passed: true,
         skipped: false,
         duration: Date.now() - stepStartTime
       };
     } catch {
       const fixed = await this.attemptClaudeFix(
-        "typecheck",
+        scriptToRun,
         worktreePath,
         packageManager
       );
       if (fixed) {
         return {
-          step: "typecheck",
+          step: scriptToRun,
           passed: true,
           skipped: false,
           duration: Date.now() - stepStartTime
         };
       }
-      const runCommand = packageManager === "npm" ? "npm run typecheck" : `${packageManager} typecheck`;
+      const runCommand = packageManager === "npm" ? `npm run ${scriptToRun}` : `${packageManager} ${scriptToRun}`;
+      const stepLabel = scriptToRun.charAt(0).toUpperCase() + scriptToRun.slice(1);
       throw new Error(
-        `Error: Typecheck failed.
+        `Error: ${stepLabel} failed.
 Fix type errors before merging.
 
 Run '${runCommand}' to see detailed errors.`
@@ -861,7 +943,7 @@ Run '${runCommand}' to see detailed errors.`
       const pkgJson = await readPackageJson(worktreePath);
       const hasLintScript = hasScript(pkgJson, "lint");
       if (!hasLintScript) {
-        logger.debug("Skipping lint - no lint script found");
+        getLogger().debug("Skipping lint - no lint script found");
         return {
           step: "lint",
           passed: true,
@@ -871,7 +953,7 @@ Run '${runCommand}' to see detailed errors.`
       }
     } catch (error) {
       if (error instanceof Error && error.message.includes("package.json not found")) {
-        logger.debug("Skipping lint - no package.json found (non-Node.js project)");
+        getLogger().debug("Skipping lint - no package.json found (non-Node.js project)");
         return {
           step: "lint",
           passed: true,
@@ -884,7 +966,7 @@ Run '${runCommand}' to see detailed errors.`
     const packageManager = await detectPackageManager(worktreePath);
     if (dryRun) {
       const command = packageManager === "npm" ? "npm run lint" : `${packageManager} lint`;
-      logger.info(`[DRY RUN] Would run: ${command}`);
+      getLogger().info(`[DRY RUN] Would run: ${command}`);
       return {
         step: "lint",
         passed: true,
@@ -892,10 +974,10 @@ Run '${runCommand}' to see detailed errors.`
         duration: Date.now() - stepStartTime
       };
     }
-    logger.info("Running lint...");
+    getLogger().info("Running lint...");
     try {
       await runScript("lint", worktreePath, [], { quiet: true });
-      logger.success("Linting passed");
+      getLogger().success("Linting passed");
       return {
         step: "lint",
         passed: true,
@@ -934,7 +1016,7 @@ Run '${runCommand}' to see detailed errors.`
       const pkgJson = await readPackageJson(worktreePath);
       const hasTestScript = hasScript(pkgJson, "test");
       if (!hasTestScript) {
-        logger.debug("Skipping tests - no test script found");
+        getLogger().debug("Skipping tests - no test script found");
         return {
           step: "test",
           passed: true,
@@ -944,7 +1026,7 @@ Run '${runCommand}' to see detailed errors.`
       }
     } catch (error) {
       if (error instanceof Error && error.message.includes("package.json not found")) {
-        logger.debug("Skipping tests - no package.json found (non-Node.js project)");
+        getLogger().debug("Skipping tests - no package.json found (non-Node.js project)");
         return {
           step: "test",
           passed: true,
@@ -957,7 +1039,7 @@ Run '${runCommand}' to see detailed errors.`
     const packageManager = await detectPackageManager(worktreePath);
     if (dryRun) {
       const command = packageManager === "npm" ? "npm run test" : `${packageManager} test`;
-      logger.info(`[DRY RUN] Would run: ${command}`);
+      getLogger().info(`[DRY RUN] Would run: ${command}`);
       return {
         step: "test",
         passed: true,
@@ -965,10 +1047,10 @@ Run '${runCommand}' to see detailed errors.`
         duration: Date.now() - stepStartTime
       };
     }
-    logger.info("Running tests...");
+    getLogger().info("Running tests...");
     try {
       await runScript("test", worktreePath, [], { quiet: true });
-      logger.success("Tests passed");
+      getLogger().success("Tests passed");
       return {
         step: "test",
         passed: true,
@@ -1002,7 +1084,7 @@ Run '${runCommand}' to see detailed errors.`
    * Attempt to fix validation errors using Claude
    * Pattern based on MergeManager.attemptClaudeConflictResolution
    *
-   * @param validationType - Type of validation that failed ('typecheck' | 'lint' | 'test')
+   * @param validationType - Type of validation that failed ('compile' | 'typecheck' | 'lint' | 'test')
    * @param worktreePath - Path to the worktree
    * @param packageManager - Detected package manager
    * @returns true if Claude fixed the issue, false otherwise
@@ -1010,13 +1092,13 @@ Run '${runCommand}' to see detailed errors.`
   async attemptClaudeFix(validationType, worktreePath, packageManager) {
     const isClaudeAvailable = await detectClaudeCli();
     if (!isClaudeAvailable) {
-      logger.debug("Claude CLI not available, skipping auto-fix");
+      getLogger().debug("Claude CLI not available, skipping auto-fix");
       return false;
     }
     const validationCommand = this.getValidationCommand(validationType, packageManager);
     const prompt = this.getClaudePrompt(validationType, validationCommand);
     const validationTypeCapitalized = validationType.charAt(0).toUpperCase() + validationType.slice(1);
-    logger.info(`Launching Claude to help fix ${validationTypeCapitalized} errors...`);
+    getLogger().info(`Launching Claude to help fix ${validationTypeCapitalized} errors...`);
     try {
       await launchClaude(prompt, {
         addDir: worktreePath,
@@ -1027,17 +1109,17 @@ Run '${runCommand}' to see detailed errors.`
         model: "sonnet"
         // Use Sonnet model
       });
-      logger.info(`Re-running ${validationTypeCapitalized} after Claude's fixes...`);
+      getLogger().info(`Re-running ${validationTypeCapitalized} after Claude's fixes...`);
       try {
         await runScript(validationType, worktreePath, [], { quiet: true });
-        logger.success(`${validationTypeCapitalized} passed after Claude auto-fix`);
+        getLogger().success(`${validationTypeCapitalized} passed after Claude auto-fix`);
         return true;
       } catch {
-        logger.warn(`${validationTypeCapitalized} still failing after Claude's help`);
+        getLogger().warn(`${validationTypeCapitalized} still failing after Claude's help`);
         return false;
       }
     } catch (error) {
-      logger.warn("Claude auto-fix failed", {
+      getLogger().warn("Claude auto-fix failed", {
         error: error instanceof Error ? error.message : String(error)
       });
       return false;
@@ -1058,8 +1140,9 @@ Run '${runCommand}' to see detailed errors.`
    */
   getClaudePrompt(validationType, validationCommand) {
     switch (validationType) {
+      case "compile":
       case "typecheck":
-        return `There are TypeScript errors in this codebase. Please analyze the typecheck output, identify all type errors, and fix them. Run '${validationCommand}' to see the errors, then make the necessary code changes to resolve all type issues. When you are done, tell the user to quit using /exit to continue the validation process.`;
+        return `There are TypeScript errors in this codebase. Please analyze the ${validationType} output, identify all type errors, and fix them. Run '${validationCommand}' to see the errors, then make the necessary code changes to resolve all type issues. When you are done, tell the user to quit using /exit to continue the validation process.`;
       case "lint":
         return `There are ESLint errors in this codebase. Please analyze the linting output, identify all linting issues, and fix them. Run '${validationCommand}' to see the errors, then make the necessary code changes to resolve all linting issues. Focus on code quality, consistency, and following the project's linting rules. When you are done, tell the user to quit using /exit to continue the validation process.`;
       case "test":
@@ -1068,6 +1151,54 @@ Run '${runCommand}' to see detailed errors.`
   }
 };
 
+// src/utils/vscode.ts
+import { execa } from "execa";
+function isRunningInVSCode() {
+  return process.env.TERM_PROGRAM === "vscode";
+}
+function isRunningInCursor() {
+  return !!process.env.CURSOR_TRACE_ID;
+}
+function isRunningInAntigravity() {
+  return !!process.env.ANTIGRAVITY_CLI_ALIAS;
+}
+async function isVSCodeAvailable() {
+  try {
+    await execa("command", ["-v", "code"], {
+      shell: true,
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    logger.debug("VSCode CLI not available", { error });
+    return false;
+  }
+}
+async function isCursorAvailable() {
+  try {
+    await execa("command", ["-v", "cursor"], {
+      shell: true,
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    logger.debug("Cursor CLI not available", { error });
+    return false;
+  }
+}
+async function isAntigravityAvailable() {
+  try {
+    await execa("command", ["-v", "agy"], {
+      shell: true,
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    logger.debug("Antigravity CLI not available", { error });
+    return false;
+  }
+}
+
 // src/types/index.ts
 var UserAbortedCommitError = class extends Error {
   constructor(message = "User aborted the commit") {
@@ -1077,7 +1208,12 @@ var UserAbortedCommitError = class extends Error {
 };
 
 // src/lib/CommitManager.ts
+import { writeFile, readFile as readFile2, unlink } from "fs/promises";
+import { join } from "path";
+import { execa as execa2 } from "execa";
 var CommitManager = class {
+  constructor() {
+  }
   /**
    * Detect uncommitted changes in a worktree
    * Parses git status --porcelain output into structured GitStatus
@@ -1106,11 +1242,11 @@ var CommitManager = class {
    */
   async commitChanges(worktreePath, options) {
     if (options.dryRun) {
-      logger.info("[DRY RUN] Would run: git add -A");
-      logger.info("[DRY RUN] Would generate commit message with Claude (if available)");
+      getLogger().info("[DRY RUN] Would run: git add -A");
+      getLogger().info("[DRY RUN] Would generate commit message with Claude (if available)");
       const fallbackMessage = this.generateFallbackMessage(options);
       const verifyFlag = options.skipVerify ? " --no-verify" : "";
-      logger.info(`[DRY RUN] Would commit with message${verifyFlag}: ${fallbackMessage}`);
+      getLogger().info(`[DRY RUN] Would commit with message${verifyFlag}: ${fallbackMessage}`);
       return;
     }
     await executeGitCommand(["add", "-A"], { cwd: worktreePath });
@@ -1119,12 +1255,12 @@ var CommitManager = class {
       try {
         message = await this.generateClaudeCommitMessage(worktreePath, options.issueNumber);
       } catch (error) {
-        logger.debug("Claude commit message generation failed, using fallback", { error });
+        getLogger().debug("Claude commit message generation failed, using fallback", { error });
       }
     }
     message ??= this.generateFallbackMessage(options);
     if (options.skipVerify) {
-      logger.warn("\u26A0\uFE0F  Skipping pre-commit hooks (--no-verify configured in settings)");
+      getLogger().warn("Skipping pre-commit hooks (--no-verify configured in settings)");
     }
     try {
       if (options.noReview || options.message) {
@@ -1145,17 +1281,25 @@ var CommitManager = class {
           }
           await executeGitCommand(commitArgs, { cwd: worktreePath });
         } else {
-          logger.info("Opening git editor for commit message review...");
-          const commitArgs = ["commit", "-e", "-m", message];
-          if (options.skipVerify) {
-            commitArgs.push("--no-verify");
+          getLogger().info("Opening editor for commit message review...");
+          if (isRunningInAntigravity() && await isAntigravityAvailable()) {
+            await this.commitWithExternalEditor(worktreePath, message, options, "agy", "Antigravity");
+          } else if (isRunningInCursor() && await isCursorAvailable()) {
+            await this.commitWithExternalEditor(worktreePath, message, options, "cursor", "Cursor");
+          } else if (isRunningInVSCode() && await isVSCodeAvailable()) {
+            await this.commitWithExternalEditor(worktreePath, message, options, "code", "VSCode");
+          } else {
+            const commitArgs = ["commit", "-e", "-m", message];
+            if (options.skipVerify) {
+              commitArgs.push("--no-verify");
+            }
+            await executeGitCommand(commitArgs, {
+              cwd: worktreePath,
+              stdio: "inherit",
+              timeout: 3e5
+              // 5 minutes for interactive editing
+            });
           }
-          await executeGitCommand(commitArgs, {
-            cwd: worktreePath,
-            stdio: "inherit",
-            timeout: 3e5
-            // 5 minutes for interactive editing
-          });
         }
       }
     } catch (error) {
@@ -1163,12 +1307,51 @@ var CommitManager = class {
         throw error;
       }
       if (error instanceof Error && error.message.includes("nothing to commit")) {
-        logger.info("No changes to commit");
+        getLogger().info("No changes to commit");
         return;
       }
       throw error;
     }
   }
+  /**
+   * Commit with external editor CLI (VSCode, Cursor, Antigravity, etc.)
+   * Handles file creation, editing, and commit to ensure the file opens
+   * in the current editor window (preserves IPC context)
+   */
+  async commitWithExternalEditor(worktreePath, message, options, cliCommand, editorName) {
+    const commitMsgPath = join(worktreePath, ".COMMIT_EDITMSG");
+    const initialContent = `${message}
+
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# Save and close the file to complete the commit.
+`;
+    await writeFile(commitMsgPath, initialContent, "utf-8");
+    try {
+      getLogger().debug(`Opening commit message in ${editorName}: ${commitMsgPath}`);
+      await execa2(cliCommand, ["--wait", commitMsgPath], {
+        cwd: worktreePath,
+        stdio: "inherit"
+      });
+      const editedContent = await readFile2(commitMsgPath, "utf-8");
+      const finalMessage = editedContent.split("\n").filter((line) => !line.startsWith("#")).join("\n").trim();
+      if (!finalMessage) {
+        throw new UserAbortedCommitError();
+      }
+      const commitArgs = ["commit", "-F", commitMsgPath];
+      if (options.skipVerify) {
+        commitArgs.push("--no-verify");
+      }
+      await writeFile(commitMsgPath, finalMessage, "utf-8");
+      await executeGitCommand(commitArgs, { cwd: worktreePath });
+    } finally {
+      try {
+        await unlink(commitMsgPath);
+      } catch {
+      }
+    }
+  }
   /**
    * Generate simple fallback commit message when Claude unavailable
    * Used as fallback for Claude-powered commit messages
@@ -1222,61 +1405,62 @@ Fixes #${options.issueNumber}`;
    */
   async generateClaudeCommitMessage(worktreePath, issueNumber) {
     const startTime = Date.now();
-    logger.info("Starting Claude commit message generation...", {
+    getLogger().info("Starting Claude commit message generation...", {
       worktreePath: worktreePath.split("/").pop(),
       // Just show the folder name for privacy
       issueNumber
     });
-    logger.debug("Checking Claude CLI availability...");
+    getLogger().debug("Checking Claude CLI availability...");
     const isClaudeAvailable = await detectClaudeCli();
     if (!isClaudeAvailable) {
-      logger.info("Claude CLI not available, skipping Claude commit message generation");
+      getLogger().info("Claude CLI not available, skipping Claude commit message generation");
       return null;
     }
-    logger.debug("Claude CLI is available");
-    logger.debug("Building commit message prompt...");
+    getLogger().debug("Claude CLI is available");
+    getLogger().debug("Building commit message prompt...");
     const prompt = this.buildCommitMessagePrompt(issueNumber);
-    logger.debug("Prompt built", { promptLength: prompt.length });
-    logger.debug("Claude prompt content:", {
+    getLogger().debug("Prompt built", { promptLength: prompt.length });
+    getLogger().debug("Claude prompt content:", {
       prompt,
       truncatedPreview: prompt.substring(0, 500) + (prompt.length > 500 ? "...[truncated]" : "")
     });
     try {
-      logger.info("Calling Claude CLI for commit message generation...");
+      getLogger().info("Calling Claude CLI for commit message generation...");
       const claudeStartTime = Date.now();
       const claudeOptions = {
         headless: true,
         addDir: worktreePath,
         model: "claude-haiku-4-5-20251001",
         // Fast, cost-effective model
-        timeout: 12e4
+        timeout: 12e4,
         // 120 second timeout
+        appendSystemPrompt: "Output only the requested content. Never include preamble, analysis, or meta-commentary. Your response is used verbatim."
       };
-      logger.debug("Claude CLI call parameters:", {
+      getLogger().debug("Claude CLI call parameters:", {
         options: claudeOptions,
         worktreePathForAnalysis: worktreePath,
         addDirContents: "Will include entire worktree directory for analysis"
       });
       const result = await launchClaude(prompt, claudeOptions);
       const claudeDuration = Date.now() - claudeStartTime;
-      logger.debug("Claude API call completed", { duration: `${claudeDuration}ms` });
+      getLogger().debug("Claude API call completed", { duration: `${claudeDuration}ms` });
       if (typeof result !== "string") {
-        logger.warn("Claude returned non-string result", { resultType: typeof result });
+        getLogger().warn("Claude returned non-string result", { resultType: typeof result });
         return null;
       }
-      logger.debug("Raw Claude output received", {
+      getLogger().debug("Raw Claude output received", {
         outputLength: result.length,
         preview: result.substring(0, 200) + (result.length > 200 ? "..." : "")
       });
-      logger.debug("Sanitizing Claude output...");
+      getLogger().debug("Sanitizing Claude output...");
       const sanitized = this.sanitizeClaudeOutput(result);
-      logger.debug("Output sanitized", {
+      getLogger().debug("Output sanitized", {
         originalLength: result.length,
         sanitizedLength: sanitized.length,
         sanitized: sanitized.substring(0, 200) + (sanitized.length > 200 ? "..." : "")
       });
       if (!sanitized) {
-        logger.warn("Claude returned empty message after sanitization");
+        getLogger().warn("Claude returned empty message after sanitization");
         return null;
       }
       let finalMessage = sanitized;
@@ -1285,13 +1469,13 @@ Fixes #${options.issueNumber}`;
           finalMessage = `${finalMessage}
 
 Fixes #${issueNumber}`;
-          logger.debug(`Added "Fixes #${issueNumber}" trailer to commit message`);
+          getLogger().debug(`Added "Fixes #${issueNumber}" trailer to commit message`);
         } else {
-          logger.debug(`"Fixes #${issueNumber}" already present in commit message`);
+          getLogger().debug(`"Fixes #${issueNumber}" already present in commit message`);
         }
       }
       const totalDuration = Date.now() - startTime;
-      logger.info("Claude commit message generated successfully", {
+      getLogger().info("Claude commit message generated successfully", {
         message: finalMessage,
         totalDuration: `${totalDuration}ms`,
         claudeApiDuration: `${claudeDuration}ms`
@@ -1301,12 +1485,12 @@ Fixes #${issueNumber}`;
       const totalDuration = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       if (errorMessage.includes("timed out") || errorMessage.includes("timeout")) {
-        logger.warn("Claude commit message generation timed out after 45 seconds", {
+        getLogger().warn("Claude commit message generation timed out after 45 seconds", {
           totalDuration: `${totalDuration}ms`,
           worktreePath: worktreePath.split("/").pop()
         });
       } else {
-        logger.warn("Failed to generate commit message with Claude", {
+        getLogger().warn("Failed to generate commit message with Claude", {
           error: errorMessage,
           totalDuration: `${totalDuration}ms`,
           worktreePath: worktreePath.split("/").pop()
@@ -1418,7 +1602,7 @@ var BuildRunner = class {
       const pkgJson = await readPackageJson(buildPath);
       const hasBuildScript = hasScript(pkgJson, "build");
       if (!hasBuildScript) {
-        logger.debug("Skipping build - no build script found");
+        getLogger().debug("Skipping build - no build script found");
         return {
           success: true,
           skipped: true,
@@ -1428,7 +1612,7 @@ var BuildRunner = class {
       }
     } catch (error) {
       if (error instanceof Error && error.message.includes("package.json not found")) {
-        logger.debug("Skipping build - no package.json found (non-Node.js project)");
+        getLogger().debug("Skipping build - no package.json found (non-Node.js project)");
         return {
           success: true,
           skipped: true,
@@ -1441,7 +1625,7 @@ var BuildRunner = class {
     const capabilities = await this.capabilityDetector.detectCapabilities(buildPath);
     const isCLIProject = capabilities.capabilities.includes("cli");
     if (!isCLIProject) {
-      logger.debug("Skipping build - not a CLI project (no bin field)");
+      getLogger().debug("Skipping build - not a CLI project (no bin field)");
       return {
         success: true,
         skipped: true,
@@ -1452,17 +1636,17 @@ var BuildRunner = class {
     const packageManager = await detectPackageManager(buildPath);
     if (options.dryRun) {
       const command = packageManager === "npm" ? "npm run build" : `${packageManager} build`;
-      logger.info(`[DRY RUN] Would run: ${command}`);
+      getLogger().info(`[DRY RUN] Would run: ${command}`);
       return {
         success: true,
         skipped: false,
         duration: Date.now() - startTime
       };
     }
-    logger.info("Running build...");
+    getLogger().info("Running build...");
     try {
       await runScript("build", buildPath, [], { quiet: true });
-      logger.success("Build completed successfully");
+      getLogger().success("Build completed successfully");
       return {
         success: true,
         skipped: false,
@@ -1502,7 +1686,7 @@ var PRManager = class {
       }
       return null;
     } catch (error) {
-      logger.debug("Error checking for existing PR", { error });
+      getLogger().debug("Error checking for existing PR", { error });
       return null;
     }
   }
@@ -1529,7 +1713,7 @@ var PRManager = class {
           }
         }
       } catch (error) {
-        logger.debug("Claude PR body generation failed, using template", { error });
+        getLogger().debug("Claude PR body generation failed, using template", { error });
       }
     }
     let body = "This PR contains changes from the iloom workflow.\n\n";
@@ -1647,7 +1831,7 @@ Start your response immediately with the PR body text.
         const originRemote = remotes.find((r) => r.name === "origin");
         if (originRemote) {
           headValue = `${originRemote.owner}:${branchName}`;
-          logger.debug(`Fork workflow detected, using head: ${headValue}`);
+          getLogger().debug(`Fork workflow detected, using head: ${headValue}`);
         }
       }
       const args = ["pr", "create", "--head", headValue, "--title", title, "--body", body, "--base", baseBranch];
@@ -1686,9 +1870,9 @@ Then retry: il finish`
   async openPRInBrowser(url) {
     try {
       await openBrowser(url);
-      logger.debug("Opened PR in browser", { url });
+      getLogger().debug("Opened PR in browser", { url });
     } catch (error) {
-      logger.warn("Failed to open PR in browser", { error });
+      getLogger().warn("Failed to open PR in browser", { error });
     }
   }
   /**
@@ -1704,7 +1888,7 @@ Then retry: il finish`
   async createOrOpenPR(branchName, title, issueNumber, baseBranch, worktreePath, openInBrowser) {
     const existingPR = await this.checkForExistingPR(branchName, worktreePath);
     if (existingPR) {
-      logger.info(`Pull request already exists: ${existingPR.url}`);
+      getLogger().info(`Pull request already exists: ${existingPR.url}`);
       if (openInBrowser) {
         await this.openPRInBrowser(existingPR.url);
       }
@@ -1715,7 +1899,7 @@ Then retry: il finish`
       };
     }
     const body = await this.generatePRBody(issueNumber, worktreePath);
-    logger.info("Creating pull request...");
+    getLogger().info("Creating pull request...");
     const url = await this.createPR(branchName, title, body, baseBranch, worktreePath);
     const prNumber = this.extractPRNumberFromUrl(url);
     if (openInBrowser) {
@@ -1747,10 +1931,10 @@ var FinishCommand = class {
   constructor(issueTracker, gitWorktreeManager, validationRunner, commitManager, mergeManager, identifierParser, resourceCleanup, buildRunner, settingsManager, loomManager) {
     const envResult = loadEnvIntoProcess();
     if (envResult.error) {
-      logger.debug(`Environment loading warning: ${envResult.error.message}`);
+      getLogger().debug(`Environment loading warning: ${envResult.error.message}`);
     }
     if (envResult.parsed) {
-      logger.debug(`Loaded ${Object.keys(envResult.parsed).length} environment variables`);
+      getLogger().debug(`Loaded ${Object.keys(envResult.parsed).length} environment variables`);
     }
     this.issueTracker = issueTracker;
     this.gitWorktreeManager = gitWorktreeManager ?? new GitWorktreeManager();
@@ -1781,7 +1965,7 @@ var FinishCommand = class {
     const neonProvider = createNeonProviderFromSettings(settings);
     const databaseManager = new DatabaseManager(neonProvider, environmentManager, databaseUrlEnvVarName);
     const cliIsolationManager = new CLIIsolationManager();
-    const { DefaultBranchNamingService: DefaultBranchNamingService2 } = await import("./BranchNamingService-A77VI6AI.js");
+    const { DefaultBranchNamingService: DefaultBranchNamingService2 } = await import("./BranchNamingService-GCCWB3LK.js");
     this.loomManager ??= new LoomManager(
       this.gitWorktreeManager,
       this.issueTracker,
@@ -1826,12 +2010,12 @@ var FinishCommand = class {
       targetBranch = worktree == null ? void 0 : worktree.branch;
     }
     if (!targetBranch) {
-      logger.debug(`Cannot determine target branch for child loom check`);
+      getLogger().debug(`Cannot determine target branch for child loom check`);
       return;
     }
     const hasChildLooms = await this.loomManager.checkAndWarnChildLooms(targetBranch);
     if (hasChildLooms) {
-      logger.error("Cannot finish loom while child looms exist. Please finish child looms first.");
+      getLogger().error("Cannot finish loom while child looms exist. Please 'finish' or 'cleanup' child looms first.");
       process.exit(1);
     }
   }
@@ -1839,42 +2023,53 @@ var FinishCommand = class {
    * Main entry point for finish command
    */
   async execute(input) {
-    var _a;
-    try {
-      const settings = await this.settingsManager.loadSettings();
-      let repo;
-      const needsRepo = ((_a = settings.mergeBehavior) == null ? void 0 : _a.mode) === "github-pr" || this.issueTracker.providerName === "github";
-      if (needsRepo && await hasMultipleRemotes()) {
-        repo = await getConfiguredRepoFromSettings(settings);
-        logger.info(`Using GitHub repository: ${repo}`);
-      }
-      const parsed = await this.parseInput(input.identifier, input.options);
-      await this.checkForChildLooms(parsed);
-      const worktrees = await this.validateInput(parsed, input.options, repo);
-      logger.info(`Validated input: ${this.formatParsedInput(parsed)}`);
-      const worktree = worktrees[0];
-      if (!worktree) {
-        throw new Error("No worktree found");
-      }
-      if (parsed.type === "pr") {
-        if (!parsed.number) {
-          throw new Error("Invalid PR number");
-        }
-        if (!this.issueTracker.supportsPullRequests || !this.issueTracker.fetchPR) {
-          throw new Error("Issue tracker does not support pull requests");
-        }
-        const pr = await this.issueTracker.fetchPR(parsed.number, repo);
-        await this.executePRWorkflow(parsed, input.options, worktree, pr);
-      } else {
-        await this.executeIssueWorkflow(parsed, input.options, worktree);
+    var _a, _b;
+    const isJsonMode = input.options.json === true;
+    const result = {
+      success: false,
+      type: "issue",
+      identifier: "",
+      dryRun: input.options.dryRun ?? false,
+      operations: []
+    };
+    if (isJsonMode) {
+      const settings2 = await this.settingsManager.loadSettings();
+      if (((_a = settings2.mergeBehavior) == null ? void 0 : _a.mode) === "github-pr" && input.options.cleanup === void 0) {
+        throw new Error("JSON mode with github-pr workflow requires --cleanup or --no-cleanup flag. Use: il finish --json --cleanup <identifier>");
       }
-    } catch (error) {
-      if (error instanceof Error) {
-        logger.error(`${error.message}`);
-      } else {
-        logger.error("An unknown error occurred");
+    }
+    const settings = await this.settingsManager.loadSettings();
+    let repo;
+    const needsRepo = ((_b = settings.mergeBehavior) == null ? void 0 : _b.mode) === "github-pr" || this.issueTracker.providerName === "github";
+    if (needsRepo && await hasMultipleRemotes()) {
+      repo = await getConfiguredRepoFromSettings(settings);
+      getLogger().info(`Using GitHub repository: ${repo}`);
+    }
+    const parsed = await this.parseInput(input.identifier, input.options);
+    result.type = parsed.type;
+    result.identifier = parsed.number ?? parsed.branchName ?? "";
+    await this.checkForChildLooms(parsed);
+    const worktrees = await this.validateInput(parsed, input.options, repo);
+    getLogger().info(`Validated input: ${this.formatParsedInput(parsed)}`);
+    const worktree = worktrees[0];
+    if (!worktree) {
+      throw new Error("No worktree found");
+    }
+    if (parsed.type === "pr") {
+      if (!parsed.number) {
+        throw new Error("Invalid PR number");
       }
-      throw error;
+      if (!this.issueTracker.supportsPullRequests || !this.issueTracker.fetchPR) {
+        throw new Error("Issue tracker does not support pull requests");
+      }
+      const pr = await this.issueTracker.fetchPR(parsed.number, repo);
+      await this.executePRWorkflow(parsed, input.options, worktree, pr, result);
+    } else {
+      await this.executeIssueWorkflow(parsed, input.options, worktree, result);
+    }
+    result.success = true;
+    if (isJsonMode) {
+      return result;
     }
   }
   /**
@@ -1937,7 +2132,7 @@ var FinishCommand = class {
     const prMatch = currentDir.match(prPattern);
     if (prMatch == null ? void 0 : prMatch[1]) {
       const prNumber = parseInt(prMatch[1], 10);
-      logger.debug(`Auto-detected PR #${prNumber} from directory: ${currentDir}`);
+      getLogger().debug(`Auto-detected PR #${prNumber} from directory: ${currentDir}`);
       return {
         type: "pr",
         number: prNumber,
@@ -1947,7 +2142,7 @@ var FinishCommand = class {
     }
     const issueNumber = extractIssueNumber(currentDir);
     if (issueNumber !== null) {
-      logger.debug(
+      getLogger().debug(
         `Auto-detected issue #${issueNumber} from directory: ${currentDir}`
       );
       return {
@@ -1966,7 +2161,7 @@ var FinishCommand = class {
     }
     const branchIssueNumber = extractIssueNumber(currentBranch);
     if (branchIssueNumber !== null) {
-      logger.debug(
+      getLogger().debug(
         `Auto-detected issue #${branchIssueNumber} from branch: ${currentBranch}`
       );
       return {
@@ -1996,7 +2191,7 @@ var FinishCommand = class {
           throw new Error("Issue tracker does not support pull requests");
         }
         const pr = await this.issueTracker.fetchPR(parsed.number);
-        logger.debug(`Validated PR #${parsed.number} (state: ${pr.state})`);
+        getLogger().debug(`Validated PR #${parsed.number} (state: ${pr.state})`);
         return await this.findWorktreeForIdentifier(parsed);
       }
       case "issue": {
@@ -2009,7 +2204,7 @@ var FinishCommand = class {
             `Issue #${parsed.number} is closed. Use --force to finish anyway.`
           );
         }
-        logger.debug(`Validated issue #${parsed.number} (state: ${issue.state})`);
+        getLogger().debug(`Validated issue #${parsed.number} (state: ${issue.state})`);
         return await this.findWorktreeForIdentifier(parsed);
       }
       case "branch": {
@@ -2021,7 +2216,7 @@ var FinishCommand = class {
             "Invalid branch name. Use only letters, numbers, hyphens, underscores, and slashes"
           );
         }
-        logger.debug(`Validated branch name: ${parsed.branchName}`);
+        getLogger().debug(`Validated branch name: ${parsed.branchName}`);
         return await this.findWorktreeForIdentifier(parsed);
       }
       default: {
@@ -2080,7 +2275,7 @@ var FinishCommand = class {
         `No worktree found for ${this.formatParsedInput(parsed)}. Use 'il list' to see available worktrees.`
       );
     }
-    logger.debug(`Found worktree: ${worktree.path}`);
+    getLogger().debug(`Found worktree: ${worktree.path}`);
     return [worktree];
   }
   /**
@@ -2109,23 +2304,38 @@ var FinishCommand = class {
    * Execute workflow for issues and branches (merge into main)
    * This is the traditional workflow: validate → commit → rebase → merge → cleanup
    */
-  async executeIssueWorkflow(parsed, options, worktree) {
+  async executeIssueWorkflow(parsed, options, worktree, result) {
     var _a, _b;
     if (!options.dryRun) {
-      logger.info("Running pre-merge validations...");
+      getLogger().info("Running pre-merge validations...");
       await this.validationRunner.runValidations(worktree.path, {
         dryRun: options.dryRun ?? false
       });
-      logger.success("All validations passed");
+      getLogger().success("All validations passed");
+      result.operations.push({
+        type: "validation",
+        message: "Pre-merge validations passed",
+        success: true
+      });
     } else {
-      logger.info("[DRY RUN] Would run pre-merge validations");
+      getLogger().info("[DRY RUN] Would run pre-merge validations");
+      result.operations.push({
+        type: "validation",
+        message: "Would run pre-merge validations (dry-run)",
+        success: true
+      });
     }
     const gitStatus = await this.commitManager.detectUncommittedChanges(worktree.path);
     if (gitStatus.hasUncommittedChanges) {
       if (options.dryRun) {
-        logger.info("[DRY RUN] Would auto-commit uncommitted changes (validation passed)");
+        getLogger().info("[DRY RUN] Would auto-commit uncommitted changes (validation passed)");
+        result.operations.push({
+          type: "commit",
+          message: "Would auto-commit uncommitted changes (dry-run)",
+          success: true
+        });
       } else {
-        logger.info("Validation passed, auto-committing uncommitted changes...");
+        getLogger().info("Validation passed, auto-committing uncommitted changes...");
         const settings2 = await this.settingsManager.loadSettings(worktree.path);
         const skipVerify = ((_b = (_a = settings2.workflows) == null ? void 0 : _a.issue) == null ? void 0 : _b.noVerify) ?? false;
         const commitOptions = {
@@ -2137,17 +2347,27 @@ var FinishCommand = class {
         }
         try {
           await this.commitManager.commitChanges(worktree.path, commitOptions);
-          logger.success("Changes committed successfully");
+          getLogger().success("Changes committed successfully");
+          result.operations.push({
+            type: "commit",
+            message: "Changes committed successfully",
+            success: true
+          });
         } catch (error) {
           if (error instanceof UserAbortedCommitError) {
-            logger.info("Commit aborted by user");
+            getLogger().info("Commit aborted by user");
+            result.operations.push({
+              type: "commit",
+              message: "Commit aborted by user",
+              success: false
+            });
             return;
           }
           throw error;
         }
       }
     } else {
-      logger.debug("No uncommitted changes found");
+      getLogger().debug("No uncommitted changes found");
     }
     const settings = await this.settingsManager.loadSettings(worktree.path);
     const mergeBehavior = settings.mergeBehavior ?? { mode: "local" };
@@ -2157,32 +2377,43 @@ var FinishCommand = class {
           `The 'github-pr' merge mode requires a GitHub-compatible issue tracker. Your current provider (${this.issueTracker.providerName}) does not support pull requests. Either change mergeBehavior.mode to 'local' in your settings, or use GitHub as your issue tracker.`
         );
       }
-      await this.executeGitHubPRWorkflow(parsed, options, worktree, settings);
+      await this.executeGitHubPRWorkflow(parsed, options, worktree, settings, result);
       return;
     }
-    logger.info("Rebasing branch on main...");
+    getLogger().info("Rebasing branch on main...");
     const mergeOptions = {
       dryRun: options.dryRun ?? false,
       force: options.force ?? false
     };
     await this.mergeManager.rebaseOnMain(worktree.path, mergeOptions);
-    logger.success("Branch rebased successfully");
-    logger.info("Performing fast-forward merge...");
+    getLogger().success("Branch rebased successfully");
+    result.operations.push({
+      type: "rebase",
+      message: "Branch rebased on main",
+      success: true
+    });
+    getLogger().info("Performing fast-forward merge...");
     await this.mergeManager.performFastForwardMerge(worktree.branch, worktree.path, mergeOptions);
-    logger.success("Fast-forward merge completed successfully");
+    getLogger().success("Fast-forward merge completed successfully");
+    result.operations.push({
+      type: "merge",
+      message: "Fast-forward merge completed",
+      success: true
+    });
     if (options.dryRun) {
-      logger.info("[DRY RUN] Would install dependencies in main worktree");
+      getLogger().info("[DRY RUN] Would install dependencies in main worktree");
     } else {
-      logger.info("Installing dependencies in main worktree...");
+      getLogger().info("Installing dependencies in main worktree...");
       const mainWorktreePath = await findMainWorktreePathWithSettings(worktree.path, this.settingsManager);
       await installDependencies(mainWorktreePath, true, true);
     }
     if (!options.skipBuild) {
-      await this.runPostMergeBuild(worktree.path, options);
+      await this.runPostMergeBuild(worktree.path, options, result);
     } else {
-      logger.debug("Skipping build verification (--skip-build flag provided)");
+      getLogger().debug("Skipping build verification (--skip-build flag provided)");
     }
-    await this.performPostMergeCleanup(parsed, options, worktree);
+    await this.generateSessionSummaryIfConfigured(parsed, worktree, options);
+    await this.performPostMergeCleanup(parsed, options, worktree, result);
   }
   /**
    * Execute workflow for Pull Requests
@@ -2190,27 +2421,37 @@ var FinishCommand = class {
    * - OPEN: Commit changes, push to remote, keep worktree active
    * - CLOSED/MERGED: Skip to cleanup
    */
-  async executePRWorkflow(parsed, options, worktree, pr) {
+  async executePRWorkflow(parsed, options, worktree, pr, result) {
     var _a, _b;
     if (pr.state === "closed" || pr.state === "merged") {
-      logger.info(`PR #${parsed.number} is ${pr.state.toUpperCase()} - skipping to cleanup`);
+      getLogger().info(`PR #${parsed.number} is ${pr.state.toUpperCase()} - skipping to cleanup`);
       const gitStatus = await this.commitManager.detectUncommittedChanges(worktree.path);
       if (gitStatus.hasUncommittedChanges && !options.force) {
-        logger.warn("PR has uncommitted changes");
+        getLogger().warn("PR has uncommitted changes");
         throw new Error(
           "Cannot cleanup PR with uncommitted changes. Commit or stash changes, then run again with --force to cleanup anyway."
         );
       }
-      await this.performPRCleanup(parsed, options, worktree);
-      logger.success(`PR #${parsed.number} cleanup completed`);
+      await this.performPRCleanup(parsed, options, worktree, pr.state, result);
+      getLogger().success(`PR #${parsed.number} cleanup completed`);
+      result.operations.push({
+        type: "cleanup",
+        message: `PR #${parsed.number} cleanup completed`,
+        success: true
+      });
     } else {
-      logger.info(`PR #${parsed.number} is OPEN - will push changes and keep worktree active`);
+      getLogger().info(`PR #${parsed.number} is OPEN - will push changes and keep worktree active`);
       const gitStatus = await this.commitManager.detectUncommittedChanges(worktree.path);
       if (gitStatus.hasUncommittedChanges) {
         if (options.dryRun) {
-          logger.info("[DRY RUN] Would commit uncommitted changes");
+          getLogger().info("[DRY RUN] Would commit uncommitted changes");
+          result.operations.push({
+            type: "commit",
+            message: "Would commit uncommitted changes (dry-run)",
+            success: true
+          });
         } else {
-          logger.info("Committing uncommitted changes...");
+          getLogger().info("Committing uncommitted changes...");
           const settings = await this.settingsManager.loadSettings(worktree.path);
           const skipVerify = ((_b = (_a = settings.workflows) == null ? void 0 : _a.pr) == null ? void 0 : _b.noVerify) ?? false;
           try {
@@ -2219,43 +2460,54 @@ var FinishCommand = class {
               skipVerify
               // Do NOT pass issueNumber for PRs - no "Fixes #" trailer needed
             });
-            logger.success("Changes committed");
+            getLogger().success("Changes committed");
+            result.operations.push({
+              type: "commit",
+              message: "Changes committed successfully",
+              success: true
+            });
           } catch (error) {
             if (error instanceof UserAbortedCommitError) {
-              logger.info("Commit aborted by user");
+              getLogger().info("Commit aborted by user");
+              result.operations.push({
+                type: "commit",
+                message: "Commit aborted by user",
+                success: false
+              });
               return;
             }
             throw error;
           }
         }
       } else {
-        logger.debug("No uncommitted changes found");
+        getLogger().debug("No uncommitted changes found");
       }
       if (options.dryRun) {
-        logger.info(`[DRY RUN] Would push changes to origin/${pr.branch}`);
+        getLogger().info(`[DRY RUN] Would push changes to origin/${pr.branch}`);
       } else {
-        logger.info("Pushing changes to remote...");
+        getLogger().info("Pushing changes to remote...");
         await pushBranchToRemote(pr.branch, worktree.path, {
           dryRun: false
         });
-        logger.success(`Changes pushed to PR #${parsed.number}`);
+        getLogger().success(`Changes pushed to PR #${parsed.number}`);
       }
-      logger.success(`PR #${parsed.number} updated successfully`);
-      logger.info("Worktree remains active for continued work");
-      logger.info(`To cleanup when done: il cleanup ${parsed.number}`);
+      getLogger().success(`PR #${parsed.number} updated successfully`);
+      getLogger().info("Worktree remains active for continued work");
+      getLogger().info(`To cleanup when done: il cleanup ${parsed.number}`);
+      result.prUrl = pr.url;
     }
   }
   /**
    * Execute workflow for GitHub PR creation (github-pr merge mode)
    * Validates → Commits → Pushes → Creates PR → Prompts for cleanup
    */
-  async executeGitHubPRWorkflow(parsed, options, worktree, settings) {
+  async executeGitHubPRWorkflow(parsed, options, worktree, settings, finishResult) {
     if (options.dryRun) {
-      logger.info("[DRY RUN] Would push branch to origin");
+      getLogger().info("[DRY RUN] Would push branch to origin");
     } else {
-      logger.info("Pushing branch to origin...");
+      getLogger().info("Pushing branch to origin...");
       await pushBranchToRemote(worktree.branch, worktree.path, { dryRun: false });
-      logger.success("Branch pushed successfully");
+      getLogger().success("Branch pushed successfully");
     }
     const prManager = new PRManager(settings);
     let prTitle = `Work from ${worktree.branch}`;
@@ -2264,17 +2516,22 @@ var FinishCommand = class {
         const issue = await this.issueTracker.fetchIssue(parsed.number);
         prTitle = issue.title;
       } catch (error) {
-        logger.debug("Could not fetch issue title, using branch name", { error });
+        getLogger().debug("Could not fetch issue title, using branch name", { error });
       }
     }
+    const baseBranch = await getMergeTargetBranch(worktree.path);
     if (options.dryRun) {
-      logger.info("[DRY RUN] Would create GitHub PR");
-      logger.info(`  Title: ${prTitle}`);
-      logger.info(`  Base: ${settings.mainBranch ?? "main"}`);
+      getLogger().info("[DRY RUN] Would create GitHub PR");
+      getLogger().info(`  Title: ${prTitle}`);
+      getLogger().info(`  Base: ${baseBranch}`);
+      finishResult.operations.push({
+        type: "pr-creation",
+        message: "Would create GitHub PR (dry-run)",
+        success: true
+      });
     } else {
-      const baseBranch = settings.mainBranch ?? "main";
       const openInBrowser = options.noBrowser !== true;
-      const result = await prManager.createOrOpenPR(
+      const prResult = await prManager.createOrOpenPR(
         worktree.branch,
         prTitle,
         parsed.type === "issue" ? parsed.number : void 0,
@@ -2282,40 +2539,52 @@ var FinishCommand = class {
         worktree.path,
         openInBrowser
       );
-      if (result.wasExisting) {
-        logger.success(`Existing pull request: ${result.url}`);
+      if (prResult.wasExisting) {
+        getLogger().success(`Existing pull request: ${prResult.url}`);
+        finishResult.operations.push({
+          type: "pr-creation",
+          message: `Found existing pull request`,
+          success: true
+        });
       } else {
-        logger.success(`Pull request created: ${result.url}`);
+        getLogger().success(`Pull request created: ${prResult.url}`);
+        finishResult.operations.push({
+          type: "pr-creation",
+          message: `Pull request created`,
+          success: true
+        });
       }
-      await this.handlePRCleanupPrompt(parsed, options, worktree);
+      finishResult.prUrl = prResult.url;
+      await this.generateSessionSummaryIfConfigured(parsed, worktree, options);
+      await this.handlePRCleanupPrompt(parsed, options, worktree, finishResult);
     }
   }
   /**
    * Handle cleanup prompt after PR creation
    * Respects --cleanup and --no-cleanup flags, otherwise prompts user
    */
-  async handlePRCleanupPrompt(parsed, options, worktree) {
+  async handlePRCleanupPrompt(parsed, options, worktree, finishResult) {
     if (options.cleanup === true) {
-      logger.info("Cleaning up worktree (--cleanup flag)...");
-      await this.performWorktreeCleanup(parsed, options, worktree);
+      getLogger().info("Cleaning up worktree (--cleanup flag)...");
+      await this.performWorktreeCleanup(parsed, options, worktree, finishResult);
     } else if (options.cleanup === false) {
-      logger.info("Worktree kept active for continued work (--no-cleanup flag)");
-      logger.info(`To cleanup later: il cleanup ${parsed.originalInput}`);
+      getLogger().info("Worktree kept active for continued work (--no-cleanup flag)");
+      getLogger().info(`To cleanup later: il cleanup ${parsed.originalInput}`);
     } else {
-      logger.info("");
-      logger.info("PR created successfully. Would you like to clean up the worktree?");
-      logger.info(`  Worktree: ${worktree.path}`);
-      logger.info(`  Branch: ${worktree.branch}`);
-      logger.info("");
+      getLogger().info("");
+      getLogger().info("PR created successfully. Would you like to clean up the worktree?");
+      getLogger().info(`  Worktree: ${worktree.path}`);
+      getLogger().info(`  Branch: ${worktree.branch}`);
+      getLogger().info("");
       const shouldCleanup = await promptConfirmation(
         "Clean up worktree now?",
         false
         // Default to keeping worktree (safer option)
       );
       if (shouldCleanup) {
-        await this.performWorktreeCleanup(parsed, options, worktree);
+        await this.performWorktreeCleanup(parsed, options, worktree, finishResult);
       } else {
-        logger.info("Worktree kept active. Run `il cleanup` when ready.");
+        getLogger().info("Worktree kept active. Run `il cleanup` when ready.");
       }
     }
   }
@@ -2323,7 +2592,7 @@ var FinishCommand = class {
    * Perform worktree cleanup (used by GitHub PR workflow)
    * Similar to performPostMergeCleanup but for PR workflow
    */
-  async performWorktreeCleanup(parsed, options, worktree) {
+  async performWorktreeCleanup(parsed, options, worktree, finishResult) {
     const cleanupInput = {
       type: parsed.type,
       originalInput: parsed.originalInput,
@@ -2339,56 +2608,98 @@ var FinishCommand = class {
       force: options.force ?? false
     };
     try {
-      logger.info("Starting worktree cleanup...");
+      getLogger().info("Starting worktree cleanup...");
       await this.ensureResourceCleanup();
       if (!this.resourceCleanup) {
         throw new Error("Failed to initialize ResourceCleanup");
       }
-      const result = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
-      this.reportCleanupResults(result);
-      if (!result.success) {
-        logger.warn("Some cleanup operations failed - manual cleanup may be required");
+      const cleanupResult = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
+      this.reportCleanupResults(cleanupResult);
+      finishResult.cleanupResult = cleanupResult;
+      if (!cleanupResult.success) {
+        getLogger().warn("Some cleanup operations failed - manual cleanup may be required");
         this.showManualCleanupInstructions(worktree);
+        finishResult.operations.push({
+          type: "cleanup",
+          message: "Worktree cleanup partially failed",
+          success: false
+        });
       } else {
-        logger.success("Worktree cleanup completed successfully");
+        getLogger().success("Worktree cleanup completed successfully");
+        finishResult.operations.push({
+          type: "cleanup",
+          message: "Worktree cleanup completed",
+          success: true
+        });
       }
       if (this.isRunningFromWithinWorktree(worktree.path)) {
         this.showTerminalCloseWarning(worktree);
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger.warn(`Cleanup failed: ${errorMessage}`);
-      logger.warn("Manual cleanup may be required");
+      getLogger().warn(`Cleanup failed: ${errorMessage}`);
+      getLogger().warn("Manual cleanup may be required");
       this.showManualCleanupInstructions(worktree);
+      finishResult.operations.push({
+        type: "cleanup",
+        message: "Worktree cleanup failed",
+        success: false,
+        error: errorMessage
+      });
     }
   }
   /**
    * Perform cleanup for closed/merged PRs
    * Similar to performPostMergeCleanup but with different messaging
+   *
+   * Safety check behavior differs based on PR state:
+   * - MERGED: Skip safety checks - work is safely in main branch
+   * - CLOSED (not merged): Enable safety checks - PR was rejected/abandoned,
+   *   local commits may not exist anywhere else
+   *
+   * @param parsed - Parsed input identifying the PR
+   * @param options - Finish options
+   * @param worktree - The worktree to clean up
+   * @param prState - The PR state ('closed' or 'merged')
+   * @param finishResult - Result object to populate
    */
-  async performPRCleanup(parsed, options, worktree) {
+  async performPRCleanup(parsed, options, worktree, prState, finishResult) {
     const cleanupInput = {
       type: parsed.type,
       originalInput: parsed.originalInput,
       ...parsed.number !== void 0 && { number: parsed.number },
       ...parsed.branchName !== void 0 && { branchName: parsed.branchName }
     };
+    const isMerged = prState === "merged";
     const cleanupOptions = {
       dryRun: options.dryRun ?? false,
       deleteBranch: true,
       // Delete branch for closed/merged PRs
       keepDatabase: false,
-      force: options.force ?? false
+      force: options.force ?? false,
+      // For merged PRs: skip merge check (work is in main)
+      // For closed PRs: enable merge check (may have unpushed local commits)
+      checkMergeSafety: !isMerged,
+      // Skip remote branch check for MERGED PRs because:
+      // 1. The PR is merged - the work is safely in main
+      // 2. GitHub may have auto-deleted the branch after merge
+      // 3. The user may have manually deleted the remote branch post-merge
+      //
+      // For CLOSED PRs, we rely on checkMergeSafety to verify no unpushed commits
+      // rather than checkRemoteBranch, since the remote branch may still exist
+      // but local may have additional commits
+      checkRemoteBranch: false
     };
     try {
       await this.ensureResourceCleanup();
       if (!this.resourceCleanup) {
         throw new Error("Failed to initialize ResourceCleanup");
       }
-      const result = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
-      this.reportCleanupResults(result);
-      if (!result.success) {
-        logger.warn("Some cleanup operations failed - manual cleanup may be required");
+      const cleanupResult = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
+      this.reportCleanupResults(cleanupResult);
+      finishResult.cleanupResult = cleanupResult;
+      if (!cleanupResult.success) {
+        getLogger().warn("Some cleanup operations failed - manual cleanup may be required");
         this.showManualCleanupInstructions(worktree);
       } else {
         if (this.isRunningFromWithinWorktree(worktree.path)) {
@@ -2397,29 +2708,86 @@ var FinishCommand = class {
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger.warn(`Cleanup failed: ${errorMessage}`);
+      getLogger().warn(`Cleanup failed: ${errorMessage}`);
       this.showManualCleanupInstructions(worktree);
       throw error;
     }
   }
+  /**
+   * Generate and post session summary if configured
+   *
+   * Non-blocking: Catches all errors and logs warnings instead of throwing
+   * This ensures the finish workflow continues even if summary generation fails
+   *
+   * In dry-run mode: generates summary and shows preview, but doesn't post
+   */
+  async generateSessionSummaryIfConfigured(parsed, worktree, options) {
+    if (parsed.type === "branch") {
+      return;
+    }
+    this.sessionSummaryService ??= new SessionSummaryService(
+      void 0,
+      // Use default PromptTemplateManager
+      void 0,
+      // Use default MetadataManager
+      this.settingsManager
+    );
+    if (options.dryRun) {
+      try {
+        const result = await this.sessionSummaryService.generateSummary(
+          worktree.path,
+          worktree.branch,
+          parsed.type,
+          parsed.number
+        );
+        const preview = result.summary.slice(0, 100).replace(/\n/g, " ");
+        getLogger().info(`[DRY RUN] Would post session summary: "${preview}..."`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        getLogger().warn(`[DRY RUN] Session summary generation failed: ${errorMessage}`);
+      }
+      return;
+    }
+    await this.sessionSummaryService.generateAndPostSummary({
+      worktreePath: worktree.path,
+      issueNumber: parsed.number ?? 0,
+      branchName: worktree.branch,
+      loomType: parsed.type
+    });
+  }
   /**
    * Run post-merge build verification for CLI projects
    * Runs in main worktree to verify merged code builds successfully
    */
-  async runPostMergeBuild(worktreePath, options) {
+  async runPostMergeBuild(worktreePath, options, finishResult) {
     const mainWorktreePath = await findMainWorktreePathWithSettings(worktreePath, this.settingsManager);
     if (options.dryRun) {
-      logger.info("[DRY RUN] Would run post-merge build");
+      getLogger().info("[DRY RUN] Would run post-merge build");
+      finishResult.operations.push({
+        type: "build",
+        message: "Would run post-merge build (dry-run)",
+        success: true
+      });
       return;
     }
-    logger.info("Running post-merge build...");
-    const result = await this.buildRunner.runBuild(mainWorktreePath, {
+    getLogger().info("Running post-merge build...");
+    const buildResult = await this.buildRunner.runBuild(mainWorktreePath, {
       dryRun: options.dryRun ?? false
     });
-    if (result.skipped) {
-      logger.debug(`Build skipped: ${result.reason}`);
+    if (buildResult.skipped) {
+      getLogger().debug(`Build skipped: ${buildResult.reason}`);
+      finishResult.operations.push({
+        type: "build",
+        message: `Build skipped: ${buildResult.reason}`,
+        success: true
+      });
     } else {
-      logger.success("Post-merge build completed successfully");
+      getLogger().success("Post-merge build completed successfully");
+      finishResult.operations.push({
+        type: "build",
+        message: "Post-merge build completed",
+        success: true
+      });
     }
   }
   /**
@@ -2427,7 +2795,7 @@ var FinishCommand = class {
    * Converts ParsedFinishInput to ParsedInput and calls ResourceCleanup
    * Handles failures gracefully without throwing
    */
-  async performPostMergeCleanup(parsed, options, worktree) {
+  async performPostMergeCleanup(parsed, options, worktree, finishResult) {
     await this.ensureResourceCleanup();
     if (!this.loomManager) {
       throw new Error("Failed to initialize LoomManager");
@@ -2448,26 +2816,43 @@ var FinishCommand = class {
       force: options.force ?? false
     };
     try {
-      logger.info("Starting post-merge cleanup...");
+      getLogger().info("Starting post-merge cleanup...");
       if (!this.resourceCleanup) {
         throw new Error("Failed to initialize ResourceCleanup");
       }
-      const result = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
-      this.reportCleanupResults(result);
-      if (!result.success) {
-        logger.warn("Some cleanup operations failed - manual cleanup may be required");
+      const cleanupResult = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
+      this.reportCleanupResults(cleanupResult);
+      finishResult.cleanupResult = cleanupResult;
+      if (!cleanupResult.success) {
+        getLogger().warn("Some cleanup operations failed - manual cleanup may be required");
         this.showManualCleanupInstructions(worktree);
+        finishResult.operations.push({
+          type: "cleanup",
+          message: "Post-merge cleanup partially failed",
+          success: false
+        });
       } else {
-        logger.success("Post-merge cleanup completed successfully");
+        getLogger().success("Post-merge cleanup completed successfully");
+        finishResult.operations.push({
+          type: "cleanup",
+          message: "Post-merge cleanup completed",
+          success: true
+        });
       }
       if (this.isRunningFromWithinWorktree(worktree.path)) {
         this.showTerminalCloseWarning(worktree);
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger.warn(`Cleanup failed: ${errorMessage}`);
-      logger.warn("Merge completed successfully, but manual cleanup is required");
+      getLogger().warn(`Cleanup failed: ${errorMessage}`);
+      getLogger().warn("Merge completed successfully, but manual cleanup is required");
       this.showManualCleanupInstructions(worktree);
+      finishResult.operations.push({
+        type: "cleanup",
+        message: "Post-merge cleanup failed",
+        success: false,
+        error: errorMessage
+      });
     }
   }
   /**
@@ -2477,14 +2862,14 @@ var FinishCommand = class {
     if (result.operations.length === 0) {
       return;
     }
-    logger.info("Cleanup operations:");
+    getLogger().info("Cleanup operations:");
     for (const op of result.operations) {
       const status = op.success ? "\u2713" : "\u2717";
       const message = op.error ? `${op.message}: ${op.error}` : op.message;
       if (op.success) {
-        logger.info(`  ${status} ${message}`);
+        getLogger().info(`  ${status} ${message}`);
       } else {
-        logger.warn(`  ${status} ${message}`);
+        getLogger().warn(`  ${status} ${message}`);
       }
     }
   }
@@ -2492,10 +2877,10 @@ var FinishCommand = class {
    * Show manual cleanup instructions when cleanup fails
    */
   showManualCleanupInstructions(worktree) {
-    logger.info("\nManual cleanup commands:");
-    logger.info(`  1. Remove worktree: git worktree remove ${worktree.path}`);
-    logger.info(`  2. Delete branch: git branch -d ${worktree.branch}`);
-    logger.info(`  3. Check dev servers: lsof -i :PORT (and kill if needed)`);
+    getLogger().info("\nManual cleanup commands:");
+    getLogger().info(`  1. Remove worktree: git worktree remove ${worktree.path}`);
+    getLogger().info(`  2. Delete branch: git branch -d ${worktree.branch}`);
+    getLogger().info(`  3. Check dev servers: lsof -i :PORT (and kill if needed)`);
   }
   /**
    * Check if current working directory is within the target worktree
@@ -2509,17 +2894,17 @@ var FinishCommand = class {
    * Display warning to close terminal/IDE when running from within finished loom
    */
   showTerminalCloseWarning(worktree) {
-    logger.info("");
-    logger.info("You are currently in the directory of the loom that was just finished.");
-    logger.info("Please close this terminal and any IDE/terminal windows using this directory.");
-    logger.info(`Directory: ${worktree.path}`);
+    getLogger().info("");
+    getLogger().info("You are currently in the directory of the loom that was just finished.");
+    getLogger().info("Please close this terminal and any IDE/terminal windows using this directory.");
+    getLogger().info(`Directory: ${worktree.path}`);
   }
 };
 
 // src/utils/package-info.ts
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
-import { dirname, join } from "path";
+import { dirname, join as join2 } from "path";
 function getPackageInfo(scriptPath) {
   try {
     let basePath;
@@ -2530,7 +2915,7 @@ function getPackageInfo(scriptPath) {
       basePath = __filename2;
     }
     const __dirname = dirname(basePath);
-    const packageJsonPath = join(__dirname, "..", "package.json");
+    const packageJsonPath = join2(__dirname, "..", "package.json");
     const packageJsonContent = readFileSync(packageJsonPath, "utf8");
     const packageJson2 = JSON.parse(packageJsonContent);
     return packageJson2;
@@ -2606,7 +2991,8 @@ function formatLoomForJson(worktree, mainWorktreePath, metadata) {
     description: (metadata == null ? void 0 : metadata.description) ?? null,
     created_at: (metadata == null ? void 0 : metadata.created_at) ?? null,
     issueTracker: (metadata == null ? void 0 : metadata.issueTracker) ?? null,
-    colorHex: (metadata == null ? void 0 : metadata.colorHex) ?? null
+    colorHex: (metadata == null ? void 0 : metadata.colorHex) ?? null,
+    projectPath: (metadata == null ? void 0 : metadata.projectPath) ?? null
   };
 }
 function formatLoomsForJson(worktrees, mainWorktreePath, metadata) {
@@ -2631,14 +3017,14 @@ program.name("iloom").description(packageJson.description).version(packageJson.v
     process.exit(0);
   }
   try {
-    const { checkAndNotifyUpdate } = await import("./update-notifier-QEX3CJHA.js");
-    const { detectInstallationMethod } = await import("./installation-detector-VARGFFRZ.js");
+    const { checkAndNotifyUpdate } = await import("./update-notifier-H55ZK7NU.js");
+    const { detectInstallationMethod } = await import("./installation-detector-6R6YOFVZ.js");
     const installMethod = detectInstallationMethod(__filename);
     await checkAndNotifyUpdate(packageJson.version, packageJson.name, installMethod);
   } catch {
   }
   try {
-    const { SettingsMigrationManager } = await import("./SettingsMigrationManager-TJ7UWZG5.js");
+    const { SettingsMigrationManager } = await import("./SettingsMigrationManager-EH3J2TCN.js");
     const migrationManager = new SettingsMigrationManager();
     await migrationManager.migrateSettingsIfNeeded();
   } catch (error) {
@@ -2728,21 +3114,21 @@ async function autoLaunchInitForMultipleRemotes() {
   logger.info("iloom will now launch an interactive configuration session with Claude");
   logger.info("to help you select which remote to use for GitHub operations.");
   logger.info("");
-  const { waitForKeypress: waitForKeypress2 } = await import("./prompt-QALMYTVC.js");
+  const { waitForKeypress: waitForKeypress2 } = await import("./prompt-A7GGRHSY.js");
   await waitForKeypress2("Press any key to start configuration...");
   logger.info("");
   try {
-    const { InitCommand: InitCommand2 } = await import("./init-4FHTAM3F.js");
+    const { InitCommand: InitCommand2 } = await import("./init-LBA6NUK2.js");
     const initCommand = new InitCommand2();
     const customInitialMessage = "Help me configure which git remote iloom should use for GitHub operations. I have multiple remotes and need to select the correct one.";
     await initCommand.execute(customInitialMessage);
     logger.info("");
     logger.info("Configuration complete! Continuing with your original command...");
     logger.info("");
-    const { SettingsManager: SettingsManager2 } = await import("./SettingsManager-I2LRCW2A.js");
+    const { SettingsManager: SettingsManager2 } = await import("./SettingsManager-FJFU6JJD.js");
     const settingsManager = new SettingsManager2();
     const settings = await settingsManager.loadSettings();
-    const { hasMultipleRemotes: hasMultipleRemotes2 } = await import("./remote-VUNCQZ6J.js");
+    const { hasMultipleRemotes: hasMultipleRemotes2 } = await import("./remote-73TZ2ADI.js");
     const multipleRemotes = await hasMultipleRemotes2();
     if (multipleRemotes && !((_b = (_a = settings.issueManagement) == null ? void 0 : _a.github) == null ? void 0 : _b.remote)) {
       logger.error("Configuration incomplete: GitHub remote is still not configured.");
@@ -2758,50 +3144,82 @@ async function autoLaunchInitForMultipleRemotes() {
 }
 var shellCompletion = new ShellCompletion();
 shellCompletion.init();
-program.command("start").alias("new").alias("create").alias("up").description("Create isolated workspace for an issue/PR").argument("[identifier]", "Issue number, PR number, or branch name (optional - will prompt if not provided)").option("--claude", "Enable Claude integration (default: true)").option("--no-claude", "Disable Claude integration").option("--code", "Enable VSCode (default: true)").option("--no-code", "Disable VSCode").option("--dev-server", "Enable dev server in terminal (default: true)").option("--no-dev-server", "Disable dev server").option("--terminal", "Enable terminal without dev server (default: false)").option("--no-terminal", "Disable terminal").option("--child-loom", "Force create as child loom (skip prompt)").option("--no-child-loom", "Force create as independent loom (skip prompt)").option("--body <text>", "Body text for issue (skips AI enhancement)").addOption(
+program.command("start").alias("new").alias("create").alias("up").description("Create isolated workspace for an issue/PR").argument("[identifier]", "Issue number, PR number, or branch name (optional - will prompt if not provided)").option("--claude", "Enable Claude integration (default: true)").option("--no-claude", "Disable Claude integration").option("--code", "Enable VSCode (default: true)").option("--no-code", "Disable VSCode").option("--dev-server", "Enable dev server in terminal (default: true)").option("--no-dev-server", "Disable dev server").option("--terminal", "Enable terminal without dev server (default: false)").option("--no-terminal", "Disable terminal").option("--child-loom", "Force create as child loom (skip prompt)").option("--no-child-loom", "Force create as independent loom (skip prompt)").option("--body <text>", "Body text for issue (skips AI enhancement)").option("--json", "Output result as JSON").addOption(
   new Option("--one-shot <mode>", "One-shot automation mode").choices(["default", "noReview", "bypassPermissions"]).default("default")
 ).action(async (identifier, options) => {
-  try {
-    let finalIdentifier = identifier;
-    if (!finalIdentifier) {
-      const { promptInput } = await import("./prompt-QALMYTVC.js");
-      finalIdentifier = await promptInput("Enter issue number, PR number (pr/123), or branch name");
-      if (!(finalIdentifier == null ? void 0 : finalIdentifier.trim())) {
-        logger.error("Identifier is required");
-        process.exit(1);
+  const executeAction = async () => {
+    try {
+      let finalIdentifier = identifier;
+      if (!finalIdentifier) {
+        if (options.json) {
+          logger.error("JSON mode requires identifier argument");
+          process.exit(1);
+        }
+        const { promptInput } = await import("./prompt-A7GGRHSY.js");
+        finalIdentifier = await promptInput("Enter issue number, PR number (pr/123), or branch name");
+        if (!(finalIdentifier == null ? void 0 : finalIdentifier.trim())) {
+          logger.error("Identifier is required");
+          process.exit(1);
+        }
+      }
+      const settingsManager = new SettingsManager();
+      const settings = await settingsManager.loadSettings();
+      const issueTracker = IssueTrackerFactory.create(settings);
+      const command = new StartCommand(issueTracker, void 0, void 0, settingsManager);
+      const result = await command.execute({ identifier: finalIdentifier, options });
+      if (options.json && result) {
+        console.log(JSON.stringify(result, null, 2));
       }
+      process.exit(0);
+    } catch (error) {
+      logger.error(`Failed to start workspace: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
     }
-    const settingsManager = new SettingsManager();
-    const settings = await settingsManager.loadSettings();
-    const issueTracker = IssueTrackerFactory.create(settings);
-    const command = new StartCommand(issueTracker, void 0, void 0, settingsManager);
-    await command.execute({ identifier: finalIdentifier, options });
-  } catch (error) {
-    logger.error(`Failed to start workspace: ${error instanceof Error ? error.message : "Unknown error"}`);
-    process.exit(1);
+  };
+  if (options.json) {
+    const jsonLogger = createStderrLogger();
+    await withLogger(jsonLogger, executeAction);
+  } else {
+    await executeAction();
   }
 });
-program.command("add-issue").alias("a").description("Create and enhance GitHub issue without starting workspace").argument("<description>", "Natural language description of the issue (>50 chars, >2 spaces)").option("--body <text>", "Body text for issue (skips AI enhancement)").action(async (description, options) => {
-  try {
-    const settingsManager = new SettingsManager();
-    const settings = await settingsManager.loadSettings();
-    const issueTracker = IssueTrackerFactory.create(settings);
-    const enhancementService = new IssueEnhancementService(issueTracker, new AgentManager(), settingsManager);
-    const command = new AddIssueCommand(enhancementService, settingsManager);
-    const issueNumber = await command.execute({
-      description,
-      options: options.body ? { body: options.body } : {}
-    });
-    logger.success(`Issue #${issueNumber} created successfully`);
-    process.exit(0);
-  } catch (error) {
-    logger.error(`Failed to create issue: ${error instanceof Error ? error.message : "Unknown error"}`);
-    process.exit(1);
+program.command("add-issue").alias("a").description("Create and enhance GitHub issue without starting workspace").argument("<description>", "Natural language description of the issue (>50 chars, >2 spaces)").option("--body <text>", "Body text for issue (skips AI enhancement)").option("--json", "Output result as JSON").action(async (description, options) => {
+  const executeAction = async () => {
+    try {
+      const settingsManager = new SettingsManager();
+      const settings = await settingsManager.loadSettings();
+      const issueTracker = IssueTrackerFactory.create(settings);
+      const enhancementService = new IssueEnhancementService(issueTracker, new AgentManager(), settingsManager);
+      const command = new AddIssueCommand(enhancementService, settingsManager);
+      const result = await command.execute({
+        description,
+        options: {
+          ...options.body && { body: options.body },
+          ...options.json && { json: options.json }
+        }
+      });
+      if (options.json && result) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result) {
+        const issueNumber = typeof result === "object" ? result.id : result;
+        logger.success(`Issue #${issueNumber} created successfully`);
+      }
+      process.exit(0);
+    } catch (error) {
+      logger.error(`Failed to create issue: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  };
+  if (options.json) {
+    const jsonLogger = createStderrLogger();
+    await withLogger(jsonLogger, executeAction);
+  } else {
+    await executeAction();
   }
 });
 program.command("feedback").alias("f").description("Submit feedback/bug report to iloom-cli repository").argument("<description>", "Natural language description of feedback (>50 chars, >2 spaces)").option("--body <text>", "Body text for feedback (added after diagnostics)").action(async (description, options) => {
   try {
-    const { FeedbackCommand } = await import("./feedback-XTUCKJNT.js");
+    const { FeedbackCommand } = await import("./feedback-7PVBQNLJ.js");
     const command = new FeedbackCommand();
     const feedbackOptions = {};
     if (options.body !== void 0) {
@@ -2818,41 +3236,70 @@ program.command("feedback").alias("f").description("Submit feedback/bug report t
     process.exit(1);
   }
 });
-program.command("enhance").description("Apply enhancement agent to existing GitHub issue").argument("<issue-number>", "GitHub issue identifier to enhance", parseIssueIdentifier).option("--no-browser", "Skip browser opening prompt").option("--author <username>", "GitHub username to tag in questions (for CI usage)").action(async (issueNumber, options) => {
-  try {
-    const settingsManager = new SettingsManager();
-    const settings = await settingsManager.loadSettings();
-    const issueTracker = IssueTrackerFactory.create(settings);
-    const command = new EnhanceCommand(issueTracker);
-    await command.execute({
-      issueNumber,
-      options: {
-        noBrowser: options.browser === false,
-        ...options.author && { author: options.author }
+program.command("enhance").description("Apply enhancement agent to existing GitHub issue").argument("<issue-number>", "GitHub issue identifier to enhance", parseIssueIdentifier).option("--no-browser", "Skip browser opening prompt").option("--author <username>", "GitHub username to tag in questions (for CI usage)").option("--json", "Output result as JSON").action(async (issueNumber, options) => {
+  const executeAction = async () => {
+    try {
+      const settingsManager = new SettingsManager();
+      const settings = await settingsManager.loadSettings();
+      const issueTracker = IssueTrackerFactory.create(settings);
+      const command = new EnhanceCommand(issueTracker);
+      const result = await command.execute({
+        issueNumber,
+        options: {
+          noBrowser: options.browser === false,
+          ...options.author && { author: options.author },
+          ...options.json && { json: options.json }
+        }
+      });
+      if (options.json && result) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        logger.success(`Enhancement process completed for issue #${issueNumber}`);
       }
-    });
-    logger.success(`Enhancement process completed for issue #${issueNumber}`);
-    process.exit(0);
-  } catch (error) {
-    logger.error(`Failed to enhance issue: ${error instanceof Error ? error.message : "Unknown error"}`);
-    process.exit(1);
+      process.exit(0);
+    } catch (error) {
+      logger.error(`Failed to enhance issue: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  };
+  if (options.json) {
+    const jsonLogger = createStderrLogger();
+    await withLogger(jsonLogger, executeAction);
+  } else {
+    await executeAction();
   }
 });
-program.command("finish").alias("dn").description("Merge work and cleanup workspace").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").option("-f, --force", "Skip confirmation prompts").option("-n, --dry-run", "Preview actions without executing").option("--pr <number>", "Treat input as PR number", parseFloat).option("--skip-build", "Skip post-merge build verification").option("--no-browser", "Skip opening PR in browser (github-pr mode only)").option("--cleanup", "Clean up worktree after PR creation (github-pr mode only)").option("--no-cleanup", "Keep worktree after PR creation (github-pr mode only)").action(async (identifier, options) => {
-  try {
-    const settingsManager = new SettingsManager();
-    const settings = await settingsManager.loadSettings();
-    const issueTracker = IssueTrackerFactory.create(settings);
-    const command = new FinishCommand(issueTracker);
-    await command.execute({ identifier, options });
-  } catch (error) {
-    logger.error(`Failed to finish workspace: ${error instanceof Error ? error.message : "Unknown error"}`);
-    process.exit(1);
+program.command("finish").alias("dn").description("Merge work and cleanup workspace").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").option("-f, --force", "Skip confirmation prompts").option("-n, --dry-run", "Preview actions without executing").option("--pr <number>", "Treat input as PR number", parseFloat).option("--skip-build", "Skip post-merge build verification").option("--no-browser", "Skip opening PR in browser (github-pr mode only)").option("--cleanup", "Clean up worktree after PR creation (github-pr mode only)").option("--no-cleanup", "Keep worktree after PR creation (github-pr mode only)").option("--json", "Output result as JSON").action(async (identifier, options) => {
+  const executeAction = async () => {
+    try {
+      const settingsManager = new SettingsManager();
+      const settings = await settingsManager.loadSettings();
+      const issueTracker = IssueTrackerFactory.create(settings);
+      const command = new FinishCommand(issueTracker);
+      const result = await command.execute({ identifier, options });
+      if (options.json && result) {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      process.exit(0);
+    } catch (error) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: error instanceof Error ? error.message : "Unknown error" }, null, 2));
+      } else {
+        logger.error(`Failed to finish workspace: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+      process.exit(1);
+    }
+  };
+  if (options.json) {
+    const jsonLogger = createStderrLogger();
+    await withLogger(jsonLogger, executeAction);
+  } else {
+    await executeAction();
   }
 });
 program.command("rebase").description("Rebase current branch on main with Claude-assisted conflict resolution").option("-f, --force", "Skip confirmation prompts").option("-n, --dry-run", "Preview actions without executing").action(async (options) => {
   try {
-    const { RebaseCommand } = await import("./rebase-VJ2VKR6R.js");
+    const { RebaseCommand } = await import("./rebase-4T5FQHNH.js");
     const command = new RebaseCommand();
     await command.execute(options);
   } catch (error) {
@@ -2864,7 +3311,7 @@ program.command("spin").alias("ignite").description("Launch Claude with auto-det
   new Option("--one-shot <mode>", "One-shot automation mode").choices(["default", "noReview", "bypassPermissions"]).default("default")
 ).action(async (options) => {
   try {
-    const { IgniteCommand } = await import("./ignite-T74RYXCA.js");
+    const { IgniteCommand } = await import("./ignite-3B264M7K.js");
     const command = new IgniteCommand();
     await command.execute(options.oneShot ?? "default");
   } catch (error) {
@@ -2875,7 +3322,7 @@ program.command("spin").alias("ignite").description("Launch Claude with auto-det
 program.command("open").description("Open workspace in browser or run CLI tool").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").allowUnknownOption().action(async (identifier, _options, command) => {
   try {
     const args = (command == null ? void 0 : command.args) ? command.args.slice(identifier ? 1 : 0) : [];
-    const { OpenCommand } = await import("./open-UMXANW5S.js");
+    const { OpenCommand } = await import("./open-OGCV32Z4.js");
     const cmd = new OpenCommand();
     const input = identifier ? { identifier, args } : { args };
     await cmd.execute(input);
@@ -2887,7 +3334,7 @@ program.command("open").description("Open workspace in browser or run CLI tool")
 program.command("run").description("Run CLI tool or open workspace in browser").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").allowUnknownOption().action(async (identifier, _options, command) => {
   try {
     const args = (command == null ? void 0 : command.args) ? command.args.slice(identifier ? 1 : 0) : [];
-    const { RunCommand } = await import("./run-MJYY4PUT.js");
+    const { RunCommand } = await import("./run-HNOP6WE2.js");
     const cmd = new RunCommand();
     const input = identifier ? { identifier, args } : { args };
     await cmd.execute(input);
@@ -2896,22 +3343,58 @@ program.command("run").description("Run CLI tool or open workspace in browser").
     process.exit(1);
   }
 });
-program.command("cleanup").alias("remove").alias("clean").description("Remove workspaces").argument("[identifier]", "Branch name or issue number to cleanup (auto-detected)").option("-l, --list", "List all worktrees").option("-a, --all", "Remove all worktrees (interactive confirmation)").option("-i, --issue <number>", "Cleanup by issue number", parseInt).option("-f, --force", "Skip confirmations and force removal").option("--dry-run", "Show what would be done without doing it").action(async (identifier, options) => {
+program.command("dev-server").alias("dev").description("Start dev server for workspace (foreground)").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").option("--json", "Output as JSON").action(async (identifier, options) => {
   try {
-    const { CleanupCommand } = await import("./cleanup-H4VXU3C3.js");
-    const command = new CleanupCommand();
-    const input = {
-      options: options ?? {}
-    };
-    if (identifier) {
-      input.identifier = identifier;
-    }
-    await command.execute(input);
+    const { DevServerCommand } = await import("./dev-server-JCJGQ3PV.js");
+    const cmd = new DevServerCommand();
+    await cmd.execute({ identifier, json: options == null ? void 0 : options.json });
+  } catch (error) {
+    logger.error(`Failed to start dev server: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("shell").alias("terminal").description("Open interactive shell with workspace environment").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").action(async (identifier) => {
+  try {
+    const { ShellCommand } = await import("./shell-DE3HKJSM.js");
+    const cmd = new ShellCommand();
+    await cmd.execute({ identifier });
   } catch (error) {
-    logger.error(`Failed to cleanup worktrees: ${error instanceof Error ? error.message : "Unknown error"}`);
+    logger.error(`Failed to open shell: ${error instanceof Error ? error.message : "Unknown error"}`);
     process.exit(1);
   }
 });
+program.command("cleanup").alias("remove").alias("clean").description("Remove workspaces").argument("[identifier]", "Branch name or issue number to cleanup (auto-detected)").option("-l, --list", "List all worktrees").option("-a, --all", "Remove all worktrees (interactive confirmation)").option("-i, --issue <number>", "Cleanup by issue number", parseInt).option("-f, --force", "Skip confirmations and force removal").option("--dry-run", "Show what would be done without doing it").option("--json", "Output result as JSON").action(async (identifier, options) => {
+  const executeAction = async () => {
+    try {
+      const { CleanupCommand } = await import("./cleanup-KDLVTT7M.js");
+      const command = new CleanupCommand();
+      const input = {
+        options: options ?? {}
+      };
+      if (identifier) {
+        input.identifier = identifier;
+      }
+      const result = await command.execute(input);
+      if ((options == null ? void 0 : options.json) && result) {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      process.exit(0);
+    } catch (error) {
+      if (options == null ? void 0 : options.json) {
+        console.log(JSON.stringify({ success: false, error: error instanceof Error ? error.message : "Unknown error" }, null, 2));
+      } else {
+        logger.error(error instanceof Error ? error.message : "Unknown error");
+      }
+      process.exit(1);
+    }
+  };
+  if (options == null ? void 0 : options.json) {
+    const jsonLogger = createStderrLogger();
+    await withLogger(jsonLogger, executeAction);
+  } else {
+    await executeAction();
+  }
+});
 program.command("list").description("Show active workspaces").option("--json", "Output as JSON").action(async (options) => {
   try {
     const manager = new GitWorktreeManager();
@@ -2955,9 +3438,20 @@ program.command("list").description("Show active workspaces").option("--json", "
     process.exit(1);
   }
 });
+program.command("projects").description("List configured iloom projects").option("--json", "Output as JSON (default behavior)").action(async (options) => {
+  try {
+    const { ProjectsCommand } = await import("./projects-P55273AB.js");
+    const command = new ProjectsCommand();
+    const result = await command.execute(options);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    logger.error(`Failed to list projects: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
 program.command("init").alias("config").description("Initialize iloom configuration and setup shell autocomplete").argument("[prompt]", 'Custom initial message to send to Claude (defaults to "Help me configure iloom settings.")').action(async (prompt) => {
   try {
-    const { InitCommand: InitCommand2 } = await import("./init-4FHTAM3F.js");
+    const { InitCommand: InitCommand2 } = await import("./init-LBA6NUK2.js");
     const command = new InitCommand2();
     const trimmedPrompt = prompt == null ? void 0 : prompt.trim();
     const customPrompt = trimmedPrompt && trimmedPrompt.length > 0 ? trimmedPrompt : void 0;
@@ -2969,7 +3463,7 @@ program.command("init").alias("config").description("Initialize iloom configurat
 });
 program.command("contribute").description("Set up local development environment for contributing to iloom").action(async () => {
   try {
-    const { ContributeCommand } = await import("./contribute-Y7IQV5QY.js");
+    const { ContributeCommand } = await import("./contribute-HY372S6F.js");
     const command = new ContributeCommand();
     await command.execute();
   } catch (error) {
@@ -2979,7 +3473,7 @@ program.command("contribute").description("Set up local development environment
 });
 program.command("update").description("Update iloom-cli to the latest version").option("--dry-run", "Show what would be done without actually updating").action(async (options) => {
   try {
-    const { UpdateCommand } = await import("./update-4TDDUR5K.js");
+    const { UpdateCommand } = await import("./update-LETF5ASC.js");
     const command = new UpdateCommand();
     await command.execute(options);
   } catch (error) {
@@ -2989,8 +3483,8 @@ program.command("update").description("Update iloom-cli to the latest version").
 });
 program.command("test-github").description("Test GitHub integration (Issue #3)").argument("<identifier>", "Issue number or PR number").option("--no-claude", "Skip Claude for branch name generation").action(async (identifier, options) => {
   try {
-    const { GitHubService: GitHubService2 } = await import("./GitHubService-FZHHBOFG.js");
-    const { DefaultBranchNamingService: DefaultBranchNamingService2 } = await import("./BranchNamingService-A77VI6AI.js");
+    const { GitHubService: GitHubService2 } = await import("./GitHubService-RPM27GWD.js");
+    const { DefaultBranchNamingService: DefaultBranchNamingService2 } = await import("./BranchNamingService-GCCWB3LK.js");
     logger.info("Testing GitHub Integration\n");
     const service = new GitHubService2();
     const branchNaming = new DefaultBranchNamingService2({ useClaude: options.claude !== false });
@@ -3048,10 +3542,10 @@ program.command("test-github").description("Test GitHub integration (Issue #3)")
 });
 program.command("test-claude").description("Test Claude integration (Issue #10)").option("--detect", "Test Claude CLI detection").option("--version", "Get Claude CLI version").option("--branch <title>", "Test branch name generation with given title").option("--issue <number>", "Issue number for branch generation", "123").option("--launch <prompt>", "Launch Claude with a prompt (headless)").option("--interactive", "Launch Claude interactively (requires --launch)").option("--template <name>", "Test template loading").action(async (options) => {
   try {
-    const { detectClaudeCli: detectClaudeCli2, getClaudeVersion, generateBranchName, launchClaude: launchClaude2 } = await import("./claude-W52VKI6L.js");
-    const { PromptTemplateManager } = await import("./PromptTemplateManager-6HH3PVXV.js");
-    const { ClaudeService } = await import("./ClaudeService-DLYLJUPA.js");
-    const { ClaudeContextManager: ClaudeContextManager2 } = await import("./ClaudeContextManager-BN7RE5ZQ.js");
+    const { detectClaudeCli: detectClaudeCli2, getClaudeVersion, generateBranchName, launchClaude: launchClaude2 } = await import("./claude-ACVXNB6N.js");
+    const { PromptTemplateManager } = await import("./PromptTemplateManager-2TDZAUC6.js");
+    const { ClaudeService } = await import("./ClaudeService-W3SA7HVG.js");
+    const { ClaudeContextManager: ClaudeContextManager2 } = await import("./ClaudeContextManager-DK77227F.js");
     logger.info("Testing Claude Integration\n");
     if (options.detect) {
       logger.info("Detecting Claude CLI...");
@@ -3186,7 +3680,7 @@ program.command("test-claude").description("Test Claude integration (Issue #10)"
 });
 program.command("test-webserver").description("Test if a web server is running on a workspace port").argument("<issue-number>", "Issue number (port will be calculated as 3000 + issue number)", parseInt).option("--kill", "Kill the web server if detected").action(async (issueNumber, options) => {
   try {
-    const { TestWebserverCommand } = await import("./test-webserver-DAHONWCS.js");
+    const { TestWebserverCommand } = await import("./test-webserver-VPNLAFZ3.js");
     const command = new TestWebserverCommand();
     await command.execute({ issueNumber, options });
   } catch (error) {
@@ -3199,7 +3693,7 @@ program.command("test-webserver").description("Test if a web server is running o
 });
 program.command("test-git").description("Test Git integration - findMainWorktreePath() function (reads .iloom/settings.json)").action(async () => {
   try {
-    const { TestGitCommand } = await import("./test-git-IT5EWQ5C.js");
+    const { TestGitCommand } = await import("./test-git-YMAE57UP.js");
     const command = new TestGitCommand();
     await command.execute();
   } catch (error) {
@@ -3212,7 +3706,7 @@ program.command("test-git").description("Test Git integration - findMainWorktree
 });
 program.command("test-tabs").description("Test iTerm2 dual tab functionality - opens two tabs with test commands").action(async () => {
   try {
-    const { TestTabsCommand } = await import("./test-tabs-PRMRSHKI.js");
+    const { TestTabsCommand } = await import("./test-tabs-3SCJWRKT.js");
     const command = new TestTabsCommand();
     await command.execute();
   } catch (error) {
@@ -3225,7 +3719,7 @@ program.command("test-tabs").description("Test iTerm2 dual tab functionality - o
 });
 program.command("test-prefix").description("Test worktree prefix configuration - preview worktree paths (reads .iloom/settings.json)").action(async () => {
   try {
-    const { TestPrefixCommand } = await import("./test-prefix-NPWDPUUH.js");
+    const { TestPrefixCommand } = await import("./test-prefix-YCKL6CMT.js");
     const command = new TestPrefixCommand();
     await command.execute();
   } catch (error) {
@@ -3236,11 +3730,40 @@ program.command("test-prefix").description("Test worktree prefix configuration -
     process.exit(1);
   }
 });
+program.command("summary").description("Generate Claude session summary for a loom").argument("[identifier]", "Issue number, PR number (pr/123), or branch name (auto-detected if omitted)").option("--with-comment", "Post summary as a comment to the issue/PR").option("--json", "Output result as JSON").action(async (identifier, options) => {
+  const executeAction = async () => {
+    try {
+      const { SummaryCommand } = await import("./summary-GDT7DTRI.js");
+      const command = new SummaryCommand();
+      const result = await command.execute({ identifier, options });
+      if (options.json && result) {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      process.exit(0);
+    } catch (error) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }, null, 2));
+      } else {
+        logger.error(`Summary failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        if (error instanceof Error && error.stack) {
+          logger.debug(error.stack);
+        }
+      }
+      process.exit(1);
+    }
+  };
+  if (options.json) {
+    const jsonLogger = createStderrLogger();
+    await withLogger(jsonLogger, executeAction);
+  } else {
+    await executeAction();
+  }
+});
 program.command("test-neon").description("Test Neon integration and debug configuration").action(async () => {
   var _a;
   try {
-    const { SettingsManager: SettingsManager2 } = await import("./SettingsManager-I2LRCW2A.js");
-    const { createNeonProviderFromSettings: createNeonProviderFromSettings2 } = await import("./neon-helpers-77PBPGJ5.js");
+    const { SettingsManager: SettingsManager2 } = await import("./SettingsManager-FJFU6JJD.js");
+    const { createNeonProviderFromSettings: createNeonProviderFromSettings2 } = await import("./neon-helpers-L5CXQ5CT.js");
     logger.info("Testing Neon Integration\n");
     logger.info("1. Settings Configuration:");
     const settingsManager = new SettingsManager2();