@iloom/cli 0.9.2 → 0.10.1

package/dist/chunk-OTGH2HRS.js

@@ -0,0 +1,1427 @@
+#!/usr/bin/env node
+import {
+  buildDependencyMap,
+  fetchChildIssueDetails
+} from "./chunk-QZWEJVWV.js";
+import {
+  IssueManagementProviderFactory
+} from "./chunk-SWSJWA2S.js";
+import {
+  getWorkspacePort
+} from "./chunk-LLHXQS3C.js";
+import {
+  installDependencies
+} from "./chunk-WWKOVDWC.js";
+import {
+  TelemetryService
+} from "./chunk-RSYT7MVI.js";
+import {
+  GitWorktreeManager
+} from "./chunk-I5T677EA.js";
+import {
+  FirstRunManager
+} from "./chunk-Q7POFB5Q.js";
+import {
+  generateAndWriteMcpConfigFile,
+  generateIssueManagementMcpConfig,
+  generateRecapMcpConfig
+} from "./chunk-SKSYYBCU.js";
+import {
+  AgentManager
+} from "./chunk-C6HNNJIV.js";
+import {
+  launchClaude
+} from "./chunk-UR5DGNUO.js";
+import {
+  PromptTemplateManager,
+  buildReviewTemplateVariables
+} from "./chunk-UUEW5KWB.js";
+import {
+  extractSettingsOverrides
+} from "./chunk-GYCR2LOU.js";
+import {
+  extractIssueNumber,
+  findMainWorktreePathWithSettings,
+  generateWorktreePath,
+  getWorktreeRoot,
+  isValidGitRepo
+} from "./chunk-4FGEGQW4.js";
+import {
+  SettingsManager
+} from "./chunk-7VHJNVLF.js";
+import {
+  MetadataManager
+} from "./chunk-KB64WNBZ.js";
+import {
+  IssueTrackerFactory
+} from "./chunk-UKBAJ2QQ.js";
+import {
+  getLogger,
+  withLogger
+} from "./chunk-6MLEBAYZ.js";
+import {
+  createStderrLogger,
+  logger
+} from "./chunk-VT4PDUYT.js";
+
+// src/commands/ignite.ts
+import path4 from "path";
+import fs4 from "fs-extra";
+import { readFile } from "fs/promises";
+
+// src/lib/ClaudeHookManager.ts
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import { parse, modify, applyEdits } from "jsonc-parser";
+import { fileURLToPath } from "url";
+import { accessSync } from "fs";
+var ClaudeHookManager = class {
+  constructor() {
+    this.claudeDir = path.join(os.homedir(), ".claude");
+    this.hooksDir = path.join(this.claudeDir, "hooks");
+    this.settingsPath = path.join(this.claudeDir, "settings.json");
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = fileURLToPath(currentFileUrl);
+    const distDir = path.dirname(currentFilePath);
+    let templateDir = path.join(distDir, "hooks");
+    let currentDir = distDir;
+    while (currentDir !== path.dirname(currentDir)) {
+      const candidatePath = path.join(currentDir, "hooks");
+      try {
+        accessSync(candidatePath);
+        templateDir = candidatePath;
+        break;
+      } catch {
+        currentDir = path.dirname(currentDir);
+      }
+    }
+    this.templateDir = templateDir;
+    logger.debug("ClaudeHookManager initialized", {
+      claudeDir: this.claudeDir,
+      hooksDir: this.hooksDir,
+      settingsPath: this.settingsPath,
+      templateDir: this.templateDir
+    });
+  }
+  /**
+   * Install Claude hooks for VSCode integration
+   *
+   * This is idempotent - safe to call on every spin.
+   * Installs hook script to ~/.claude/hooks/ and merges
+   * hook configuration into ~/.claude/settings.json
+   */
+  async installHooks() {
+    try {
+      await fs.ensureDir(this.hooksDir);
+      await this.installHookScript();
+      await this.mergeHookConfig();
+      logger.debug("Claude hooks installed successfully");
+    } catch (error) {
+      logger.warn(
+        `Failed to install Claude hooks: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Check if hooks are already installed
+   */
+  async isHooksInstalled() {
+    try {
+      const hookScriptPath = path.join(this.hooksDir, "iloom-hook.js");
+      if (!await fs.pathExists(hookScriptPath)) {
+        return false;
+      }
+      if (!await fs.pathExists(this.settingsPath)) {
+        return false;
+      }
+      const content = await fs.readFile(this.settingsPath, "utf8");
+      const errors = [];
+      const settings = parse(content, errors, { allowTrailingComma: true });
+      if (errors.length > 0 || !(settings == null ? void 0 : settings.hooks)) {
+        return false;
+      }
+      return Array.isArray(settings.hooks.SessionStart);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Install the hook script from bundled templates
+   * Skips write if destination already has identical content
+   */
+  async installHookScript() {
+    const sourcePath = path.join(this.templateDir, "iloom-hook.js");
+    const destPath = path.join(this.hooksDir, "iloom-hook.js");
+    if (!await fs.pathExists(sourcePath)) {
+      throw new Error(`Hook template not found at ${sourcePath}`);
+    }
+    if (await fs.pathExists(destPath)) {
+      const [sourceContent, destContent] = await Promise.all([
+        fs.readFile(sourcePath, "utf8"),
+        fs.readFile(destPath, "utf8")
+      ]);
+      if (sourceContent === destContent) {
+        logger.debug("Hook script already up to date, skipping");
+        return;
+      }
+    }
+    await fs.copyFile(sourcePath, destPath);
+    logger.debug("Hook script installed", { sourcePath, destPath });
+  }
+  /**
+   * Merge hook configuration into settings.json
+   * Preserves existing user hooks and comments
+   */
+  async mergeHookConfig() {
+    var _a, _b;
+    await fs.ensureDir(this.claudeDir);
+    let existingContent = "{}";
+    let existingSettings = {};
+    if (await fs.pathExists(this.settingsPath)) {
+      existingContent = await fs.readFile(this.settingsPath, "utf8");
+      const errors = [];
+      existingSettings = parse(existingContent, errors, { allowTrailingComma: true });
+      if (errors.length > 0) {
+        logger.warn("Existing settings.json has parse errors, will attempt to merge anyway");
+      }
+    }
+    const ourHooks = this.getHookConfig();
+    const mergedHooks = { ...existingSettings.hooks ?? {} };
+    let hooksAdded = false;
+    for (const [eventName, eventConfigs] of Object.entries(ourHooks)) {
+      const existing = mergedHooks[eventName] ?? [];
+      const ourConfig = eventConfigs[0];
+      const ourCommand = (_b = (_a = ourConfig == null ? void 0 : ourConfig.hooks) == null ? void 0 : _a[0]) == null ? void 0 : _b.command;
+      const existingConfigIndex = existing.findIndex(
+        (config) => {
+          var _a2;
+          return (_a2 = config.hooks) == null ? void 0 : _a2.some((h) => h.command === ourCommand);
+        }
+      );
+      if (existingConfigIndex === -1) {
+        mergedHooks[eventName] = [...existing, ...eventConfigs];
+        hooksAdded = true;
+      } else {
+        const existingConfig = existing[existingConfigIndex];
+        const ourMatcher = ourConfig == null ? void 0 : ourConfig.matcher;
+        if (existingConfig && ourMatcher !== void 0 && existingConfig.matcher !== ourMatcher) {
+          existing[existingConfigIndex] = {
+            ...existingConfig,
+            matcher: ourMatcher
+          };
+          hooksAdded = true;
+        }
+      }
+    }
+    if (!hooksAdded) {
+      logger.debug("All hooks already registered, skipping settings.json update");
+      return;
+    }
+    let content;
+    if (existingContent.includes("//") || existingContent.includes("/*")) {
+      let modifiedContent = existingContent;
+      const edits = modify(modifiedContent, ["hooks"], mergedHooks, {});
+      content = applyEdits(modifiedContent, edits);
+    } else {
+      const updatedSettings = {
+        ...existingSettings,
+        hooks: mergedHooks
+      };
+      content = JSON.stringify(updatedSettings, null, 2) + "\n";
+    }
+    const tempPath = `${this.settingsPath}.tmp`;
+    await fs.writeFile(tempPath, content, "utf8");
+    await fs.rename(tempPath, this.settingsPath);
+    logger.debug("Hook configuration merged into settings.json");
+  }
+  /**
+   * Get the hook configuration to register
+   *
+   * Each event maps to a hook that runs iloom-hook.js
+   */
+  getHookConfig() {
+    const hookCommand = `node ${path.join(this.hooksDir, "iloom-hook.js")}`;
+    return {
+      Notification: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      Stop: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      SubagentStop: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      PermissionRequest: [
+        { matcher: "*", hooks: [{ type: "command", command: hookCommand, timeout: 86400 }] }
+      ],
+      PreToolUse: [
+        { matcher: "*", hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      PostToolUse: [
+        { matcher: "*", hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      SessionStart: [
+        { matcher: "*", hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      SessionEnd: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      UserPromptSubmit: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ]
+    };
+  }
+};
+
+// src/lib/SwarmSetupService.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+var SwarmSetupService = class {
+  constructor(gitWorktree, metadataManager, agentManager, settingsManager, templateManager) {
+    this.gitWorktree = gitWorktree;
+    this.metadataManager = metadataManager;
+    this.agentManager = agentManager;
+    this.settingsManager = settingsManager;
+    this.templateManager = templateManager;
+  }
+  /**
+   * Create child worktrees for each child issue, branched off the epic branch.
+   * Writes iloom-metadata.json for each child with state: 'pending' and parentLoom.
+   * Generates and writes per-loom MCP config file for each child.
+   *
+   * Uses standard iloom naming conventions via generateWorktreePath().
+   *
+   * @param childIssues - Array of child issues from epic metadata
+   * @param epicBranch - The epic branch name (base branch for children)
+   * @param epicWorktreePath - Path to the epic worktree
+   * @param mainWorktreePath - Path to the main worktree (project root)
+   * @param epicIssueNumber - The parent epic issue number
+   * @param issueTrackerName - The issue tracker provider name (e.g., 'github')
+   * @param settings - Optional settings for MCP config generation
+   * @returns Array of results for each child worktree creation
+   */
+  async createChildWorktrees(childIssues, epicBranch, epicWorktreePath, mainWorktreePath, epicIssueNumber, issueTrackerName, settings) {
+    return Promise.all(childIssues.map(async (child) => {
+      try {
+        const rawId = child.number.replace(/^#/, "");
+        const safeId = rawId.replace(/[^a-zA-Z0-9-_]/g, "-");
+        const childBranch = `issue/${safeId}`;
+        const childWorktreePath = generateWorktreePath(
+          childBranch,
+          mainWorktreePath
+        );
+        getLogger().info(`Creating child worktree for ${child.number}: ${childWorktreePath}...`);
+        await this.gitWorktree.createWorktree({
+          path: childWorktreePath,
+          branch: childBranch,
+          createBranch: true,
+          baseBranch: epicBranch
+        });
+        const metadataInput = {
+          description: child.title,
+          branchName: childBranch,
+          worktreePath: childWorktreePath,
+          issueType: "issue",
+          issue_numbers: [rawId],
+          pr_numbers: [],
+          issueTracker: issueTrackerName,
+          colorHex: "#808080",
+          sessionId: "",
+          // No session - not launching Claude directly
+          projectPath: mainWorktreePath,
+          issueUrls: { [rawId]: child.url },
+          prUrls: {},
+          capabilities: [],
+          state: "pending",
+          parentLoom: {
+            type: "epic",
+            identifier: epicIssueNumber,
+            branchName: epicBranch,
+            worktreePath: epicWorktreePath
+          }
+        };
+        try {
+          await this.metadataManager.writeMetadata(childWorktreePath, metadataInput);
+        } catch (metaError) {
+          getLogger().warn(`Metadata write failed for ${child.number}, cleaning up worktree...`);
+          try {
+            await this.gitWorktree.removeWorktree(childWorktreePath, { force: true });
+          } catch {
+            getLogger().debug(`Could not clean up worktree at ${childWorktreePath}`);
+          }
+          throw metaError;
+        }
+        try {
+          const childMetadata = await this.metadataManager.readMetadata(childWorktreePath);
+          if (childMetadata) {
+            const providerName = IssueTrackerFactory.getProviderName(
+              settings ?? await this.settingsManager.loadSettings()
+            );
+            const mcpConfigPath = await generateAndWriteMcpConfigFile(
+              childWorktreePath,
+              childMetadata,
+              providerName,
+              settings
+            );
+            await this.metadataManager.updateMetadata(childWorktreePath, { mcpConfigPath });
+            const claudeDir = path2.join(childWorktreePath, ".claude");
+            await fs2.ensureDir(claudeDir);
+            await fs2.writeFile(
+              path2.join(claudeDir, "iloom-swarm-mcp-config-path"),
+              mcpConfigPath,
+              "utf-8"
+            );
+            getLogger().debug(`Wrote MCP config for ${child.number}: ${mcpConfigPath}`);
+          }
+        } catch (error) {
+          getLogger().warn(
+            `Failed to write MCP config for child ${child.number}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+        try {
+          await installDependencies(childWorktreePath, true, true);
+        } catch (error) {
+          getLogger().warn(
+            `Failed to install dependencies in child worktree ${child.number}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+        getLogger().success(`Created child worktree for ${child.number}`);
+        return {
+          issueId: rawId,
+          worktreePath: childWorktreePath,
+          branch: childBranch,
+          success: true
+        };
+      } catch (error) {
+        const rawId = child.number.replace(/^#/, "");
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        getLogger().warn(`Failed to create child worktree for ${child.number}: ${errorMessage}`);
+        return {
+          issueId: rawId,
+          worktreePath: "",
+          branch: "",
+          success: false,
+          error: errorMessage
+        };
+      }
+    }));
+  }
+  /**
+   * Render swarm-mode agent templates to the epic worktree's .claude/agents/ directory.
+   *
+   * Phase agent files are written WITHOUT frontmatter (prompt body only) because they are
+   * loaded via `--append-system-prompt-file` which does not parse YAML frontmatter.
+   * Model and tools metadata is extracted from the agent config and returned separately
+   * for use as CLI flags in `claude -p` commands.
+   */
+  async renderSwarmAgents(epicWorktreePath) {
+    var _a, _b;
+    const claudeAgentsDir = path2.join(epicWorktreePath, ".claude", "agents");
+    await fs2.ensureDir(claudeAgentsDir);
+    const settings = await this.settingsManager.loadSettings();
+    const templateVariables = {
+      SWARM_MODE: true
+    };
+    const agents = await this.agentManager.loadAgents(settings, templateVariables);
+    const defaultSwarmModels = {
+      "iloom-issue-analyzer": "opus",
+      "iloom-issue-analyze-and-plan": "opus",
+      "iloom-issue-planner": "sonnet",
+      "iloom-issue-implementer": "sonnet",
+      "iloom-issue-enhancer": "sonnet",
+      "iloom-code-reviewer": "sonnet",
+      "iloom-issue-complexity-evaluator": "haiku"
+    };
+    for (const [agentName, agentConfig] of Object.entries(agents)) {
+      const userSwarmModel = (_b = (_a = settings == null ? void 0 : settings.agents) == null ? void 0 : _a[agentName]) == null ? void 0 : _b.swarmModel;
+      if (userSwarmModel) {
+        agents[agentName] = { ...agentConfig, model: userSwarmModel };
+      } else if (defaultSwarmModels[agentName]) {
+        agents[agentName] = { ...agentConfig, model: defaultSwarmModels[agentName] };
+      }
+    }
+    const renderedFiles = [];
+    const metadata = {};
+    for (const [agentName, agentConfig] of Object.entries(agents)) {
+      const swarmFileName = agentName.startsWith("iloom-") ? `iloom-swarm-${agentName.slice("iloom-".length)}.md` : `iloom-swarm-${agentName}.md`;
+      const agentKey = swarmFileName.replace(".md", "");
+      metadata[agentKey] = {
+        model: agentConfig.model,
+        ...agentConfig.tools && { tools: agentConfig.tools }
+      };
+      const outputPath = path2.join(claudeAgentsDir, swarmFileName);
+      await fs2.writeFile(outputPath, agentConfig.prompt + "\n", "utf-8");
+      renderedFiles.push(swarmFileName);
+      getLogger().debug(`Rendered swarm agent: ${swarmFileName}`);
+    }
+    getLogger().success(`Rendered ${renderedFiles.length} swarm agents to ${claudeAgentsDir}`);
+    return { renderedFiles, metadata };
+  }
+  /**
+   * Render the swarm worker agent file to the epic worktree's .claude/agents/ directory.
+   *
+   * This creates an agent file at `.claude/agents/iloom-swarm-worker.md` containing
+   * the full iloom workflow instructions (rendered from issue-prompt.txt with SWARM_MODE=true).
+   * The orchestrator spawns children with `subagent_type: "iloom-swarm-worker"` so these
+   * instructions become the agent's system prompt (high authority), rather than arriving
+   * as a skill invocation (low authority user message).
+   *
+   * The agent file is shared across all children. Issue-specific context (number, title,
+   * worktree path, body) is provided per-child via the Task prompt from the orchestrator.
+   */
+  async renderSwarmWorkerAgent(epicWorktreePath, agentMetadata) {
+    var _a, _b, _c, _d, _e;
+    const agentsDir = path2.join(epicWorktreePath, ".claude", "agents");
+    const agentOutputPath = path2.join(agentsDir, "iloom-swarm-worker.md");
+    await fs2.ensureDir(agentsDir);
+    try {
+      const settings = await this.settingsManager.loadSettings();
+      const providerType = ((_a = settings == null ? void 0 : settings.issueManagement) == null ? void 0 : _a.provider) ?? "github";
+      const issuePrefix = IssueManagementProviderFactory.create(providerType, settings ?? void 0).issuePrefix;
+      const subAgentTimeoutMinutes = ((_c = (_b = settings == null ? void 0 : settings.agents) == null ? void 0 : _b["iloom-swarm-worker"]) == null ? void 0 : _c.subAgentTimeout) ?? 10;
+      const subAgentTimeoutMs = subAgentTimeoutMinutes * 60 * 1e3;
+      const variables = {
+        SWARM_MODE: true,
+        ONE_SHOT_MODE: true,
+        EPIC_WORKTREE_PATH: epicWorktreePath,
+        ISSUE_PREFIX: issuePrefix,
+        SWARM_SUB_AGENT_TIMEOUT_MS: subAgentTimeoutMs,
+        ...agentMetadata && { SWARM_AGENT_METADATA: JSON.stringify(agentMetadata) },
+        ...buildReviewTemplateVariables(settings == null ? void 0 : settings.agents)
+      };
+      const agentBody = await this.templateManager.getPrompt("issue", variables);
+      const workerModel = ((_e = (_d = settings == null ? void 0 : settings.agents) == null ? void 0 : _d["iloom-swarm-worker"]) == null ? void 0 : _e.model) ?? "opus";
+      const frontmatter = [
+        "---",
+        "name: iloom-swarm-worker",
+        "description: Swarm worker agent that implements a child issue following the full iloom workflow.",
+        `model: ${workerModel}`,
+        "---"
+      ].join("\n");
+      const content = `${frontmatter}
+
+${agentBody}
+`;
+      await fs2.writeFile(agentOutputPath, content, "utf-8");
+      getLogger().success(`Rendered swarm worker agent to ${agentOutputPath}`);
+      return true;
+    } catch (error) {
+      getLogger().warn(
+        `Failed to render swarm worker agent: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      return false;
+    }
+  }
+  /**
+   * Copy .claude/agents/ from the epic worktree to each child worktree.
+   *
+   * Child workers need local access to agent files (used via --append-system-prompt-file).
+   * Without this copy, child worktrees lack the rendered agent files since they only
+   * exist in the epic worktree after renderSwarmAgents/renderSwarmWorkerAgent.
+   */
+  async copyAgentsToChildWorktrees(epicWorktreePath, childWorktrees) {
+    const sourceDir = path2.join(epicWorktreePath, ".claude", "agents");
+    if (!await fs2.pathExists(sourceDir)) {
+      getLogger().warn("No .claude/agents/ directory in epic worktree to copy");
+      return;
+    }
+    const successfulChildren = childWorktrees.filter((c) => c.success);
+    await Promise.all(successfulChildren.map(async (child) => {
+      try {
+        const targetDir = path2.join(child.worktreePath, ".claude", "agents");
+        await fs2.copy(sourceDir, targetDir, { overwrite: true });
+        getLogger().debug(`Copied .claude/agents/ to ${child.worktreePath}`);
+      } catch (error) {
+        getLogger().warn(
+          `Failed to copy agents to child worktree ${child.issueId}: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }));
+    getLogger().success(`Copied agents to ${successfulChildren.length} child worktrees`);
+  }
+  /**
+   * Run the full swarm setup: child worktrees, agents, and worker agent.
+   *
+   * The epic worktree already exists (created by `il start`).
+   */
+  async setupSwarm(epicIssueNumber, epicBranch, epicWorktreePath, childIssues, mainWorktreePath, issueTrackerName, settings) {
+    const childWorktrees = await this.createChildWorktrees(
+      childIssues,
+      epicBranch,
+      epicWorktreePath,
+      mainWorktreePath,
+      epicIssueNumber,
+      issueTrackerName,
+      settings
+    );
+    const { renderedFiles: agentsRendered, metadata: agentMetadata } = await this.renderSwarmAgents(epicWorktreePath);
+    const workerAgentRendered = await this.renderSwarmWorkerAgent(
+      epicWorktreePath,
+      agentMetadata
+    );
+    await this.copyAgentsToChildWorktrees(epicWorktreePath, childWorktrees);
+    const successCount = childWorktrees.filter((c) => c.success).length;
+    const failCount = childWorktrees.filter((c) => !c.success).length;
+    getLogger().success(
+      `Swarm setup complete: ${successCount} child worktrees` + (failCount > 0 ? ` (${failCount} failed)` : "")
+    );
+    return {
+      epicWorktreePath,
+      epicBranch,
+      childWorktrees,
+      agentsRendered,
+      workerAgentRendered
+    };
+  }
+};
+
+// src/utils/language-detector.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import fg from "fast-glob";
+async function detectProjectLanguage(projectPath) {
+  try {
+    const packageJsonPath = path3.join(projectPath, "package.json");
+    if (await fs3.pathExists(packageJsonPath)) {
+      try {
+        const pkg = await fs3.readJson(packageJsonPath);
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return "typescript" in allDeps ? "typescript" : "javascript";
+      } catch {
+        return "javascript";
+      }
+    }
+    if (await fs3.pathExists(path3.join(projectPath, "Cargo.toml"))) {
+      return "rust";
+    }
+    if (await fs3.pathExists(path3.join(projectPath, "go.mod"))) {
+      return "go";
+    }
+    for (const file of ["pyproject.toml", "setup.py", "requirements.txt"]) {
+      if (await fs3.pathExists(path3.join(projectPath, file))) {
+        return "python";
+      }
+    }
+    if (await fs3.pathExists(path3.join(projectPath, "Gemfile"))) {
+      return "ruby";
+    }
+    for (const file of ["pom.xml", "build.gradle", "build.gradle.kts"]) {
+      if (await fs3.pathExists(path3.join(projectPath, file))) {
+        return "java";
+      }
+    }
+    const csprojFiles = await fg("*.csproj", { cwd: projectPath, dot: false });
+    if (csprojFiles.length > 0) {
+      return "csharp";
+    }
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/commands/ignite.ts
+var WorktreeValidationError = class extends Error {
+  constructor(message, suggestion) {
+    super(message);
+    this.suggestion = suggestion;
+    this.name = "WorktreeValidationError";
+  }
+};
+var IgniteCommand = class {
+  constructor(templateManager, gitWorktreeManager, agentManager, settingsManager, firstRunManager, hookManager) {
+    this.templateManager = templateManager ?? new PromptTemplateManager();
+    this.gitWorktreeManager = gitWorktreeManager ?? new GitWorktreeManager();
+    this.agentManager = agentManager ?? new AgentManager();
+    this.settingsManager = settingsManager ?? new SettingsManager();
+    this.firstRunManager = firstRunManager ?? new FirstRunManager("spin");
+    this.hookManager = hookManager ?? new ClaudeHookManager();
+  }
+  /**
+   * Validate that we're not running from the main worktree
+   * @param workspacePath - Optional explicit workspace path; defaults to process.cwd()
+   * @throws WorktreeValidationError if running from main worktree
+   */
+  async validateNotMainWorktree(workspacePath) {
+    const currentDir = workspacePath ?? process.cwd();
+    const isGitRepo = await isValidGitRepo(currentDir);
+    if (!isGitRepo) {
+      return;
+    }
+    const worktreeRoot = await getWorktreeRoot(currentDir);
+    if (!worktreeRoot) {
+      return;
+    }
+    const worktrees = await this.gitWorktreeManager.listWorktrees();
+    const currentWorktree = worktrees.find((wt) => wt.path === worktreeRoot);
+    if (!currentWorktree) {
+      return;
+    }
+    const isMain = await this.gitWorktreeManager.isMainWorktree(currentWorktree, this.settingsManager);
+    if (isMain) {
+      throw new WorktreeValidationError(
+        "You cannot run the command from the main worktree.",
+        "Navigate to a feature worktree created by 'il start <issue>' and run 'il spin' from there."
+      );
+    }
+  }
+  /**
+   * Main entry point for spin command
+   * @param oneShot - One-shot automation mode
+   * @param printOptions - Print mode options for headless/CI execution
+   * @param skipCleanup - Skip cleanup after execution
+   * @param workspacePath - Optional explicit workspace path for programmatic invocation (avoids process.chdir())
+   */
+  async execute(oneShot, printOptions, skipCleanup, workspacePath) {
+    var _a, _b;
+    this.printOptions = printOptions;
+    const isJsonMode = (((_a = this.printOptions) == null ? void 0 : _a.json) ?? false) || (((_b = this.printOptions) == null ? void 0 : _b.jsonStream) ?? false);
+    if (isJsonMode) {
+      const jsonLogger = createStderrLogger();
+      return withLogger(jsonLogger, () => this.executeInternal(oneShot, skipCleanup, workspacePath));
+    }
+    return this.executeInternal(oneShot, skipCleanup, workspacePath);
+  }
+  /**
+   * Internal execution method (separated for withLogger wrapping)
+   */
+  async executeInternal(oneShot, skipCleanup, workspacePath) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+    process.env.ILOOM = "1";
+    try {
+      await this.validateNotMainWorktree(workspacePath);
+    } catch (error) {
+      if (error instanceof WorktreeValidationError) {
+        logger.error(error.message);
+        logger.info(error.suggestion);
+        throw error;
+      }
+      throw error;
+    }
+    try {
+      logger.info("\u{1F680} Your loom is spinning up, please wait...");
+      const isFirstRun = await this.firstRunManager.isFirstRun();
+      if (isFirstRun) {
+        logger.success("Welcome to iloom! Preparing first-time experience...");
+      }
+      await this.hookManager.installHooks();
+      const context = await this.detectWorkspaceContext(workspacePath);
+      logger.debug("Auto-detected workspace context", { context });
+      this.logDetectedContext(context);
+      logger.info("\u{1F4DD} Loading prompt template and preparing Claude...");
+      const metadataManager = new MetadataManager();
+      const metadata = await metadataManager.readMetadata(context.workspacePath);
+      const draftPrNumber = (metadata == null ? void 0 : metadata.draftPrNumber) ?? void 0;
+      const draftPrUrl = draftPrNumber && ((_a = metadata == null ? void 0 : metadata.prUrls) == null ? void 0 : _a[String(draftPrNumber)]) ? metadata.prUrls[String(draftPrNumber)] : void 0;
+      if (((_b = metadata == null ? void 0 : metadata.parentLoom) == null ? void 0 : _b.type) === "epic" && metadata.issueType !== "epic") {
+        throw new WorktreeValidationError(
+          "Cannot run il spin in a child worktree of an epic loom. The swarm orchestrator manages agent execution for these issues.",
+          "Run il spin from the parent epic worktree instead to launch the swarm orchestrator."
+        );
+      }
+      const storedOneShot = (metadata == null ? void 0 : metadata.oneShot) ?? "default";
+      const isHeadlessForOneShot = ((_c = this.printOptions) == null ? void 0 : _c.print) ?? false;
+      const effectiveOneShot = isHeadlessForOneShot ? "noReview" : oneShot ?? storedOneShot;
+      if (!this.settings) {
+        const cliOverrides = extractSettingsOverrides();
+        this.settings = await this.settingsManager.loadSettings(void 0, cliOverrides);
+      }
+      try {
+        const hasNeon = !!((_e = (_d = this.settings) == null ? void 0 : _d.databaseProviders) == null ? void 0 : _e.neon);
+        const language = await detectProjectLanguage(context.workspacePath);
+        TelemetryService.getInstance().track("session.started", {
+          has_neon: hasNeon,
+          language
+        });
+      } catch (error) {
+        logger.debug(`Telemetry session.started tracking failed: ${error instanceof Error ? error.message : error}`);
+      }
+      if (((_f = metadata == null ? void 0 : metadata.capabilities) == null ? void 0 : _f.includes("web")) && context.branchName) {
+        const basePort = ((_i = (_h = (_g = this.settings) == null ? void 0 : _g.capabilities) == null ? void 0 : _h.web) == null ? void 0 : _i.basePort) ?? 3e3;
+        context.port = await getWorkspacePort({
+          basePort,
+          worktreePath: context.workspacePath,
+          worktreeBranch: context.branchName
+        });
+        logger.info(`\u{1F310} Development server port: ${context.port}`);
+      }
+      const isEpicLoom = metadata && metadata.issue_numbers.length > 0 && ((((_j = metadata.childIssues) == null ? void 0 : _j.length) ?? 0) > 0 || metadata.issueType === "epic");
+      if (isEpicLoom && this.settings) {
+        await this.fetchAndStoreEpicChildData(metadataManager, metadata, context.workspacePath, this.settings);
+      }
+      if (isEpicLoom && this.settings) {
+        const freshMetadata = await metadataManager.readMetadata(context.workspacePath);
+        if (freshMetadata && freshMetadata.childIssues.length > 0) {
+          await this.executeSwarmMode(
+            freshMetadata,
+            context.workspacePath,
+            context.branchName ?? "",
+            metadataManager,
+            skipCleanup
+          );
+          return;
+        }
+      }
+      const variables = this.buildTemplateVariables(context, effectiveOneShot, draftPrNumber, draftPrUrl);
+      if (isFirstRun) {
+        variables.FIRST_TIME_USER = true;
+        variables.README_CONTENT = await this.loadReadmeContent();
+        variables.SETTINGS_SCHEMA_CONTENT = await this.loadSettingsSchemaContent();
+      }
+      const systemInstructions = await this.templateManager.getPrompt(context.type, variables);
+      const userPrompt = this.buildUserPrompt(effectiveOneShot);
+      const model = this.settingsManager.getSpinModel(this.settings);
+      let permissionMode = this.getPermissionModeForWorkflow(context.type);
+      if (effectiveOneShot === "bypassPermissions") {
+        permissionMode = "bypassPermissions";
+      }
+      if (permissionMode === "bypassPermissions") {
+        logger.warn(
+          "\u26A0\uFE0F  WARNING: Using bypassPermissions mode - Claude will execute all tool calls without confirmation. This can be dangerous. Use with caution."
+        );
+      }
+      const sessionId = metadata == null ? void 0 : metadata.sessionId;
+      if (!sessionId) {
+        throw new Error("No session ID found in loom metadata. This loom may need to be recreated with `il start`.");
+      }
+      logger.debug("Using session ID from metadata", { sessionId });
+      const isHeadless = ((_k = this.printOptions) == null ? void 0 : _k.print) ?? false;
+      const claudeOptions = {
+        headless: isHeadless,
+        addDir: context.workspacePath,
+        sessionId
+        // Enable Claude Code session resume
+      };
+      if (model !== void 0) {
+        claudeOptions.model = model;
+      }
+      if (isHeadless) {
+        permissionMode = "bypassPermissions";
+      }
+      if (permissionMode !== void 0 && permissionMode !== "default") {
+        claudeOptions.permissionMode = permissionMode;
+      }
+      if (((_l = this.printOptions) == null ? void 0 : _l.outputFormat) !== void 0) {
+        claudeOptions.outputFormat = this.printOptions.outputFormat;
+      }
+      if (((_m = this.printOptions) == null ? void 0 : _m.verbose) !== void 0) {
+        claudeOptions.verbose = this.printOptions.verbose;
+      }
+      if ((_n = this.printOptions) == null ? void 0 : _n.json) {
+        claudeOptions.jsonMode = "json";
+        claudeOptions.outputFormat = "stream-json";
+      } else if ((_o = this.printOptions) == null ? void 0 : _o.jsonStream) {
+        claudeOptions.jsonMode = "stream";
+        claudeOptions.outputFormat = "stream-json";
+      }
+      if (context.branchName !== void 0) {
+        claudeOptions.branchName = context.branchName;
+      }
+      let mcpConfig;
+      let allowedTools;
+      let disallowedTools;
+      if (context.type === "issue" || context.type === "pr") {
+        try {
+          const provider = this.settings ? IssueTrackerFactory.getProviderName(this.settings) : "github";
+          mcpConfig = await generateIssueManagementMcpConfig(context.type, void 0, provider, this.settings, draftPrNumber);
+          logger.debug("Generated MCP configuration for issue management", { provider, draftPrNumber });
+          const baseTools = [
+            "mcp__issue_management__get_issue",
+            "mcp__issue_management__get_comment",
+            "mcp__issue_management__create_comment",
+            "mcp__issue_management__update_comment",
+            "mcp__issue_management__create_issue",
+            "mcp__issue_management__close_issue",
+            "mcp__issue_management__reopen_issue",
+            "mcp__issue_management__edit_issue",
+            "mcp__recap__add_entry",
+            "mcp__recap__get_recap",
+            "mcp__recap__add_artifact",
+            "mcp__recap__set_complexity",
+            "mcp__recap__set_loom_state",
+            "mcp__recap__get_loom_state"
+          ];
+          allowedTools = context.type === "pr" ? [...baseTools, "mcp__issue_management__get_pr", "mcp__issue_management__get_review_comments", "mcp__recap__set_goal"] : baseTools;
+          disallowedTools = ["Bash(gh api:*), Bash(gh issue comment:*)"];
+          logger.debug("Configured tool filtering for issue/PR workflow", { allowedTools, disallowedTools });
+        } catch (error) {
+          logger.warn(`Failed to generate MCP config: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      } else {
+        allowedTools = [
+          "mcp__recap__set_goal",
+          "mcp__recap__add_entry",
+          "mcp__recap__get_recap",
+          "mcp__recap__set_complexity",
+          "mcp__recap__set_loom_state",
+          "mcp__recap__get_loom_state"
+        ];
+        logger.debug("Configured tool filtering for regular workflow", { allowedTools });
+      }
+      try {
+        if (!metadata) {
+          throw new Error("No loom metadata found for this workspace");
+        }
+        const recapMcpConfig = generateRecapMcpConfig(context.workspacePath, metadata);
+        if (mcpConfig) {
+          mcpConfig.push(...recapMcpConfig);
+        } else {
+          mcpConfig = recapMcpConfig;
+        }
+        logger.debug("Generated MCP configuration for recap server");
+      } catch (error) {
+        logger.warn(`Failed to generate recap MCP config: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+      let agents;
+      try {
+        if (((_p = this.settings) == null ? void 0 : _p.agents) && Object.keys(this.settings.agents).length > 0) {
+          logger.debug("Loaded project settings", {
+            agentOverrides: Object.keys(this.settings.agents)
+          });
+        }
+        const loadedAgents = await this.agentManager.loadAgents(
+          this.settings,
+          variables,
+          ["*.md", "!iloom-framework-detector.md"]
+        );
+        agents = this.agentManager.formatForCli(loadedAgents);
+        logger.debug("Loaded agent configurations", {
+          agentCount: Object.keys(agents).length,
+          agentNames: Object.keys(agents)
+        });
+      } catch (error) {
+        logger.warn(`Failed to load agents: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+      logger.debug("Launching Claude in current terminal", {
+        type: context.type,
+        model,
+        permissionMode,
+        workspacePath: context.workspacePath,
+        hasMcpConfig: !!mcpConfig
+      });
+      logger.info(isHeadless ? "\u2728 Launching Claude in headless mode..." : "\u2728 Launching Claude in current terminal...");
+      const claudeResult = await launchClaude(userPrompt, {
+        ...claudeOptions,
+        appendSystemPrompt: systemInstructions,
+        ...mcpConfig && { mcpConfig },
+        ...allowedTools && { allowedTools },
+        ...disallowedTools && { disallowedTools },
+        ...agents && { agents }
+      });
+      if ((_q = this.printOptions) == null ? void 0 : _q.json) {
+        console.log(JSON.stringify({
+          success: true,
+          output: claudeResult ?? ""
+        }));
+      }
+      if (isFirstRun) {
+        await this.firstRunManager.markAsRun();
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      if ((_r = this.printOptions) == null ? void 0 : _r.json) {
+        console.log(JSON.stringify({
+          success: false,
+          error: errorMessage
+        }));
+      } else {
+        logger.error(`Failed to launch Claude: ${errorMessage}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Log user-friendly information about detected context
+   */
+  logDetectedContext(context) {
+    if (context.type === "issue") {
+      logger.info(`\u{1F3AF} Detected issue workflow: Issue #${context.issueNumber}`);
+    } else if (context.type === "pr") {
+      logger.info(`\u{1F504} Detected PR workflow: PR #${context.prNumber}`);
+    } else {
+      logger.info("\u{1F31F} Detected regular workflow");
+    }
+    if (context.branchName) {
+      logger.info(`\u{1F33F} Working on branch: ${context.branchName}`);
+    }
+    if (context.port) {
+      logger.info(`\u{1F310} Development server port: ${context.port}`);
+    }
+  }
+  /**
+   * Build template variables from context
+   */
+  buildTemplateVariables(context, oneShot, draftPrNumber, draftPrUrl) {
+    var _a, _b, _c, _d, _e;
+    const variables = {
+      WORKSPACE_PATH: context.workspacePath
+    };
+    if (context.issueNumber !== void 0) {
+      variables.ISSUE_NUMBER = context.issueNumber;
+    }
+    if (context.prNumber !== void 0) {
+      variables.PR_NUMBER = context.prNumber;
+    }
+    if (context.title !== void 0) {
+      if (context.type === "issue") {
+        variables.ISSUE_TITLE = context.title;
+      } else if (context.type === "pr") {
+        variables.PR_TITLE = context.title;
+      }
+    }
+    if (context.port !== void 0) {
+      variables.PORT = context.port;
+    }
+    if (oneShot === "noReview" || oneShot === "bypassPermissions") {
+      variables.ONE_SHOT_MODE = true;
+    } else {
+      variables.INTERACTIVE_MODE = true;
+    }
+    Object.assign(variables, buildReviewTemplateVariables((_a = this.settings) == null ? void 0 : _a.agents));
+    if (draftPrNumber !== void 0) {
+      variables.DRAFT_PR_MODE = true;
+      variables.DRAFT_PR_NUMBER = draftPrNumber;
+      if (draftPrUrl) {
+        variables.DRAFT_PR_URL = draftPrUrl;
+      }
+      const autoCommitPushEnabled = ((_c = (_b = this.settings) == null ? void 0 : _b.mergeBehavior) == null ? void 0 : _c.autoCommitPush) !== false;
+      variables.AUTO_COMMIT_PUSH = autoCommitPushEnabled;
+      const remote = ((_e = (_d = this.settings) == null ? void 0 : _d.mergeBehavior) == null ? void 0 : _e.remote) ?? "origin";
+      if (!/^[a-zA-Z0-9_-]+$/.test(remote)) {
+        throw new Error(`Invalid git remote name: "${remote}". Remote names can only contain alphanumeric characters, underscores, and hyphens.`);
+      }
+      variables.GIT_REMOTE = remote;
+    } else if (context.type === "regular") {
+      variables.STANDARD_BRANCH_MODE = true;
+    } else {
+      variables.STANDARD_ISSUE_MODE = true;
+    }
+    const isVscodeMode = process.env.ILOOM_VSCODE === "1";
+    variables.IS_VSCODE_MODE = isVscodeMode;
+    return variables;
+  }
+  /**
+   * Get the appropriate permission mode for a workflow type
+   * Same logic as ClaudeService.getPermissionModeForWorkflow()
+   */
+  getPermissionModeForWorkflow(type) {
+    var _a;
+    if ((_a = this.settings) == null ? void 0 : _a.workflows) {
+      const workflowConfig = type === "issue" ? this.settings.workflows.issue : type === "pr" ? this.settings.workflows.pr : this.settings.workflows.regular;
+      if (workflowConfig == null ? void 0 : workflowConfig.permissionMode) {
+        return workflowConfig.permissionMode;
+      }
+    }
+    if (type === "issue") {
+      return "acceptEdits";
+    }
+    return "default";
+  }
+  /**
+   * Auto-detect workspace context from current directory and git branch
+   *
+   * Detection priority:
+   * 1. Directory name patterns (_pr_N, issue-N)
+   * 2. Git branch name patterns
+   * 3. Fallback to 'regular' workflow
+   *
+   * This leverages the same logic as FinishCommand.autoDetectFromCurrentDirectory()
+   */
+  async detectWorkspaceContext(workspacePath) {
+    const workspacePath_ = workspacePath ?? process.cwd();
+    const currentDir = path4.basename(workspacePath_);
+    const prPattern = /_pr_(\d+)$/;
+    const prMatch = currentDir.match(prPattern);
+    if (prMatch == null ? void 0 : prMatch[1]) {
+      const prNumber = parseInt(prMatch[1], 10);
+      logger.debug(`Auto-detected PR #${prNumber} from directory: ${currentDir}`);
+      return this.buildContextForPR(prNumber, workspacePath_);
+    }
+    const issueNumber = extractIssueNumber(currentDir);
+    if (issueNumber !== null) {
+      logger.debug(`Auto-detected issue #${issueNumber} from directory: ${currentDir}`);
+      return this.buildContextForIssue(issueNumber, workspacePath_);
+    }
+    try {
+      const repoInfo = await this.gitWorktreeManager.getRepoInfo();
+      const currentBranch = repoInfo.currentBranch;
+      if (currentBranch) {
+        const branchIssueNumber = extractIssueNumber(currentBranch);
+        if (branchIssueNumber !== null) {
+          logger.debug(`Auto-detected issue #${branchIssueNumber} from branch: ${currentBranch}`);
+          return this.buildContextForIssue(branchIssueNumber, workspacePath_, currentBranch);
+        }
+      }
+    } catch (error) {
+      logger.debug("Could not detect from git branch", { error });
+    }
+    logger.debug("No specific context detected, using regular workflow");
+    return this.buildContextForRegular(workspacePath_);
+  }
+  /**
+   * Build context for issue workflow
+   */
+  async buildContextForIssue(issueNumber, workspacePath, branchName) {
+    if (!branchName) {
+      try {
+        const repoInfo = await this.gitWorktreeManager.getRepoInfo();
+        branchName = repoInfo.currentBranch ?? void 0;
+      } catch {
+      }
+    }
+    const context = {
+      type: "issue",
+      issueNumber,
+      workspacePath,
+      headless: false
+      // Interactive mode
+    };
+    if (branchName !== void 0) {
+      context.branchName = branchName;
+    }
+    return context;
+  }
+  /**
+   * Build context for PR workflow
+   */
+  async buildContextForPR(prNumber, workspacePath) {
+    let branchName;
+    try {
+      const repoInfo = await this.gitWorktreeManager.getRepoInfo();
+      branchName = repoInfo.currentBranch ?? void 0;
+    } catch {
+    }
+    const context = {
+      type: "pr",
+      prNumber,
+      workspacePath,
+      headless: false
+      // Interactive mode
+    };
+    if (branchName !== void 0) {
+      context.branchName = branchName;
+    }
+    return context;
+  }
+  /**
+   * Build context for regular workflow
+   */
+  async buildContextForRegular(workspacePath) {
+    let branchName;
+    try {
+      const repoInfo = await this.gitWorktreeManager.getRepoInfo();
+      branchName = repoInfo.currentBranch ?? void 0;
+    } catch {
+    }
+    const context = {
+      type: "regular",
+      workspacePath,
+      headless: false
+      // Interactive mode
+    };
+    if (branchName !== void 0) {
+      context.branchName = branchName;
+    }
+    return context;
+  }
+  /**
+   * Fetch and store epic child issue data and dependency map in metadata
+   *
+   * Called during spin setup for epic looms. Fetches child issue details
+   * and dependency relationships from the issue tracker, then persists
+   * them in the loom metadata for use by the orchestrator.
+   */
+  async fetchAndStoreEpicChildData(metadataManager, metadata, worktreePath, settings) {
+    const parentIssueNumber = metadata.issue_numbers[0];
+    if (!parentIssueNumber) return;
+    logger.info("Fetching child issue data for epic...");
+    try {
+      const issueTracker = IssueTrackerFactory.create(settings);
+      const childIssueDetails = await fetchChildIssueDetails(
+        parentIssueNumber,
+        issueTracker
+      );
+      if (childIssueDetails.length === 0) {
+        logger.debug("No child issues found for epic");
+        return;
+      }
+      const childIds = childIssueDetails.map((child) => child.number.replace(/^#/, ""));
+      const dependencyMap = await buildDependencyMap(childIds, settings);
+      await metadataManager.updateMetadata(worktreePath, {
+        childIssues: childIssueDetails,
+        dependencyMap
+      });
+      logger.info(`Stored ${childIssueDetails.length} child issues and dependency map in metadata`);
+    } catch (error) {
+      logger.warn(`Failed to fetch epic child data: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Execute swarm mode for an epic loom.
+   *
+   * Creates child worktrees, renders swarm agents/skill, builds the
+   * orchestrator prompt, and launches Claude with agent teams enabled.
+   */
+  async executeSwarmMode(metadata, epicWorktreePath, epicBranch, metadataManager, skipCleanup) {
+    var _a, _b, _c;
+    if (!this.settings) {
+      throw new Error("Settings not loaded. Cannot enter swarm mode.");
+    }
+    const settings = this.settings;
+    const epicIssueNumber = metadata.issue_numbers[0];
+    if (!epicIssueNumber) {
+      throw new Error("Epic loom has no issue number in metadata");
+    }
+    logger.info("Epic loom detected - entering swarm mode...");
+    const mainWorktreePath = await findMainWorktreePathWithSettings();
+    const providerName = IssueTrackerFactory.getProviderName(settings);
+    const swarmSetup = new SwarmSetupService(
+      this.gitWorktreeManager,
+      metadataManager,
+      this.agentManager,
+      this.settingsManager,
+      this.templateManager
+    );
+    try {
+      const epicMcpConfigPath = await generateAndWriteMcpConfigFile(
+        epicWorktreePath,
+        metadata,
+        providerName,
+        settings
+      );
+      await metadataManager.updateMetadata(epicWorktreePath, { mcpConfigPath: epicMcpConfigPath });
+      const epicClaudeDir = path4.join(epicWorktreePath, ".claude");
+      await fs4.ensureDir(epicClaudeDir);
+      await fs4.writeFile(
+        path4.join(epicClaudeDir, "iloom-swarm-mcp-config-path"),
+        epicMcpConfigPath,
+        "utf-8"
+      );
+      logger.debug("Wrote MCP config for epic loom", { epicMcpConfigPath });
+    } catch (error) {
+      logger.warn(`Failed to write MCP config for epic loom: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const mcpConfigs = [];
+    try {
+      const issueMcpConfigs = await generateIssueManagementMcpConfig(
+        "issue",
+        void 0,
+        providerName,
+        settings
+      );
+      mcpConfigs.push(...issueMcpConfigs);
+    } catch (error) {
+      logger.warn(`Failed to generate issue management MCP config: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    try {
+      const recapMcpConfigs = generateRecapMcpConfig(epicWorktreePath, metadata);
+      mcpConfigs.push(...recapMcpConfigs);
+    } catch (error) {
+      logger.warn(`Failed to generate recap MCP config: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const swarmResult = await swarmSetup.setupSwarm(
+      epicIssueNumber,
+      epicBranch,
+      epicWorktreePath,
+      metadata.childIssues,
+      mainWorktreePath,
+      providerName,
+      settings
+    );
+    const successfulWorktrees = swarmResult.childWorktrees.filter((c) => c.success);
+    const worktreeMap = new Map(successfulWorktrees.map((cw) => [cw.issueId, cw]));
+    const childIssuesData = metadata.childIssues.filter((ci) => worktreeMap.has(ci.number.replace(/^#/, ""))).map((ci) => {
+      const rawId = ci.number.replace(/^#/, "");
+      const wt = worktreeMap.get(rawId);
+      return {
+        number: rawId,
+        title: ci.title,
+        body: ci.body,
+        worktreePath: (wt == null ? void 0 : wt.worktreePath) ?? "",
+        branchName: (wt == null ? void 0 : wt.branch) ?? ""
+      };
+    });
+    const epicMetadataPath = metadataManager.getMetadataFilePath(epicWorktreePath);
+    const issuePrefix = providerName === "github" ? "#" : "";
+    const variables = {
+      EPIC_ISSUE_NUMBER: epicIssueNumber,
+      EPIC_WORKTREE_PATH: epicWorktreePath,
+      EPIC_METADATA_PATH: epicMetadataPath,
+      CHILD_ISSUES: JSON.stringify(childIssuesData, null, 2),
+      DEPENDENCY_MAP: JSON.stringify(metadata.dependencyMap, null, 2),
+      ISSUE_PREFIX: issuePrefix,
+      ...skipCleanup && { NO_CLEANUP: true }
+    };
+    const draftPrNumber = metadata.draftPrNumber ?? void 0;
+    if (draftPrNumber !== void 0) {
+      variables.DRAFT_PR_MODE = true;
+      variables.DRAFT_PR_NUMBER = draftPrNumber;
+      const draftPrUrl = (_a = metadata.prUrls) == null ? void 0 : _a[String(draftPrNumber)];
+      if (draftPrUrl) {
+        variables.DRAFT_PR_URL = draftPrUrl;
+      }
+      const autoCommitPushEnabled = ((_b = settings.mergeBehavior) == null ? void 0 : _b.autoCommitPush) !== false;
+      variables.AUTO_COMMIT_PUSH = autoCommitPushEnabled;
+      const remote = ((_c = settings.mergeBehavior) == null ? void 0 : _c.remote) ?? "origin";
+      if (!/^[a-zA-Z0-9_-]+$/.test(remote)) {
+        throw new Error(`Invalid git remote name: "${remote}". Remote names can only contain alphanumeric characters, underscores, and hyphens.`);
+      }
+      variables.GIT_REMOTE = remote;
+    }
+    const orchestratorPrompt = await this.templateManager.getPrompt("swarm-orchestrator", variables);
+    const allowedTools = [
+      "mcp__issue_management__get_issue",
+      "mcp__issue_management__get_comment",
+      "mcp__issue_management__create_comment",
+      "mcp__issue_management__update_comment",
+      "mcp__issue_management__create_issue",
+      "mcp__issue_management__close_issue",
+      "mcp__issue_management__reopen_issue",
+      "mcp__issue_management__edit_issue",
+      "mcp__recap__add_entry",
+      "mcp__recap__get_recap",
+      "mcp__recap__add_artifact",
+      "mcp__recap__set_complexity",
+      "mcp__recap__set_loom_state",
+      "mcp__recap__get_loom_state"
+    ];
+    const model = this.settingsManager.getSpinModel(settings, "swarm");
+    logger.info("Launching swarm orchestrator...");
+    logger.info(`   Model: ${model ?? "default"}`);
+    logger.info(`   Permission mode: bypassPermissions`);
+    logger.info(`   Agent teams: enabled`);
+    logger.info(`   Child worktrees: ${successfulWorktrees.length}`);
+    let agents;
+    try {
+      const loadedAgents = await this.agentManager.loadAgents(
+        settings,
+        variables,
+        ["*.md", "!iloom-framework-detector.md"]
+      );
+      agents = this.agentManager.formatForCli(loadedAgents);
+    } catch (error) {
+      logger.warn(`Failed to load agents: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const swarmStartTime = Date.now();
+    try {
+      TelemetryService.getInstance().track("swarm.started", {
+        child_count: successfulWorktrees.length,
+        tracker: providerName
+      });
+    } catch (error) {
+      logger.debug(`Telemetry swarm.started tracking failed: ${error instanceof Error ? error.message : error}`);
+    }
+    await launchClaude(
+      `You are the swarm orchestrator for epic #${epicIssueNumber}. Begin by reading your system prompt instructions and executing the workflow.`,
+      {
+        model,
+        permissionMode: "bypassPermissions",
+        addDir: epicWorktreePath,
+        headless: false,
+        ...metadata.sessionId && { sessionId: metadata.sessionId },
+        appendSystemPrompt: orchestratorPrompt,
+        mcpConfig: mcpConfigs,
+        allowedTools,
+        ...agents && { agents },
+        env: {
+          CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1",
+          ILOOM_SWARM: "1",
+          ENABLE_TOOL_SEARCH: "auto:30"
+        }
+      }
+    );
+    try {
+      const swarmEndTime = Date.now();
+      let succeeded = 0;
+      let failed = 0;
+      for (const child of successfulWorktrees) {
+        const childMeta = await metadataManager.readMetadata(child.worktreePath);
+        const isSuccess = (childMeta == null ? void 0 : childMeta.state) === "done";
+        if (isSuccess) {
+          succeeded++;
+        } else {
+          failed++;
+        }
+        const parsed = (childMeta == null ? void 0 : childMeta.created_at) ? Date.parse(childMeta.created_at) : NaN;
+        const childCreatedAt = Number.isNaN(parsed) ? swarmStartTime : parsed;
+        const childDuration = Math.max(0, Math.round((swarmEndTime - childCreatedAt) / 6e4));
+        TelemetryService.getInstance().track("swarm.child_completed", {
+          success: isSuccess,
+          duration_minutes: childDuration
+        });
+      }
+      TelemetryService.getInstance().track("swarm.completed", {
+        total_children: successfulWorktrees.length,
+        succeeded,
+        failed,
+        duration_minutes: Math.round((swarmEndTime - swarmStartTime) / 6e4)
+      });
+    } catch (error) {
+      logger.debug(`Telemetry swarm completion tracking failed: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  /**
+   * Build user prompt based on one-shot mode
+   */
+  buildUserPrompt(oneShot = "default") {
+    if (oneShot === "noReview" || oneShot === "bypassPermissions") {
+      return "Guide the user through the iloom workflow! The user has requested you move through the workflow without awaiting confirmation. This supersedes any other guidance.";
+    }
+    return "Guide the user through the iloom workflow!";
+  }
+  /**
+   * Load README.md content for first-time users
+   * Walks up from dist directory to find README.md in project root
+   */
+  async loadReadmeContent() {
+    try {
+      let currentDir = path4.dirname(new URL(import.meta.url).pathname);
+      while (currentDir !== path4.dirname(currentDir)) {
+        const readmePath = path4.join(currentDir, "README.md");
+        try {
+          const content = await readFile(readmePath, "utf-8");
+          logger.debug("Loaded README.md for first-time user", { readmePath });
+          return content;
+        } catch {
+          currentDir = path4.dirname(currentDir);
+        }
+      }
+      logger.debug("README.md not found, returning empty string");
+      return "";
+    } catch (error) {
+      logger.debug(`Failed to load README.md: ${error}`);
+      return "";
+    }
+  }
+  /**
+   * Load settings schema content for first-time users
+   * Walks up from dist directory to find .iloom/README.md
+   */
+  async loadSettingsSchemaContent() {
+    try {
+      let currentDir = path4.dirname(new URL(import.meta.url).pathname);
+      while (currentDir !== path4.dirname(currentDir)) {
+        const schemaPath = path4.join(currentDir, ".iloom", "README.md");
+        try {
+          const content = await readFile(schemaPath, "utf-8");
+          logger.debug("Loaded .iloom/README.md for first-time user", { schemaPath });
+          return content;
+        } catch {
+          currentDir = path4.dirname(currentDir);
+        }
+      }
+      logger.debug(".iloom/README.md not found, returning empty string");
+      return "";
+    } catch (error) {
+      logger.debug(`Failed to load .iloom/README.md: ${error}`);
+      return "";
+    }
+  }
+};
+
+export {
+  WorktreeValidationError,
+  IgniteCommand
+};
+//# sourceMappingURL=chunk-OTGH2HRS.js.map