@iloom/cli 0.1.19 → 0.3.0

package/dist/index.js

@@ -147,18 +147,23 @@ var SettingsManager_exports = {};
 __export(SettingsManager_exports, {
   AgentSettingsSchema: () => AgentSettingsSchema,
   CapabilitiesSettingsSchema: () => CapabilitiesSettingsSchema,
+  CapabilitiesSettingsSchemaNoDefaults: () => CapabilitiesSettingsSchemaNoDefaults,
   DatabaseProvidersSettingsSchema: () => DatabaseProvidersSettingsSchema,
   IloomSettingsSchema: () => IloomSettingsSchema,
+  IloomSettingsSchemaNoDefaults: () => IloomSettingsSchemaNoDefaults,
   NeonSettingsSchema: () => NeonSettingsSchema,
   SettingsManager: () => SettingsManager,
   WorkflowPermissionSchema: () => WorkflowPermissionSchema,
-  WorkflowsSettingsSchema: () => WorkflowsSettingsSchema
+  WorkflowPermissionSchemaNoDefaults: () => WorkflowPermissionSchemaNoDefaults,
+  WorkflowsSettingsSchema: () => WorkflowsSettingsSchema,
+  WorkflowsSettingsSchemaNoDefaults: () => WorkflowsSettingsSchemaNoDefaults
 });
 import { readFile } from "fs/promises";
 import path from "path";
+import os from "os";
 import { z } from "zod";
 import deepmerge from "deepmerge";
-var AgentSettingsSchema, WorkflowPermissionSchema, WorkflowsSettingsSchema, CapabilitiesSettingsSchema, NeonSettingsSchema, DatabaseProvidersSettingsSchema, IloomSettingsSchema, SettingsManager;
+var AgentSettingsSchema, WorkflowPermissionSchema, WorkflowPermissionSchemaNoDefaults, WorkflowsSettingsSchema, WorkflowsSettingsSchemaNoDefaults, CapabilitiesSettingsSchema, CapabilitiesSettingsSchemaNoDefaults, NeonSettingsSchema, DatabaseProvidersSettingsSchema, IloomSettingsSchema, IloomSettingsSchemaNoDefaults, SettingsManager;
 var init_SettingsManager = __esm({
   "src/lib/SettingsManager.ts"() {
     "use strict";
@@ -175,11 +180,24 @@ var init_SettingsManager = __esm({
       startAiAgent: z.boolean().default(true).describe("Launch Claude AI agent when starting this workflow type"),
       startTerminal: z.boolean().default(false).describe("Launch terminal window without dev server when starting this workflow type")
     });
+    WorkflowPermissionSchemaNoDefaults = z.object({
+      permissionMode: z.enum(["plan", "acceptEdits", "bypassPermissions", "default"]).optional().describe("Permission mode for Claude CLI in this workflow type"),
+      noVerify: z.boolean().optional().describe("Skip pre-commit hooks (--no-verify) when committing during finish workflow"),
+      startIde: z.boolean().optional().describe("Launch IDE (code) when starting this workflow type"),
+      startDevServer: z.boolean().optional().describe("Launch development server when starting this workflow type"),
+      startAiAgent: z.boolean().optional().describe("Launch Claude AI agent when starting this workflow type"),
+      startTerminal: z.boolean().optional().describe("Launch terminal window without dev server when starting this workflow type")
+    });
     WorkflowsSettingsSchema = z.object({
       issue: WorkflowPermissionSchema.optional(),
       pr: WorkflowPermissionSchema.optional(),
       regular: WorkflowPermissionSchema.optional()
     }).optional();
+    WorkflowsSettingsSchemaNoDefaults = z.object({
+      issue: WorkflowPermissionSchemaNoDefaults.optional(),
+      pr: WorkflowPermissionSchemaNoDefaults.optional(),
+      regular: WorkflowPermissionSchemaNoDefaults.optional()
+    }).optional();
     CapabilitiesSettingsSchema = z.object({
       web: z.object({
         basePort: z.number().min(1, "Base port must be >= 1").max(65535, "Base port must be <= 65535").optional().describe("Base port for web workspace port calculations (default: 3000)")
@@ -188,6 +206,14 @@ var init_SettingsManager = __esm({
         databaseUrlEnvVarName: z.string().min(1, "Database URL variable name cannot be empty").regex(/^[A-Z_][A-Z0-9_]*$/, "Must be valid env var name (uppercase, underscores)").optional().default("DATABASE_URL").describe("Name of environment variable for database connection URL")
       }).optional()
     }).optional();
+    CapabilitiesSettingsSchemaNoDefaults = z.object({
+      web: z.object({
+        basePort: z.number().min(1, "Base port must be >= 1").max(65535, "Base port must be <= 65535").optional().describe("Base port for web workspace port calculations (default: 3000)")
+      }).optional(),
+      database: z.object({
+        databaseUrlEnvVarName: z.string().min(1, "Database URL variable name cannot be empty").regex(/^[A-Z_][A-Z0-9_]*$/, "Must be valid env var name (uppercase, underscores)").optional().describe("Name of environment variable for database connection URL")
+      }).optional()
+    }).optional();
     NeonSettingsSchema = z.object({
       projectId: z.string().min(1).regex(/^[a-zA-Z0-9-]+$/, "Neon project ID must contain only letters, numbers, and hyphens").describe('Neon project ID found in your project URL (e.g., "fantastic-fox-3566354")'),
       parentBranch: z.string().min(1).describe("Branch from which new database branches are created")
@@ -199,6 +225,9 @@ var init_SettingsManager = __esm({
     }).optional();
     IloomSettingsSchema = z.object({
       mainBranch: z.string().min(1, "Settings 'mainBranch' cannot be empty").optional().describe("Name of the main/primary branch for the repository"),
+      sourceEnvOnStart: z.boolean().default(false).describe(
+        "Source .env file when launching terminal processes (Claude, dev server, terminal). NOTE TO AI AGENTS: Before making changes to settings files, YOU MUST OFFER to check  .env compatibility. WARNING: Unquoted values in .env files may break sourcing in bash/zsh shells. Before enabling, verify your .env file does not contain unquoted special characters (e.g., database URLs with ?, &, or other shell metacharacters). Shell compatibility issues may cause processes to fail or behave unexpectedly."
+      ),
       worktreePrefix: z.string().optional().refine(
         (val) => {
           if (val === void 0) return true;
@@ -228,28 +257,107 @@ var init_SettingsManager = __esm({
       capabilities: CapabilitiesSettingsSchema.describe("Project capability configurations"),
       databaseProviders: DatabaseProvidersSettingsSchema.describe("Database provider configurations"),
       issueManagement: z.object({
+        provider: z.enum(["github", "linear"]).optional().default("github").describe("Issue tracker provider (github, linear)"),
+        github: z.object({
+          remote: z.string().min(1, "Remote name cannot be empty").describe("Git remote name to use for GitHub operations")
+        }).optional(),
+        linear: z.object({
+          teamId: z.string().min(1, "Team ID cannot be empty").describe('Linear team identifier (e.g., "ENG", "PLAT")'),
+          branchFormat: z.string().optional().describe("Branch naming template for Linear issues"),
+          apiToken: z.string().optional().describe("Linear API token (lin_api_...). SECURITY: Store in settings.local.json only, never commit to source control.")
+        }).optional()
+      }).optional().describe("Issue management configuration"),
+      mergeBehavior: z.object({
+        mode: z.enum(["local", "github-pr"]).default("local"),
+        remote: z.string().optional()
+      }).optional().describe("Merge behavior configuration: local (merge locally) or github-pr (create PR)"),
+      ide: z.object({
+        type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf"]).default("vscode").describe(
+          "IDE to launch when starting a loom. Options: vscode (Visual Studio Code), cursor (Cursor AI editor), webstorm (JetBrains WebStorm), sublime (Sublime Text), intellij (JetBrains IntelliJ IDEA), windsurf (Windsurf editor)."
+        )
+      }).optional().describe(
+        "IDE configuration for workspace launches. Controls which editor opens when you start a loom. Supports VSCode, Cursor, WebStorm, Sublime Text, IntelliJ, and Windsurf. Note: Color synchronization (title bar colors) only works with VSCode-compatible editors (vscode, cursor, windsurf)."
+      )
+    });
+    IloomSettingsSchemaNoDefaults = z.object({
+      mainBranch: z.string().min(1, "Settings 'mainBranch' cannot be empty").optional().describe("Name of the main/primary branch for the repository"),
+      sourceEnvOnStart: z.boolean().optional().describe(
+        "Source .env file when launching terminal processes (Claude, dev server, terminal). NOTE TO AI AGENTS: Before making changes to settings files, YOU MUST OFFER to check  .env compatibility. WARNING: Unquoted values in .env files may break sourcing in bash/zsh shells. Before enabling, verify your .env file does not contain unquoted special characters (e.g., database URLs with ?, &, or other shell metacharacters). Shell compatibility issues may cause processes to fail or behave unexpectedly."
+      ),
+      worktreePrefix: z.string().optional().refine(
+        (val) => {
+          if (val === void 0) return true;
+          if (val === "") return true;
+          const allowedChars = /^[a-zA-Z0-9\-_/]+$/;
+          if (!allowedChars.test(val)) return false;
+          if (/^[-_/]+$/.test(val)) return false;
+          const segments = val.split("/");
+          for (const segment of segments) {
+            if (segment && /^[-_]+$/.test(segment)) {
+              return false;
+            }
+          }
+          return true;
+        },
+        {
+          message: "worktreePrefix contains invalid characters. Only alphanumeric characters, hyphens (-), underscores (_), and forward slashes (/) are allowed. Use forward slashes for nested directories."
+        }
+      ).describe(
+        "Prefix for worktree directories. Empty string disables prefix. Defaults to <repo-name>-looms if not set."
+      ),
+      protectedBranches: z.array(z.string().min(1, "Protected branch name cannot be empty")).optional().describe('List of branches that cannot be deleted (defaults to [mainBranch, "main", "master", "develop"])'),
+      workflows: WorkflowsSettingsSchemaNoDefaults.describe("Per-workflow-type permission configurations"),
+      agents: z.record(z.string(), AgentSettingsSchema).optional().nullable().describe(
+        "Per-agent configuration overrides. Available agents: iloom-issue-analyzer (analyzes issues), iloom-issue-planner (creates implementation plans), iloom-issue-analyze-and-plan (combined analysis and planning), iloom-issue-complexity-evaluator (evaluates complexity), iloom-issue-enhancer (enhances issue descriptions), iloom-issue-implementer (implements code changes), iloom-issue-reviewer (reviews code changes against requirements)"
+      ),
+      capabilities: CapabilitiesSettingsSchemaNoDefaults.describe("Project capability configurations"),
+      databaseProviders: DatabaseProvidersSettingsSchema.describe("Database provider configurations"),
+      issueManagement: z.object({
+        provider: z.enum(["github", "linear"]).optional().describe("Issue tracker provider (github, linear)"),
         github: z.object({
           remote: z.string().min(1, "Remote name cannot be empty").describe("Git remote name to use for GitHub operations")
+        }).optional(),
+        linear: z.object({
+          teamId: z.string().min(1, "Team ID cannot be empty").describe('Linear team identifier (e.g., "ENG", "PLAT")'),
+          branchFormat: z.string().optional().describe("Branch naming template for Linear issues"),
+          apiToken: z.string().optional().describe("Linear API token (lin_api_...). SECURITY: Store in settings.local.json only, never commit to source control.")
         }).optional()
-      }).optional().describe("Issue management configuration")
+      }).optional().describe("Issue management configuration"),
+      mergeBehavior: z.object({
+        mode: z.enum(["local", "github-pr"]).optional(),
+        remote: z.string().optional()
+      }).optional().describe("Merge behavior configuration: local (merge locally) or github-pr (create PR)"),
+      ide: z.object({
+        type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf"]).optional().describe(
+          "IDE to launch when starting a loom. Options: vscode (Visual Studio Code), cursor (Cursor AI editor), webstorm (JetBrains WebStorm), sublime (Sublime Text), intellij (JetBrains IntelliJ IDEA), windsurf (Windsurf editor)."
+        )
+      }).optional().describe(
+        "IDE configuration for workspace launches. Controls which editor opens when you start a loom. Supports VSCode, Cursor, WebStorm, Sublime Text, IntelliJ, and Windsurf. Note: Color synchronization (title bar colors) only works with VSCode-compatible editors (vscode, cursor, windsurf)."
+      )
     });
     SettingsManager = class {
       /**
-       * Load settings from <PROJECT_ROOT>/.iloom/settings.json and settings.local.json
-       * Merges settings.local.json over settings.json with priority
-       * CLI overrides have highest priority if provided
-       * Returns empty object if both files don't exist (not an error)
+       * Load settings from global, project, and local sources with proper precedence
+       * Merge hierarchy (lowest to highest priority):
+       * 1. Global settings (~/.config/iloom-ai/settings.json)
+       * 2. Project settings (<PROJECT_ROOT>/.iloom/settings.json)
+       * 3. Local settings (<PROJECT_ROOT>/.iloom/settings.local.json)
+       * 4. CLI overrides (--set flags)
+       * Returns empty object if all files don't exist (not an error)
        */
       async loadSettings(projectRoot, cliOverrides) {
         const root = this.getProjectRoot(projectRoot);
+        const globalSettings = await this.loadGlobalSettingsFile();
+        const globalSettingsPath = this.getGlobalSettingsPath();
+        logger.debug(`\u{1F30D} Global settings from ${globalSettingsPath}:`, JSON.stringify(globalSettings, null, 2));
         const baseSettings = await this.loadSettingsFile(root, "settings.json");
         const baseSettingsPath = path.join(root, ".iloom", "settings.json");
         logger.debug(`\u{1F4C4} Base settings from ${baseSettingsPath}:`, JSON.stringify(baseSettings, null, 2));
         const localSettings = await this.loadSettingsFile(root, "settings.local.json");
         const localSettingsPath = path.join(root, ".iloom", "settings.local.json");
         logger.debug(`\u{1F4C4} Local settings from ${localSettingsPath}:`, JSON.stringify(localSettings, null, 2));
-        let merged = this.mergeSettings(baseSettings, localSettings);
-        logger.debug("\u{1F504} After merging base + local settings:", JSON.stringify(merged, null, 2));
+        let merged = this.mergeSettings(this.mergeSettings(globalSettings, baseSettings), localSettings);
+        logger.debug("\u{1F504} After merging global + base + local settings:", JSON.stringify(merged, null, 2));
         if (cliOverrides && Object.keys(cliOverrides).length > 0) {
           logger.debug("\u2699\uFE0F CLI overrides to apply:", JSON.stringify(cliOverrides, null, 2));
           merged = this.mergeSettings(merged, cliOverrides);
@@ -281,6 +389,7 @@ Note: CLI overrides were applied. Check your --set arguments.`);
       /**
        * Load and parse a single settings file
        * Returns empty object if file doesn't exist (not an error)
+       * Uses non-defaulting schema to prevent polluting partial settings with defaults before merge
        */
       async loadSettingsFile(projectRoot, filename) {
         const settingsPath = path.join(projectRoot, ".iloom", filename);
@@ -294,16 +403,13 @@ Note: CLI overrides were applied. Check your --set arguments.`);
               `Failed to parse settings file at ${settingsPath}: ${error instanceof Error ? error.message : "Invalid JSON"}`
             );
           }
-          try {
-            const validated = IloomSettingsSchema.strict().parse(parsed);
-            return validated;
-          } catch (error) {
-            if (error instanceof z.ZodError) {
-              const errorMsg = this.formatAllZodErrors(error, filename);
-              throw errorMsg;
-            }
-            throw error;
+          if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            throw new Error(
+              `Settings validation failed at ${filename}:
+  - root: Expected object, received ${typeof parsed}`
+            );
           }
+          return parsed;
         } catch (error) {
           if (error.code === "ENOENT") {
             logger.debug(`No settings file found at ${settingsPath}, using defaults`);
@@ -357,6 +463,57 @@ ${errorMessages.join("\n")}`
       getProjectRoot(projectRoot) {
         return projectRoot ?? process.cwd();
       }
+      /**
+       * Get global config directory path (~/.config/iloom-ai)
+       */
+      getGlobalConfigDir() {
+        return path.join(os.homedir(), ".config", "iloom-ai");
+      }
+      /**
+       * Get global settings file path (~/.config/iloom-ai/settings.json)
+       */
+      getGlobalSettingsPath() {
+        return path.join(this.getGlobalConfigDir(), "settings.json");
+      }
+      /**
+       * Load and parse global settings file
+       * Returns empty object if file doesn't exist (not an error)
+       * Warns but returns empty object on validation/parse errors (graceful degradation)
+       */
+      async loadGlobalSettingsFile() {
+        const settingsPath = this.getGlobalSettingsPath();
+        try {
+          const content = await readFile(settingsPath, "utf-8");
+          let parsed;
+          try {
+            parsed = JSON.parse(content);
+          } catch (error) {
+            logger.warn(
+              `Failed to parse global settings file at ${settingsPath}: ${error instanceof Error ? error.message : "Invalid JSON"}. Ignoring global settings.`
+            );
+            return {};
+          }
+          try {
+            const validated = IloomSettingsSchemaNoDefaults.strict().parse(parsed);
+            return validated;
+          } catch (error) {
+            if (error instanceof z.ZodError) {
+              const errorMsg = this.formatAllZodErrors(error, "global settings");
+              logger.warn(`${errorMsg.message}. Ignoring global settings.`);
+            } else {
+              logger.warn(`Validation error in global settings: ${error instanceof Error ? error.message : "Unknown error"}. Ignoring global settings.`);
+            }
+            return {};
+          }
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            logger.debug(`No global settings file found at ${settingsPath}`);
+            return {};
+          }
+          logger.warn(`Error reading global settings file at ${settingsPath}: ${error instanceof Error ? error.message : "Unknown error"}. Ignoring global settings.`);
+          return {};
+        }
+      }
       /**
        * Get effective protected branches list with mainBranch always included
        *
@@ -392,7 +549,7 @@ __export(terminal_exports, {
   openMultipleTerminalWindows: () => openMultipleTerminalWindows,
   openTerminalWindow: () => openTerminalWindow
 });
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 import { existsSync } from "fs";
 function detectPlatform() {
   const platform = process.platform;
@@ -413,10 +570,13 @@ async function openTerminalWindow(options) {
       `Terminal window launching not yet supported on ${platform}. Currently only macOS is supported.`
     );
   }
-  const applescript = buildAppleScript(options);
+  const hasITerm2 = await detectITerm2();
+  const applescript = hasITerm2 ? buildITerm2SingleTabScript(options) : buildAppleScript(options);
   try {
-    await execa2("osascript", ["-e", applescript]);
-    await execa2("osascript", ["-e", 'tell application "Terminal" to activate']);
+    await execa3("osascript", ["-e", applescript]);
+    if (!hasITerm2) {
+      await execa3("osascript", ["-e", 'tell application "Terminal" to activate']);
+    }
   } catch (error) {
     throw new Error(
       `Failed to open terminal window: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -465,6 +625,28 @@ function escapePathForAppleScript(path5) {
 function escapeForAppleScript(command) {
   return command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
+function buildITerm2SingleTabScript(options) {
+  const command = buildCommandSequence(options);
+  let script = 'tell application id "com.googlecode.iterm2"\n';
+  script += "  create window with default profile\n";
+  script += "  set s1 to current session of current window\n\n";
+  if (options.backgroundColor) {
+    const { r, g, b } = options.backgroundColor;
+    script += `  set background color of s1 to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
+  }
+  script += `  tell s1 to write text "${escapeForAppleScript(command)}"
+
+`;
+  if (options.title) {
+    script += `  set name of s1 to "${escapeForAppleScript(options.title)}"
+
+`;
+  }
+  script += "  activate\n";
+  script += "end tell";
+  return script;
+}
 function buildCommandSequence(options) {
   const {
     workspacePath,
@@ -561,7 +743,7 @@ async function openMultipleTerminalWindows(optionsArray) {
   if (hasITerm2) {
     const applescript = buildITerm2MultiTabScript(optionsArray);
     try {
-      await execa2("osascript", ["-e", applescript]);
+      await execa3("osascript", ["-e", applescript]);
     } catch (error) {
       throw new Error(
         `Failed to open iTerm2 window: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -600,7 +782,7 @@ __export(color_exports, {
   rgbToHex: () => rgbToHex,
   saturateColor: () => saturateColor
 });
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function getColorPalette() {
   return [
     // First 10 colors preserved for backward compatibility
@@ -707,7 +889,7 @@ function hexToRgb(hex) {
   return { r, g, b };
 }
 function generateColorFromBranchName(branchName) {
-  const hash = createHash("sha256").update(branchName).digest("hex");
+  const hash = createHash2("sha256").update(branchName).digest("hex");
   const hashPrefix = hash.slice(0, 8);
   const palette = getColorPalette();
   const hashAsInt = parseInt(hashPrefix, 16);
@@ -759,349 +941,98 @@ var init_color = __esm({
   }
 });
 
-// src/utils/claude.ts
-var claude_exports = {};
-__export(claude_exports, {
-  detectClaudeCli: () => detectClaudeCli,
-  generateBranchName: () => generateBranchName,
-  getClaudeVersion: () => getClaudeVersion,
-  launchClaude: () => launchClaude,
-  launchClaudeInNewTerminalWindow: () => launchClaudeInNewTerminalWindow
-});
-import { execa as execa3 } from "execa";
-import { existsSync as existsSync2 } from "fs";
-import { join } from "path";
-async function detectClaudeCli() {
-  try {
-    await execa3("command", ["-v", "claude"], {
-      shell: true,
-      timeout: 5e3
-    });
-    return true;
-  } catch (error) {
-    logger.debug("Claude CLI not available", { error });
-    return false;
-  }
-}
-async function getClaudeVersion() {
+// src/lib/WorkspaceManager.ts
+var WorkspaceManager = class {
+  // TODO: Implement in Issue #6
+};
+
+// src/lib/GitWorktreeManager.ts
+import path3 from "path";
+import fs from "fs-extra";
+
+// src/utils/git.ts
+init_logger();
+import path2 from "path";
+import { execa } from "execa";
+async function executeGitCommand(args, options) {
   try {
-    const result = await execa3("claude", ["--version"], {
-      timeout: 5e3
+    const result = await execa("git", args, {
+      cwd: (options == null ? void 0 : options.cwd) ?? process.cwd(),
+      timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
+      encoding: "utf8",
+      stdio: (options == null ? void 0 : options.stdio) ?? "pipe",
+      verbose: logger.isDebugEnabled()
     });
-    return result.stdout.trim();
+    return result.stdout;
   } catch (error) {
-    logger.warn("Failed to get Claude version", { error });
-    return null;
+    const execaError = error;
+    const stderr = execaError.stderr ?? execaError.message ?? "Unknown Git error";
+    throw new Error(`Git command failed: ${stderr}`);
   }
 }
-function parseJsonStreamOutput(output) {
-  try {
-    const lines = output.split("\n").filter((line) => line.trim());
-    let lastResult = "";
-    for (const line of lines) {
-      try {
-        const jsonObj = JSON.parse(line);
-        if (jsonObj && typeof jsonObj === "object" && jsonObj.type === "result" && "result" in jsonObj) {
-          lastResult = jsonObj.result;
-        }
-      } catch {
+function parseWorktreeList(output, defaultBranch) {
+  var _a, _b;
+  const worktrees = [];
+  const lines = output.trim().split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const pathLine = lines[i];
+    if (!(pathLine == null ? void 0 : pathLine.startsWith("worktree "))) {
+      i++;
+      continue;
+    }
+    const pathMatch = pathLine.match(/^worktree (.+)$/);
+    if (!pathMatch) {
+      i++;
+      continue;
+    }
+    let branch = "";
+    let commit = "";
+    let detached = false;
+    let bare = false;
+    let locked = false;
+    let lockReason;
+    i++;
+    while (i < lines.length && !((_a = lines[i]) == null ? void 0 : _a.startsWith("worktree "))) {
+      const line = (_b = lines[i]) == null ? void 0 : _b.trim();
+      if (!line) {
+        i++;
         continue;
       }
+      if (line === "bare") {
+        bare = true;
+        branch = defaultBranch ?? "main";
+      } else if (line === "detached") {
+        detached = true;
+        branch = "HEAD";
+      } else if (line.startsWith("locked")) {
+        locked = true;
+        const lockMatch = line.match(/^locked (.+)$/);
+        lockReason = lockMatch == null ? void 0 : lockMatch[1];
+        branch = branch || "unknown";
+      } else if (line.startsWith("HEAD ")) {
+        const commitMatch = line.match(/^HEAD ([a-f0-9]+)/);
+        if (commitMatch) {
+          commit = commitMatch[1] ?? "";
+        }
+      } else if (line.startsWith("branch ")) {
+        const branchMatch = line.match(/^branch refs\/heads\/(.+)$/);
+        branch = (branchMatch == null ? void 0 : branchMatch[1]) ?? line.replace("branch ", "");
+      }
+      i++;
     }
-    return lastResult || output;
-  } catch {
-    return output;
-  }
-}
-async function launchClaude(prompt, options = {}) {
-  const { model, permissionMode, addDir, headless = false, appendSystemPrompt, mcpConfig, allowedTools, disallowedTools, agents } = options;
-  const args = [];
-  if (headless) {
-    args.push("-p");
-    args.push("--output-format", "stream-json");
-    args.push("--verbose");
-  }
-  if (model) {
-    args.push("--model", model);
-  }
-  if (permissionMode && permissionMode !== "default") {
-    args.push("--permission-mode", permissionMode);
-  }
-  if (addDir) {
-    args.push("--add-dir", addDir);
-  }
-  args.push("--add-dir", "/tmp");
-  if (appendSystemPrompt) {
-    args.push("--append-system-prompt", appendSystemPrompt);
-  }
-  if (mcpConfig && mcpConfig.length > 0) {
-    for (const config of mcpConfig) {
-      args.push("--mcp-config", JSON.stringify(config));
+    const worktree = {
+      path: pathMatch[1] ?? "",
+      branch,
+      commit,
+      bare,
+      detached,
+      locked
+    };
+    if (lockReason !== void 0) {
+      worktree.lockReason = lockReason;
     }
-  }
-  if (allowedTools && allowedTools.length > 0) {
-    args.push("--allowed-tools", ...allowedTools);
-  }
-  if (disallowedTools && disallowedTools.length > 0) {
-    args.push("--disallowed-tools", ...disallowedTools);
-  }
-  if (agents) {
-    args.push("--agents", JSON.stringify(agents));
-  }
-  try {
-    if (headless) {
-      const isDebugMode = logger.isDebugEnabled();
-      const execaOptions = {
-        input: prompt,
-        timeout: 0,
-        // Disable timeout for long responses
-        ...addDir && { cwd: addDir },
-        // Run Claude in the worktree directory
-        verbose: isDebugMode,
-        ...isDebugMode && { stdio: ["pipe", "pipe", "pipe"] }
-        // Enable streaming in debug mode
-      };
-      const subprocess = execa3("claude", args, execaOptions);
-      const isJsonStreamFormat = args.includes("--output-format") && args.includes("stream-json");
-      let outputBuffer = "";
-      let isStreaming = false;
-      let isFirstProgress = true;
-      if (subprocess.stdout && typeof subprocess.stdout.on === "function") {
-        isStreaming = true;
-        subprocess.stdout.on("data", (chunk) => {
-          const text = chunk.toString();
-          outputBuffer += text;
-          if (isDebugMode) {
-            process.stdout.write(text);
-          } else {
-            if (isFirstProgress) {
-              process.stdout.write("\u{1F916} .");
-              isFirstProgress = false;
-            } else {
-              process.stdout.write(".");
-            }
-          }
-        });
-      }
-      const result = await subprocess;
-      if (isStreaming) {
-        const rawOutput = outputBuffer.trim();
-        if (!isDebugMode) {
-          process.stdout.write("\n");
-        }
-        return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
-      } else {
-        if (isDebugMode) {
-          process.stdout.write(result.stdout);
-          if (result.stdout && !result.stdout.endsWith("\n")) {
-            process.stdout.write("\n");
-          }
-        } else {
-          process.stdout.write("\u{1F916} .");
-          process.stdout.write("\n");
-        }
-        const rawOutput = result.stdout.trim();
-        return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
-      }
-    } else {
-      await execa3("claude", [...args, "--", prompt], {
-        ...addDir && { cwd: addDir },
-        stdio: "inherit",
-        // Let user interact directly in current terminal
-        timeout: 0,
-        // Disable timeout
-        verbose: logger.isDebugEnabled()
-      });
-      return;
-    }
-  } catch (error) {
-    const execaError = error;
-    const errorMessage = execaError.stderr ?? execaError.message ?? "Unknown Claude CLI error";
-    throw new Error(`Claude CLI error: ${errorMessage}`);
-  }
-}
-async function launchClaudeInNewTerminalWindow(_prompt, options) {
-  const { workspacePath, branchName, oneShot = "default", port, setArguments, executablePath } = options;
-  if (!workspacePath) {
-    throw new Error("workspacePath is required for terminal window launch");
-  }
-  const { openTerminalWindow: openTerminalWindow2 } = await Promise.resolve().then(() => (init_terminal(), terminal_exports));
-  const executable = executablePath ?? "iloom";
-  let launchCommand = `${executable} spin`;
-  if (oneShot !== "default") {
-    launchCommand += ` --one-shot=${oneShot}`;
-  }
-  if (setArguments && setArguments.length > 0) {
-    for (const setArg of setArguments) {
-      launchCommand += ` --set ${setArg}`;
-    }
-  }
-  let backgroundColor;
-  if (branchName) {
-    try {
-      const { generateColorFromBranchName: generateColorFromBranchName2 } = await Promise.resolve().then(() => (init_color(), color_exports));
-      const colorData = generateColorFromBranchName2(branchName);
-      backgroundColor = colorData.rgb;
-    } catch (error) {
-      logger.warn(
-        `Failed to generate terminal color: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  const hasEnvFile = existsSync2(join(workspacePath, ".env"));
-  await openTerminalWindow2({
-    workspacePath,
-    command: launchCommand,
-    ...backgroundColor && { backgroundColor },
-    includeEnvSetup: hasEnvFile,
-    // source .env only if it exists
-    ...port !== void 0 && { port, includePortExport: true }
-  });
-}
-async function generateBranchName(issueTitle, issueNumber, model = "haiku") {
-  try {
-    const isAvailable = await detectClaudeCli();
-    if (!isAvailable) {
-      logger.warn("Claude CLI not available, using fallback branch name");
-      return `feat/issue-${issueNumber}`;
-    }
-    logger.debug("Generating branch name with Claude", { issueNumber, issueTitle });
-    const prompt = `<Task>
-Generate a git branch name for the following issue:
-<Issue>
-<IssueNumber>${issueNumber}</IssueNumber>
-<IssueTitle>${issueTitle}</IssueTitle>
-</Issue>
-
-<Requirements>
-<IssueNumber>Must use this exact issue number: ${issueNumber}</IssueNumber>
-<Format>Format must be: {prefix}/issue-${issueNumber}-{description}</Format>
-<Prefix>Prefix must be one of: feat, fix, docs, refactor, test, chore</Prefix>
-<MaxLength>Maximum 50 characters total</MaxLength>
-<Characters>Only lowercase letters, numbers, and hyphens allowed</Characters>
-<Output>Reply with ONLY the branch name, nothing else</Output>
-</Requirements>
-</Task>`;
-    logger.debug("Sending prompt to Claude", { prompt });
-    const result = await launchClaude(prompt, {
-      model,
-      headless: true
-    });
-    const branchName = result.trim();
-    logger.debug("Claude returned branch name", { branchName, issueNumber });
-    if (!branchName || !isValidBranchName(branchName, issueNumber)) {
-      logger.warn("Invalid branch name from Claude, using fallback", { branchName });
-      return `feat/issue-${issueNumber}`;
-    }
-    return branchName;
-  } catch (error) {
-    logger.warn("Failed to generate branch name with Claude", { error });
-    return `feat/issue-${issueNumber}`;
-  }
-}
-function isValidBranchName(name, issueNumber) {
-  const pattern = new RegExp(`^(feat|fix|docs|refactor|test|chore)/issue-${issueNumber}-[a-z0-9-]+$`);
-  return pattern.test(name) && name.length <= 50;
-}
-var init_claude = __esm({
-  "src/utils/claude.ts"() {
-    "use strict";
-    init_logger();
-  }
-});
-
-// src/lib/WorkspaceManager.ts
-var WorkspaceManager = class {
-  // TODO: Implement in Issue #6
-};
-
-// src/lib/GitWorktreeManager.ts
-import path3 from "path";
-import fs from "fs-extra";
-
-// src/utils/git.ts
-init_logger();
-import path2 from "path";
-import { execa } from "execa";
-async function executeGitCommand(args, options) {
-  try {
-    const result = await execa("git", args, {
-      cwd: (options == null ? void 0 : options.cwd) ?? process.cwd(),
-      timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
-      encoding: "utf8",
-      stdio: (options == null ? void 0 : options.stdio) ?? "pipe",
-      verbose: logger.isDebugEnabled()
-    });
-    return result.stdout;
-  } catch (error) {
-    const execaError = error;
-    const stderr = execaError.stderr ?? execaError.message ?? "Unknown Git error";
-    throw new Error(`Git command failed: ${stderr}`);
-  }
-}
-function parseWorktreeList(output, defaultBranch) {
-  var _a, _b;
-  const worktrees = [];
-  const lines = output.trim().split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    const pathLine = lines[i];
-    if (!(pathLine == null ? void 0 : pathLine.startsWith("worktree "))) {
-      i++;
-      continue;
-    }
-    const pathMatch = pathLine.match(/^worktree (.+)$/);
-    if (!pathMatch) {
-      i++;
-      continue;
-    }
-    let branch = "";
-    let commit = "";
-    let detached = false;
-    let bare = false;
-    let locked = false;
-    let lockReason;
-    i++;
-    while (i < lines.length && !((_a = lines[i]) == null ? void 0 : _a.startsWith("worktree "))) {
-      const line = (_b = lines[i]) == null ? void 0 : _b.trim();
-      if (!line) {
-        i++;
-        continue;
-      }
-      if (line === "bare") {
-        bare = true;
-        branch = defaultBranch ?? "main";
-      } else if (line === "detached") {
-        detached = true;
-        branch = "HEAD";
-      } else if (line.startsWith("locked")) {
-        locked = true;
-        const lockMatch = line.match(/^locked (.+)$/);
-        lockReason = lockMatch == null ? void 0 : lockMatch[1];
-        branch = branch || "unknown";
-      } else if (line.startsWith("HEAD ")) {
-        const commitMatch = line.match(/^HEAD ([a-f0-9]+)/);
-        if (commitMatch) {
-          commit = commitMatch[1] ?? "";
-        }
-      } else if (line.startsWith("branch ")) {
-        const branchMatch = line.match(/^branch refs\/heads\/(.+)$/);
-        branch = (branchMatch == null ? void 0 : branchMatch[1]) ?? line.replace("branch ", "");
-      }
-      i++;
-    }
-    const worktree = {
-      path: pathMatch[1] ?? "",
-      branch,
-      commit,
-      bare,
-      detached,
-      locked
-    };
-    if (lockReason !== void 0) {
-      worktree.lockReason = lockReason;
-    }
-    worktrees.push(worktree);
+    worktrees.push(worktree);
   }
   return worktrees;
 }
@@ -1144,6 +1075,28 @@ function extractPRNumber(branchName) {
   }
   return null;
 }
+function extractIssueNumber(branchName) {
+  const newFormatPattern = /issue-([^_]+)__/i;
+  const newMatch = branchName.match(newFormatPattern);
+  if (newMatch == null ? void 0 : newMatch[1]) return newMatch[1];
+  const oldFormatPattern = /issue-(\d+)(?:-|$)/i;
+  const oldMatch = branchName.match(oldFormatPattern);
+  if (oldMatch == null ? void 0 : oldMatch[1]) return oldMatch[1];
+  const alphanumericEndPattern = /issue-([^_\s/]+)$/i;
+  const alphanumericMatch = branchName.match(alphanumericEndPattern);
+  if (alphanumericMatch == null ? void 0 : alphanumericMatch[1]) return alphanumericMatch[1];
+  const legacyPatterns = [
+    /issue_(\d+)/i,
+    // issue_42
+    /^(\d+)-/
+    // 42-feature-name
+  ];
+  for (const pattern of legacyPatterns) {
+    const match = branchName.match(pattern);
+    if (match == null ? void 0 : match[1]) return match[1];
+  }
+  return null;
+}
 function isWorktreePath(path5) {
   const worktreePatterns = [
     /\/worktrees?\//i,
@@ -1737,7 +1690,7 @@ var GitWorktreeManager = class {
    */
   async findWorktreeForIssue(issueNumber) {
     const worktrees = await this.listWorktrees({ porcelain: true });
-    const pattern = new RegExp(`(?:^|[/_-])issue-${issueNumber}(?:-|$)`);
+    const pattern = new RegExp(`(?:^|[/_-])issue-${issueNumber}(?:-|__|$)`);
     return worktrees.find((wt) => pattern.test(wt.branch)) ?? null;
   }
   /**
@@ -1811,9 +1764,9 @@ var GitHubError = class extends Error {
 
 // src/utils/github.ts
 init_logger();
-import { execa as execa4 } from "execa";
+import { execa as execa2 } from "execa";
 async function executeGhCommand(args, options) {
-  const result = await execa4("gh", args, {
+  const result = await execa2("gh", args, {
     cwd: (options == null ? void 0 : options.cwd) ?? process.cwd(),
     timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
     encoding: "utf8"
@@ -1955,21 +1908,6 @@ async function updateProjectItemField(itemId, projectId, fieldId, optionId) {
     "json"
   ]);
 }
-var SimpleBranchNameStrategy = class {
-  async generate(issueNumber, title) {
-    const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").substring(0, 20);
-    return `feat/issue-${issueNumber}-${slug}`;
-  }
-};
-var ClaudeBranchNameStrategy = class {
-  constructor(claudeModel = "haiku") {
-    this.claudeModel = claudeModel;
-  }
-  async generate(issueNumber, title) {
-    const { generateBranchName: generateBranchName2 } = await Promise.resolve().then(() => (init_claude(), claude_exports));
-    return generateBranchName2(title, issueNumber, this.claudeModel);
-  }
-};
 async function createIssue(title, body, options) {
   const { repo, labels } = options ?? {};
   logger.debug("Creating GitHub issue", { title, repo, labels });
@@ -1994,7 +1932,7 @@ async function createIssue(title, body, options) {
   if (!repo) {
     execaOptions.cwd = process.cwd();
   }
-  const result = await execa4("gh", args, execaOptions);
+  const result = await execa2("gh", args, execaOptions);
   const urlMatch = result.stdout.trim().match(/https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/);
   if (!(urlMatch == null ? void 0 : urlMatch[1])) {
     throw new Error(`Failed to parse issue URL from gh output: ${result.stdout}`);
@@ -2048,35 +1986,29 @@ async function promptConfirmation(message, defaultValue = false) {
 // src/lib/GitHubService.ts
 var GitHubService = class {
   constructor(options) {
-    if (options == null ? void 0 : options.branchNameStrategy) {
-      this.defaultBranchNameStrategy = options.branchNameStrategy;
-    } else if ((options == null ? void 0 : options.useClaude) !== false) {
-      this.defaultBranchNameStrategy = new ClaudeBranchNameStrategy(
-        options == null ? void 0 : options.claudeModel
-      );
-    } else {
-      this.defaultBranchNameStrategy = new SimpleBranchNameStrategy();
-    }
+    // IssueTracker interface implementation
+    this.providerName = "github";
+    this.supportsPullRequests = true;
     this.prompter = (options == null ? void 0 : options.prompter) ?? promptConfirmation;
   }
-  // Input detection
+  // Input detection - IssueTracker interface implementation
   async detectInputType(input, repo) {
     const numberMatch = input.match(/^#?(\d+)$/);
     if (!(numberMatch == null ? void 0 : numberMatch[1])) {
-      return { type: "unknown", number: null, rawInput: input };
+      return { type: "unknown", identifier: null, rawInput: input };
     }
     const number = parseInt(numberMatch[1], 10);
     logger.debug("Checking if input is a PR", { number });
     const pr = await this.isValidPR(number, repo);
     if (pr) {
-      return { type: "pr", number, rawInput: input };
+      return { type: "pr", identifier: number.toString(), rawInput: input };
     }
     logger.debug("Checking if input is an issue", { number });
     const issue = await this.isValidIssue(number, repo);
     if (issue) {
-      return { type: "issue", number, rawInput: input };
+      return { type: "issue", identifier: number.toString(), rawInput: input };
     }
-    return { type: "unknown", number: null, rawInput: input };
+    return { type: "unknown", identifier: null, rawInput: input };
   }
   // Issue fetching with validation
   async fetchIssue(issueNumber, repo) {
@@ -2170,17 +2102,6 @@ var GitHubService = class {
       }
     }
   }
-  // Branch name generation using strategy pattern
-  async generateBranchName(options) {
-    const { issueNumber, title, strategy } = options;
-    const nameStrategy = strategy ?? this.defaultBranchNameStrategy;
-    logger.debug("Generating branch name", {
-      issueNumber,
-      title,
-      strategy: nameStrategy.constructor.name
-    });
-    return nameStrategy.generate(issueNumber, title);
-  }
   // Issue creation
   async createIssue(title, body, repository, labels) {
     return createIssue(title, body, { repo: repository, labels });
@@ -2315,33 +2236,392 @@ State: ${entity.state}`;
   async promptUserConfirmation(message) {
     return this.prompter(message);
   }
-  // Allow setting strategy at runtime for specific operations
-  setDefaultBranchNameStrategy(strategy) {
-    this.defaultBranchNameStrategy = strategy;
-  }
-  // Get current strategy for testing
-  getBranchNameStrategy() {
-    return this.defaultBranchNameStrategy;
-  }
 };
 
-// src/lib/EnvironmentManager.ts
-init_logger();
-import fs2 from "fs-extra";
+// src/types/linear.ts
+var LinearServiceError = class _LinearServiceError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "LinearServiceError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _LinearServiceError);
+    }
+  }
+};
 
-// src/utils/env.ts
+// src/utils/linear.ts
+import { LinearClient } from "@linear/sdk";
 init_logger();
-import dotenvFlow from "dotenv-flow";
-function parseEnvFile(content) {
-  const envMap = /* @__PURE__ */ new Map();
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine || trimmedLine.startsWith("#")) {
-      continue;
+function slugifyTitle(title, maxLength = 50) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (slug.length <= maxLength) {
+    return slug;
+  }
+  const parts = slug.split("-");
+  let result = "";
+  for (const part of parts) {
+    const candidate = result ? `${result}-${part}` : part;
+    if (candidate.length > maxLength) {
+      break;
     }
-    const cleanLine = trimmedLine.startsWith("export ") ? trimmedLine.substring(7) : trimmedLine;
-    const equalsIndex = cleanLine.indexOf("=");
+    result = candidate;
+  }
+  return result || slug.slice(0, maxLength);
+}
+function buildLinearIssueUrl(identifier, title) {
+  const base = `https://linear.app/issue/${identifier}`;
+  if (title) {
+    const slug = slugifyTitle(title);
+    return slug ? `${base}/${slug}` : base;
+  }
+  return base;
+}
+function getLinearApiToken() {
+  const token = process.env.LINEAR_API_TOKEN;
+  if (!token) {
+    throw new LinearServiceError(
+      "UNAUTHORIZED",
+      "LINEAR_API_TOKEN not set. Configure in settings.local.json or set environment variable."
+    );
+  }
+  return token;
+}
+function createLinearClient() {
+  return new LinearClient({ apiKey: getLinearApiToken() });
+}
+function handleLinearError(error, context) {
+  logger.debug(`${context}: Handling error`, { error });
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (errorMessage.includes("not found") || errorMessage.includes("Not found")) {
+    throw new LinearServiceError("NOT_FOUND", "Linear issue or resource not found", { error });
+  }
+  if (errorMessage.includes("unauthorized") || errorMessage.includes("Unauthorized") || errorMessage.includes("Invalid API key")) {
+    throw new LinearServiceError(
+      "UNAUTHORIZED",
+      "Linear authentication failed. Check LINEAR_API_TOKEN.",
+      { error }
+    );
+  }
+  if (errorMessage.includes("rate limit")) {
+    throw new LinearServiceError("RATE_LIMITED", "Linear API rate limit exceeded", { error });
+  }
+  throw new LinearServiceError("CLI_ERROR", `Linear SDK error: ${errorMessage}`, { error });
+}
+async function fetchLinearIssue(identifier) {
+  try {
+    logger.debug(`Fetching Linear issue: ${identifier}`);
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const result = {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      url: issue.url,
+      createdAt: issue.createdAt.toISOString(),
+      updatedAt: issue.updatedAt.toISOString()
+    };
+    if (issue.description) {
+      result.description = issue.description;
+    }
+    if (issue.state) {
+      const state = await issue.state;
+      if (state == null ? void 0 : state.name) {
+        result.state = state.name;
+      }
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "fetchLinearIssue");
+  }
+}
+async function createLinearIssue(title, body, teamKey, _labels) {
+  try {
+    logger.debug(`Creating Linear issue in team ${teamKey}: ${title}`);
+    const client = createLinearClient();
+    const teams = await client.teams();
+    const team = teams.nodes.find((t) => t.key === teamKey);
+    if (!team) {
+      throw new LinearServiceError("NOT_FOUND", `Linear team ${teamKey} not found`);
+    }
+    const issueInput = {
+      teamId: team.id,
+      title
+    };
+    if (body) {
+      issueInput.description = body;
+    }
+    const payload = await client.createIssue(issueInput);
+    const issue = await payload.issue;
+    if (!issue) {
+      throw new LinearServiceError("CLI_ERROR", "Failed to create Linear issue");
+    }
+    const url = issue.url ?? buildLinearIssueUrl(issue.identifier, title);
+    return {
+      identifier: issue.identifier,
+      url
+    };
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "createLinearIssue");
+  }
+}
+async function updateLinearIssueState(identifier, stateName) {
+  try {
+    logger.debug(`Updating Linear issue ${identifier} state to: ${stateName}`);
+    const client = createLinearClient();
+    const issue = await client.issue(identifier);
+    if (!issue) {
+      throw new LinearServiceError("NOT_FOUND", `Linear issue ${identifier} not found`);
+    }
+    const team = await issue.team;
+    if (!team) {
+      throw new LinearServiceError("CLI_ERROR", "Issue has no team");
+    }
+    const states = await team.states();
+    const state = states.nodes.find((s) => s.name === stateName);
+    if (!state) {
+      throw new LinearServiceError(
+        "NOT_FOUND",
+        `State "${stateName}" not found in team ${team.key}`
+      );
+    }
+    await client.updateIssue(issue.id, {
+      stateId: state.id
+    });
+  } catch (error) {
+    if (error instanceof LinearServiceError) {
+      throw error;
+    }
+    handleLinearError(error, "updateLinearIssueState");
+  }
+}
+
+// src/lib/LinearService.ts
+init_logger();
+var LinearService = class {
+  constructor(config, options) {
+    // IssueTracker interface implementation
+    this.providerName = "linear";
+    this.supportsPullRequests = false;
+    this.config = config ?? {};
+    this.prompter = (options == null ? void 0 : options.prompter) ?? promptConfirmation;
+  }
+  /**
+   * Detect if input matches Linear identifier format (TEAM-NUMBER)
+   * @param input - User input string
+   * @param _repo - Repository (unused for Linear)
+   * @returns Detection result with type and identifier
+   */
+  async detectInputType(input, _repo) {
+    logger.debug(`LinearService.detectInputType called with input: "${input}"`);
+    const linearPattern = /^([A-Z]{2,}-\d+)$/i;
+    const match = input.match(linearPattern);
+    if (!(match == null ? void 0 : match[1])) {
+      logger.debug(`LinearService: Input "${input}" does not match Linear pattern`);
+      return { type: "unknown", identifier: null, rawInput: input };
+    }
+    const identifier = match[1].toUpperCase();
+    logger.debug(`LinearService: Matched Linear identifier: ${identifier}`);
+    logger.debug(`LinearService: Checking if ${identifier} is a valid Linear issue via SDK`);
+    const issue = await this.isValidIssue(identifier);
+    if (issue) {
+      logger.debug(`LinearService: Issue ${identifier} found: "${issue.title}"`);
+      return { type: "issue", identifier, rawInput: input };
+    }
+    logger.debug(`LinearService: Issue ${identifier} NOT found by SDK`);
+    return { type: "unknown", identifier: null, rawInput: input };
+  }
+  /**
+   * Fetch a Linear issue by identifier
+   * @param identifier - Linear issue identifier (string or number)
+   * @param _repo - Repository (unused for Linear)
+   * @returns Generic Issue type
+   * @throws LinearServiceError if issue not found
+   */
+  async fetchIssue(identifier, _repo) {
+    const linearIssue = await fetchLinearIssue(String(identifier));
+    return this.mapLinearIssueToIssue(linearIssue);
+  }
+  /**
+   * Check if an issue identifier is valid (silent validation)
+   * @param identifier - Linear issue identifier
+   * @param _repo - Repository (unused for Linear)
+   * @returns Issue if valid, false if not found
+   */
+  async isValidIssue(identifier, _repo) {
+    try {
+      return await this.fetchIssue(identifier);
+    } catch (error) {
+      if (error instanceof LinearServiceError && error.code === "NOT_FOUND") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Validate issue state and prompt user if closed
+   * @param issue - Issue to validate
+   * @throws LinearServiceError if user cancels due to closed issue
+   */
+  async validateIssueState(issue) {
+    if (issue.state === "closed") {
+      const shouldContinue = await this.prompter(
+        `Issue ${issue.number} is closed. Continue anyway?`
+      );
+      if (!shouldContinue) {
+        throw new LinearServiceError("INVALID_STATE", "User cancelled due to closed issue");
+      }
+    }
+  }
+  /**
+   * Create a new Linear issue
+   * @param title - Issue title
+   * @param body - Issue description (markdown)
+   * @param _repository - Repository (unused for Linear)
+   * @param labels - Optional label names
+   * @returns Created issue identifier and URL
+   * @throws LinearServiceError if teamId not configured or creation fails
+   */
+  async createIssue(title, body, _repository, labels) {
+    if (!this.config.teamId) {
+      throw new LinearServiceError(
+        "INVALID_STATE",
+        "Linear teamId not configured. Run `il init` to configure Linear settings."
+      );
+    }
+    logger.info(`Creating Linear issue in team ${this.config.teamId}: ${title}`);
+    const result = await createLinearIssue(title, body, this.config.teamId, labels);
+    return {
+      number: result.identifier,
+      url: result.url
+    };
+  }
+  /**
+   * Get the web URL for a Linear issue
+   * @param identifier - Linear issue identifier
+   * @param _repo - Repository (unused for Linear)
+   * @returns Issue URL
+   */
+  async getIssueUrl(identifier, _repo) {
+    const issue = await this.fetchIssue(identifier);
+    return issue.url;
+  }
+  /**
+   * Move a Linear issue to "In Progress" state
+   * @param identifier - Linear issue identifier
+   * @throws LinearServiceError if state update fails
+   */
+  async moveIssueToInProgress(identifier) {
+    logger.info(`Moving Linear issue ${identifier} to In Progress`);
+    await updateLinearIssueState(String(identifier), "In Progress");
+  }
+  /**
+   * Extract issue context for AI prompts
+   * @param entity - Issue (Linear doesn't have PRs)
+   * @returns Formatted context string
+   */
+  extractContext(entity) {
+    const issue = entity;
+    return `Linear Issue ${issue.number}: ${issue.title}
+State: ${issue.state}
+
+${issue.body}`;
+  }
+  /**
+   * Map Linear API issue to generic Issue type
+   * @param linear - Linear issue from SDK
+   * @returns Generic Issue type
+   */
+  mapLinearIssueToIssue(linear) {
+    return {
+      number: linear.identifier,
+      // Keep as string (e.g., "ENG-123")
+      title: linear.title,
+      body: linear.description ?? "",
+      state: linear.state ? linear.state.toLowerCase().includes("done") || linear.state.toLowerCase().includes("completed") || linear.state.toLowerCase().includes("canceled") ? "closed" : "open" : "open",
+      labels: [],
+      assignees: [],
+      url: linear.url
+    };
+  }
+};
+
+// src/lib/IssueTrackerFactory.ts
+init_logger();
+var IssueTrackerFactory = class {
+  /**
+   * Create an IssueTracker instance based on settings configuration
+   * Defaults to GitHub if no provider specified
+   *
+   * @param settings - iloom settings containing issueManagement.provider
+   * @returns IssueTracker instance configured for the specified provider
+   * @throws Error if provider type is not supported
+   */
+  static create(settings) {
+    var _a, _b;
+    const provider = ((_a = settings.issueManagement) == null ? void 0 : _a.provider) ?? "github";
+    logger.debug(`IssueTrackerFactory: Creating tracker for provider "${provider}"`);
+    logger.debug(`IssueTrackerFactory: issueManagement settings:`, JSON.stringify(settings.issueManagement, null, 2));
+    switch (provider) {
+      case "github":
+        logger.debug("IssueTrackerFactory: Creating GitHubService");
+        return new GitHubService();
+      case "linear": {
+        const linearSettings = (_b = settings.issueManagement) == null ? void 0 : _b.linear;
+        const linearConfig = {};
+        if (linearSettings == null ? void 0 : linearSettings.teamId) {
+          linearConfig.teamId = linearSettings.teamId;
+        }
+        if (linearSettings == null ? void 0 : linearSettings.branchFormat) {
+          linearConfig.branchFormat = linearSettings.branchFormat;
+        }
+        logger.debug(`IssueTrackerFactory: Creating LinearService with config:`, JSON.stringify(linearConfig, null, 2));
+        return new LinearService(linearConfig);
+      }
+      default:
+        throw new Error(`Unsupported issue tracker provider: ${provider}`);
+    }
+  }
+  /**
+   * Get the configured provider name from settings
+   * Defaults to 'github' if not configured
+   *
+   * @param settings - iloom settings
+   * @returns Provider type string
+   */
+  static getProviderName(settings) {
+    var _a;
+    return ((_a = settings.issueManagement) == null ? void 0 : _a.provider) ?? "github";
+  }
+};
+
+// src/lib/EnvironmentManager.ts
+init_logger();
+import fs2 from "fs-extra";
+
+// src/utils/env.ts
+init_logger();
+import dotenvFlow from "dotenv-flow";
+function parseEnvFile(content) {
+  const envMap = /* @__PURE__ */ new Map();
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    const cleanLine = trimmedLine.startsWith("export ") ? trimmedLine.substring(7) : trimmedLine;
+    const equalsIndex = cleanLine.indexOf("=");
     if (equalsIndex === -1) {
       continue;
     }
@@ -2386,12 +2666,12 @@ function isValidEnvKey(key) {
 }
 
 // src/utils/port.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 function generatePortOffsetFromBranchName(branchName) {
   if (!branchName || branchName.trim().length === 0) {
     throw new Error("Branch name cannot be empty");
   }
-  const hash = createHash2("sha256").update(branchName).digest("hex");
+  const hash = createHash("sha256").update(branchName).digest("hex");
   const hashPrefix = hash.slice(0, 8);
   const hashAsInt = parseInt(hashPrefix, 16);
   const portOffset = hashAsInt % 999 + 1;
@@ -2486,6 +2766,14 @@ var EnvironmentManager = class {
       return /* @__PURE__ */ new Map();
     }
   }
+  /**
+   * Get a specific environment variable from a .env file
+   * Returns null if file doesn't exist or variable is not found
+   */
+  async getEnvVariable(filePath, variableName) {
+    const envVars = await this.readEnvFile(filePath);
+    return envVars.get(variableName) ?? null;
+  }
   /**
    * Generic file copy helper that only copies if source exists
    * Does not throw if source file doesn't exist - just logs and returns
@@ -2509,13 +2797,17 @@ var EnvironmentManager = class {
   calculatePort(options) {
     const basePort = options.basePort ?? 3e3;
     if (options.issueNumber !== void 0) {
-      const port = basePort + options.issueNumber;
-      if (port > 65535) {
-        throw new Error(
-          `Calculated port ${port} exceeds maximum (65535). Use a lower base port or issue number.`
-        );
+      const numericIssue = typeof options.issueNumber === "number" ? options.issueNumber : parseInt(String(options.issueNumber), 10);
+      if (!isNaN(numericIssue) && String(numericIssue) === String(options.issueNumber)) {
+        const port = basePort + numericIssue;
+        if (port > 65535) {
+          throw new Error(
+            `Calculated port ${port} exceeds maximum (65535). Use a lower base port or issue number.`
+          );
+        }
+        return port;
       }
-      return port;
+      return calculatePortForBranch(String(options.issueNumber), basePort);
     }
     if (options.prNumber !== void 0) {
       const port = basePort + options.prNumber;
@@ -2635,8 +2927,9 @@ var DatabaseManager = class {
    * @param branchName - Name of the branch to create
    * @param envFilePath - Path to .env file for configuration checks
    * @param cwd - Optional working directory to run commands from
+   * @param fromBranch - Optional parent branch to create from (for child looms)
    */
-  async createBranchIfConfigured(branchName, envFilePath, cwd) {
+  async createBranchIfConfigured(branchName, envFilePath, cwd, fromBranch) {
     if (!await this.shouldUseDatabaseBranching(envFilePath)) {
       return null;
     }
@@ -2658,7 +2951,7 @@ var DatabaseManager = class {
       throw error;
     }
     try {
-      const connectionString = await this.provider.createBranch(branchName, void 0, cwd);
+      const connectionString = await this.provider.createBranch(branchName, fromBranch, cwd);
       logger3.success(`Database branch ready: ${this.provider.sanitizeBranchName(branchName)}`);
       return connectionString;
     } catch (error) {
@@ -2745,6 +3038,24 @@ var DatabaseManager = class {
       };
     }
   }
+  /**
+   * Get database branch name from connection string (reverse lookup)
+   * Returns branch name if provider supports reverse lookup, null otherwise
+   *
+   * @param connectionString - Database connection string
+   * @param cwd - Optional working directory to run commands from
+   */
+  async getBranchNameFromConnectionString(connectionString, cwd) {
+    if (!this.provider.isConfigured()) {
+      logger3.debug("Provider not configured, skipping reverse lookup");
+      return null;
+    }
+    if ("getBranchNameFromConnectionString" in this.provider && typeof this.provider.getBranchNameFromConnectionString === "function") {
+      return this.provider.getBranchNameFromConnectionString(connectionString, cwd);
+    }
+    logger3.debug("Provider does not support reverse lookup");
+    return null;
+  }
   /**
    * Check if .env has the configured database URL variable
    * CRITICAL: If user explicitly configured a custom variable name (not default),
@@ -2788,8 +3099,187 @@ var DatabaseManager = class {
   }
 };
 
-// src/lib/ClaudeService.ts
-init_claude();
+// src/utils/claude.ts
+init_logger();
+import { execa as execa4 } from "execa";
+import { existsSync as existsSync2 } from "fs";
+import { join } from "path";
+async function detectClaudeCli() {
+  try {
+    await execa4("command", ["-v", "claude"], {
+      shell: true,
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    logger.debug("Claude CLI not available", { error });
+    return false;
+  }
+}
+function parseJsonStreamOutput(output) {
+  try {
+    const lines = output.split("\n").filter((line) => line.trim());
+    let lastResult = "";
+    for (const line of lines) {
+      try {
+        const jsonObj = JSON.parse(line);
+        if (jsonObj && typeof jsonObj === "object" && jsonObj.type === "result" && "result" in jsonObj) {
+          lastResult = jsonObj.result;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return lastResult || output;
+  } catch {
+    return output;
+  }
+}
+async function launchClaude(prompt, options = {}) {
+  const { model, permissionMode, addDir, headless = false, appendSystemPrompt, mcpConfig, allowedTools, disallowedTools, agents } = options;
+  const args = [];
+  if (headless) {
+    args.push("-p");
+    args.push("--output-format", "stream-json");
+    args.push("--verbose");
+  }
+  if (model) {
+    args.push("--model", model);
+  }
+  if (permissionMode && permissionMode !== "default") {
+    args.push("--permission-mode", permissionMode);
+  }
+  if (addDir) {
+    args.push("--add-dir", addDir);
+  }
+  args.push("--add-dir", "/tmp");
+  if (appendSystemPrompt) {
+    args.push("--append-system-prompt", appendSystemPrompt);
+  }
+  if (mcpConfig && mcpConfig.length > 0) {
+    for (const config of mcpConfig) {
+      args.push("--mcp-config", JSON.stringify(config));
+    }
+  }
+  if (allowedTools && allowedTools.length > 0) {
+    args.push("--allowed-tools", ...allowedTools);
+  }
+  if (disallowedTools && disallowedTools.length > 0) {
+    args.push("--disallowed-tools", ...disallowedTools);
+  }
+  if (agents) {
+    args.push("--agents", JSON.stringify(agents));
+  }
+  try {
+    if (headless) {
+      const isDebugMode = logger.isDebugEnabled();
+      const execaOptions = {
+        input: prompt,
+        timeout: 0,
+        // Disable timeout for long responses
+        ...addDir && { cwd: addDir },
+        // Run Claude in the worktree directory
+        verbose: isDebugMode,
+        ...isDebugMode && { stdio: ["pipe", "pipe", "pipe"] }
+        // Enable streaming in debug mode
+      };
+      const subprocess = execa4("claude", args, execaOptions);
+      const isJsonStreamFormat = args.includes("--output-format") && args.includes("stream-json");
+      let outputBuffer = "";
+      let isStreaming = false;
+      let isFirstProgress = true;
+      if (subprocess.stdout && typeof subprocess.stdout.on === "function") {
+        isStreaming = true;
+        subprocess.stdout.on("data", (chunk) => {
+          const text = chunk.toString();
+          outputBuffer += text;
+          if (isDebugMode) {
+            process.stdout.write(text);
+          } else {
+            if (isFirstProgress) {
+              process.stdout.write("\u{1F916} .");
+              isFirstProgress = false;
+            } else {
+              process.stdout.write(".");
+            }
+          }
+        });
+      }
+      const result = await subprocess;
+      if (isStreaming) {
+        const rawOutput = outputBuffer.trim();
+        if (!isDebugMode) {
+          process.stdout.write("\n");
+        }
+        return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
+      } else {
+        if (isDebugMode) {
+          process.stdout.write(result.stdout);
+          if (result.stdout && !result.stdout.endsWith("\n")) {
+            process.stdout.write("\n");
+          }
+        } else {
+          process.stdout.write("\u{1F916} .");
+          process.stdout.write("\n");
+        }
+        const rawOutput = result.stdout.trim();
+        return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
+      }
+    } else {
+      await execa4("claude", [...args, "--", prompt], {
+        ...addDir && { cwd: addDir },
+        stdio: "inherit",
+        // Let user interact directly in current terminal
+        timeout: 0,
+        // Disable timeout
+        verbose: logger.isDebugEnabled()
+      });
+      return;
+    }
+  } catch (error) {
+    const execaError = error;
+    const errorMessage = execaError.stderr ?? execaError.message ?? "Unknown Claude CLI error";
+    throw new Error(`Claude CLI error: ${errorMessage}`);
+  }
+}
+async function launchClaudeInNewTerminalWindow(_prompt, options) {
+  const { workspacePath, branchName, oneShot = "default", port, setArguments, executablePath } = options;
+  if (!workspacePath) {
+    throw new Error("workspacePath is required for terminal window launch");
+  }
+  const { openTerminalWindow: openTerminalWindow2 } = await Promise.resolve().then(() => (init_terminal(), terminal_exports));
+  const executable = executablePath ?? "iloom";
+  let launchCommand = `${executable} spin`;
+  if (oneShot !== "default") {
+    launchCommand += ` --one-shot=${oneShot}`;
+  }
+  if (setArguments && setArguments.length > 0) {
+    for (const setArg of setArguments) {
+      launchCommand += ` --set ${setArg}`;
+    }
+  }
+  let backgroundColor;
+  if (branchName) {
+    try {
+      const { generateColorFromBranchName: generateColorFromBranchName2 } = await Promise.resolve().then(() => (init_color(), color_exports));
+      const colorData = generateColorFromBranchName2(branchName);
+      backgroundColor = colorData.rgb;
+    } catch (error) {
+      logger.warn(
+        `Failed to generate terminal color: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  const hasEnvFile = existsSync2(join(workspacePath, ".env"));
+  await openTerminalWindow2({
+    workspacePath,
+    command: launchCommand,
+    ...backgroundColor && { backgroundColor },
+    includeEnvSetup: hasEnvFile,
+    // source .env only if it exists
+    ...port !== void 0 && { port, includePortExport: true }
+  });
+}
 
 // src/lib/PromptTemplateManager.ts
 init_logger();
@@ -2869,6 +3359,9 @@ var PromptTemplateManager = class {
     if (variables.SETTINGS_SCHEMA !== void 0) {
       result = result.replace(/SETTINGS_SCHEMA/g, variables.SETTINGS_SCHEMA);
     }
+    if (variables.SETTINGS_GLOBAL_JSON !== void 0) {
+      result = result.replace(/SETTINGS_GLOBAL_JSON/g, variables.SETTINGS_GLOBAL_JSON);
+    }
     if (variables.SETTINGS_JSON !== void 0) {
       result = result.replace(/SETTINGS_JSON/g, variables.SETTINGS_JSON);
     }
@@ -2930,6 +3423,12 @@ var PromptTemplateManager = class {
     } else {
       result = result.replace(settingsJsonRegex, "");
     }
+    const settingsGlobalJsonRegex = /\{\{#IF SETTINGS_GLOBAL_JSON\}\}(.*?)\{\{\/IF SETTINGS_GLOBAL_JSON\}\}/gs;
+    if (variables.SETTINGS_GLOBAL_JSON !== void 0 && variables.SETTINGS_GLOBAL_JSON !== "") {
+      result = result.replace(settingsGlobalJsonRegex, "$1");
+    } else {
+      result = result.replace(settingsGlobalJsonRegex, "");
+    }
     const settingsLocalJsonRegex = /\{\{#IF SETTINGS_LOCAL_JSON\}\}(.*?)\{\{\/IF SETTINGS_LOCAL_JSON\}\}/gs;
     if (variables.SETTINGS_LOCAL_JSON !== void 0 && variables.SETTINGS_LOCAL_JSON !== "") {
       result = result.replace(settingsLocalJsonRegex, "$1");
@@ -3090,17 +3589,6 @@ var ClaudeService = class {
       throw error;
     }
   }
-  /**
-   * Generate branch name with Claude, with fallback on failure
-   */
-  async generateBranchNameWithFallback(issueTitle, issueNumber) {
-    try {
-      return await generateBranchName(issueTitle, issueNumber);
-    } catch (error) {
-      logger.warn("Claude branch name generation failed, using fallback", { error });
-      return `feat/issue-${issueNumber}`;
-    }
-  }
 };
 
 // src/lib/ClaudeContextManager.ts
@@ -3160,17 +3648,322 @@ var ClaudeContextManager = class {
 
 // src/utils/index.ts
 init_logger();
+
+// src/utils/linear-markup-converter.ts
+import { appendFileSync } from "fs";
+import { join as join2, dirname, basename, extname } from "path";
+var LinearMarkupConverter = class {
+  /**
+   * Convert HTML details/summary blocks to Linear's collapsible format
+   * Handles nested details blocks recursively
+   *
+   * @param text - Text containing HTML details/summary blocks
+   * @returns Text with details/summary converted to Linear format
+   */
+  static convertDetailsToLinear(text) {
+    if (!text) {
+      return text;
+    }
+    let previousText = "";
+    let currentText = text;
+    while (previousText !== currentText) {
+      previousText = currentText;
+      currentText = this.convertSinglePass(currentText);
+    }
+    return currentText;
+  }
+  /**
+   * Perform a single pass of details block conversion
+   * Converts the innermost details blocks first
+   */
+  static convertSinglePass(text) {
+    const detailsRegex = /<details[^>]*>\s*<summary[^>]*>(.*?)<\/summary>\s*(.*?)\s*<\/details>/gis;
+    return text.replace(detailsRegex, (_match, summary, content) => {
+      const cleanSummary = this.cleanText(summary);
+      const cleanContent = this.cleanContent(content);
+      if (cleanContent) {
+        return `+++ ${cleanSummary}
+
+${cleanContent}
+
++++`;
+      } else {
+        return `+++ ${cleanSummary}
+
++++`;
+      }
+    });
+  }
+  /**
+   * Clean text by trimming whitespace and decoding common HTML entities
+   */
+  static cleanText(text) {
+    return text.trim().replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+  }
+  /**
+   * Clean content while preserving internal structure
+   * - Removes leading/trailing whitespace
+   * - Normalizes internal blank lines (max 2 consecutive newlines)
+   * - Preserves code blocks and other formatting
+   */
+  static cleanContent(content) {
+    if (!content) {
+      return "";
+    }
+    let cleaned = content.trim();
+    cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+    return cleaned;
+  }
+  /**
+   * Check if text contains HTML details/summary blocks
+   * Useful for conditional conversion
+   */
+  static hasDetailsBlocks(text) {
+    if (!text) {
+      return false;
+    }
+    const detailsRegex = /<details[^>]*>.*?<summary[^>]*>.*?<\/summary>.*?<\/details>/is;
+    return detailsRegex.test(text);
+  }
+  /**
+   * Remove wrapper tags from code sample details blocks
+   * Identifies details blocks where summary contains "X lines" pattern
+   * and removes the details/summary tags while preserving the content
+   *
+   * @param text - Text containing potential code sample details blocks
+   * @returns Text with code sample wrappers removed
+   */
+  static removeCodeSampleWrappers(text) {
+    if (!text) {
+      return text;
+    }
+    const codeSampleRegex = /<details[^>]*>\s*<summary[^>]*>([^<]*\d+\s+lines[^<]*)<\/summary>\s*([\s\S]*?)<\/details>/gi;
+    return text.replace(codeSampleRegex, (_match, _summary, content) => {
+      return content.trim();
+    });
+  }
+  /**
+   * Convert text for Linear - applies all necessary conversions
+   * Currently only converts details/summary blocks, but can be extended
+   * for other HTML to Linear markdown conversions
+   */
+  static convertToLinear(text) {
+    if (!text) {
+      return text;
+    }
+    this.logConversion("INPUT", text);
+    let converted = text;
+    converted = this.removeCodeSampleWrappers(converted);
+    converted = this.convertDetailsToLinear(converted);
+    this.logConversion("OUTPUT", converted);
+    return converted;
+  }
+  /**
+   * Log conversion input/output if LINEAR_MARKDOWN_LOG_FILE is set
+   */
+  static logConversion(label, content) {
+    const logFilePath = process.env.LINEAR_MARKDOWN_LOG_FILE;
+    if (!logFilePath) {
+      return;
+    }
+    try {
+      const timestampedPath = this.getTimestampedLogPath(logFilePath);
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const separator = "================================";
+      const logEntry = `${separator}
+[${timestamp}] CONVERSION ${label}
+${separator}
+${label}:
+${content}
+
+`;
+      appendFileSync(timestampedPath, logEntry, "utf-8");
+    } catch {
+    }
+  }
+  /**
+   * Generate timestamped log file path
+   * Example: debug.log -> debug-20231202-161234.log
+   */
+  static getTimestampedLogPath(logFilePath) {
+    const dir = dirname(logFilePath);
+    const ext = extname(logFilePath);
+    const base = basename(logFilePath, ext);
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = [
+      now.getFullYear(),
+      String(now.getMonth() + 1).padStart(2, "0"),
+      String(now.getDate()).padStart(2, "0")
+    ].join("") + "-" + [
+      String(now.getHours()).padStart(2, "0"),
+      String(now.getMinutes()).padStart(2, "0"),
+      String(now.getSeconds()).padStart(2, "0")
+    ].join("");
+    return join2(dir, `${base}-${timestamp}${ext}`);
+  }
+};
+
+// src/utils/table-formatter.ts
+var TableFormatter = class {
+  /**
+   * Pad table headers to achieve equal column widths
+   * @param headers Array of header text
+   * @param options Formatting options
+   * @returns Array of padded headers
+   */
+  static padHeaders(headers, options = {}) {
+    if (!headers || headers.length === 0) {
+      throw new Error("Headers array cannot be empty");
+    }
+    const {
+      targetTotalWidth = this.DEFAULT_TARGET_WIDTH,
+      paddingChar = this.DEFAULT_PADDING_CHAR,
+      maxPadding = this.DEFAULT_MAX_PADDING
+    } = options;
+    const columnCount = headers.length;
+    const targetWidthPerColumn = Math.floor(targetTotalWidth / columnCount);
+    return headers.map((header) => {
+      const currentLength = header.length;
+      const paddingNeeded = Math.max(0, targetWidthPerColumn - currentLength);
+      const cappedPadding = Math.min(paddingNeeded, maxPadding);
+      const padding = paddingChar.repeat(cappedPadding);
+      return header + padding;
+    });
+  }
+  /**
+   * Generate a complete markdown table with padded headers
+   * @param options Table generation options
+   * @returns Complete markdown table string
+   */
+  static generateTable(options) {
+    var _a;
+    const { headers, rows, ...paddingOptions } = options;
+    if (!rows || rows.length === 0) {
+      throw new Error("Table must have at least one row");
+    }
+    const invalidRows = rows.filter((row) => row.length !== headers.length);
+    if (invalidRows.length > 0) {
+      throw new Error(
+        `All rows must have ${headers.length} columns. Found rows with ${(_a = invalidRows[0]) == null ? void 0 : _a.length} columns.`
+      );
+    }
+    const paddedHeaders = this.padHeaders(headers, paddingOptions);
+    const headerRow = `| ${paddedHeaders.join(" | ")} |`;
+    const separators = headers.map(() => "---");
+    const separatorRow = `| ${separators.join(" | ")} |`;
+    const dataRows = rows.map((row) => `| ${row.join(" | ")} |`).join("\n");
+    return [headerRow, separatorRow, dataRows].join("\n");
+  }
+  /**
+   * Calculate the optimal width distribution for given headers
+   * @param headers Array of header text
+   * @param targetTotalWidth Target total width
+   * @param maxPadding Maximum padding entities per column
+   * @returns Width distribution information
+   */
+  static calculateWidthDistribution(headers, targetTotalWidth = this.DEFAULT_TARGET_WIDTH, maxPadding = this.DEFAULT_MAX_PADDING) {
+    if (!headers || headers.length === 0) {
+      throw new Error("Headers array cannot be empty");
+    }
+    const columnCount = headers.length;
+    const widthPerColumn = Math.floor(targetTotalWidth / columnCount);
+    const headerInfo = headers.map((header) => {
+      const paddingNeeded = Math.max(0, widthPerColumn - header.length);
+      const paddingUsed = Math.min(paddingNeeded, maxPadding);
+      return {
+        text: header,
+        currentLength: header.length,
+        targetLength: widthPerColumn,
+        paddingNeeded,
+        paddingUsed
+      };
+    });
+    return {
+      totalWidth: targetTotalWidth,
+      widthPerColumn,
+      headers: headerInfo
+    };
+  }
+  /**
+   * Create a simple two-column assessment table (common pattern)
+   * @param assessmentData Array of [question, answer] pairs
+   * @param options Formatting options
+   * @returns Formatted markdown table
+   */
+  static createAssessmentTable(assessmentData, options = {}) {
+    const headers = ["Question", "Answer"];
+    const rows = assessmentData;
+    return this.generateTable({
+      headers,
+      rows,
+      ...options
+    });
+  }
+  /**
+   * Create a three-column status table (common pattern)
+   * @param statusData Array of [task, status, assignee] tuples
+   * @param options Formatting options
+   * @returns Formatted markdown table
+   */
+  static createStatusTable(statusData, options = {}) {
+    const headers = ["Task", "Status", "Assignee"];
+    const rows = statusData;
+    return this.generateTable({
+      headers,
+      rows,
+      ...options
+    });
+  }
+  /**
+   * Preview table formatting without generating full markdown
+   * Useful for debugging and development
+   * @param headers Array of header text
+   * @param options Formatting options
+   * @returns Human-readable formatting preview
+   */
+  static previewFormatting(headers, options = {}) {
+    const { maxPadding = this.DEFAULT_MAX_PADDING } = options;
+    const distribution = this.calculateWidthDistribution(
+      headers,
+      options.targetTotalWidth,
+      maxPadding
+    );
+    const lines = [
+      `Table Formatting Preview`,
+      `========================`,
+      `Target total width: ${distribution.totalWidth} characters`,
+      `Columns: ${headers.length}`,
+      `Width per column: ${distribution.widthPerColumn} characters`,
+      `Max padding per column: ${maxPadding} entities`,
+      ``
+    ];
+    distribution.headers.forEach((header, index) => {
+      const cappedIndicator = header.paddingUsed < header.paddingNeeded ? " (capped)" : "";
+      lines.push(
+        `Column ${index + 1}: "${header.text}" (${header.currentLength} chars) + ${header.paddingUsed} padding${cappedIndicator} (target: ${header.paddingNeeded}) = ${header.currentLength + header.paddingUsed * 6} total string length`
+      );
+    });
+    return lines.join("\n");
+  }
+};
+TableFormatter.DEFAULT_TARGET_WIDTH = 140;
+TableFormatter.DEFAULT_PADDING_CHAR = "&nbsp;";
+TableFormatter.DEFAULT_MAX_PADDING = 16;
 export {
   ClaudeContextManager,
   DatabaseManager,
   EnvironmentManager,
   GitHubService,
   GitWorktreeManager,
+  IssueTrackerFactory,
+  LinearMarkupConverter,
+  TableFormatter,
   WorkspaceManager,
   branchExists,
   createLogger,
   ensureRepositoryHasCommits,
   executeGitCommand,
+  extractIssueNumber,
   extractPRNumber,
   findAllBranchesForIssue,
   findMainWorktreePath,