@iloom/cli 0.11.0 → 0.12.0

package/dist/{chunk-IR74O2F6.js → chunk-PDG74IJT.js}

@@ -2,10 +2,19 @@
 import {
   buildDependencyMap,
   fetchChildIssueDetails
-} from "./chunk-TZNNJLGT.js";
+} from "./chunk-PMB6TYV4.js";
 import {
   preAcceptClaudeTrust
-} from "./chunk-NOMQ5RFG.js";
+} from "./chunk-7UBEHQTP.js";
+import {
+  getWorkspacePort
+} from "./chunk-BFF27W3S.js";
+import {
+  TelemetryService
+} from "./chunk-MY2Q3FJ3.js";
+import {
+  FirstRunManager
+} from "./chunk-EGNUOALL.js";
 import {
   generateAndWriteMcpConfigFile,
   generateIssueManagementMcpConfig,
@@ -13,62 +22,53 @@ import {
   readRecapFile,
   resolveRecapFilePath,
   writeRecapFile
-} from "./chunk-5UFGO4ZT.js";
+} from "./chunk-CQHHEW2M.js";
 import {
-  IssueManagementProviderFactory
-} from "./chunk-RMLADZRY.js";
+  AgentManager
+} from "./chunk-JD3K2344.js";
 import {
-  getWorkspacePort
-} from "./chunk-HLDY5S4C.js";
+  IssueManagementProviderFactory
+} from "./chunk-R7DGN73N.js";
 import {
   installDependencies
-} from "./chunk-3GTUXW26.js";
-import {
-  extractSettingsOverrides
-} from "./chunk-GYCR2LOU.js";
-import {
-  TelemetryService
-} from "./chunk-GMDSYLI6.js";
+} from "./chunk-VIQOQ463.js";
 import {
-  FirstRunManager
-} from "./chunk-SQYHPBFP.js";
+  GitWorktreeManager
+} from "./chunk-FV4KXBGO.js";
 import {
-  AgentManager
-} from "./chunk-VNYWBHKR.js";
+  PromptTemplateManager,
+  buildReviewTemplateVariables
+} from "./chunk-7RCUWU3I.js";
 import {
-  GitWorktreeManager
-} from "./chunk-LE2NOUTN.js";
+  extractSettingsOverrides
+} from "./chunk-GYCR2LOU.js";
 import {
   IssueTrackerFactory
-} from "./chunk-UHIBKD73.js";
+} from "./chunk-35CBWAJL.js";
 import {
   launchClaude
-} from "./chunk-Y3RX7LZT.js";
-import {
-  PromptTemplateManager,
-  buildReviewTemplateVariables
-} from "./chunk-WG4MLJ6J.js";
+} from "./chunk-DDHWZNGL.js";
 import {
   extractIssueNumber,
   findMainWorktreePathWithSettings,
   generateWorktreePath,
   getWorktreeRoot,
   isValidGitRepo
-} from "./chunk-3RXYOBME.js";
+} from "./chunk-OPQC4OWM.js";
 import {
   SettingsManager
-} from "./chunk-ET6A2JR4.js";
+} from "./chunk-653XBU3L.js";
 import {
   MetadataManager
-} from "./chunk-YRCEOQPX.js";
+} from "./chunk-4JZEQBWV.js";
 import {
   getLogger,
   withLogger
-} from "./chunk-ZAXRQLK3.js";
+} from "./chunk-FTYWGQFM.js";
 import {
   createStderrLogger,
   logger
-} from "./chunk-H2SSF24U.js";
+} from "./chunk-VRPPI6GU.js";
 
 // src/commands/ignite.ts
 import path5 from "path";
@@ -419,20 +419,27 @@ var SwarmSetupService = class {
     }));
   }
   /**
-   * Render swarm-mode agent templates to the epic worktree's .claude/agents/ directory.
+   * Render swarm-mode agent templates as custom agent files AND thin skill wrappers.
+   *
+   * For each phase agent, two files are written:
+   * 1. Agent file at `.claude/agents/iloom-swarm-<phase>.md` - contains frontmatter
+   *    (name, description, model) and the full agent prompt as body.
+   * 2. Thin skill wrapper at `.claude/skills/iloom-swarm-<phase>/SKILL.md` - contains
+   *    frontmatter with `agent: iloom-swarm-<phase>` and a minimal body.
    *
-   * 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.
+   * Skills are auto-discovered by Claude Code and invoked via /skill-name syntax.
+   * The agent file carries the real prompt; the skill just delegates to it.
    */
   async renderSwarmAgents(epicWorktreePath) {
     var _a, _b;
+    const claudeSkillsDir = path2.join(epicWorktreePath, ".claude", "skills");
     const claudeAgentsDir = path2.join(epicWorktreePath, ".claude", "agents");
+    await fs2.ensureDir(claudeSkillsDir);
     await fs2.ensureDir(claudeAgentsDir);
     const settings = await this.settingsManager.loadSettings();
     const templateVariables = {
-      SWARM_MODE: true
+      SWARM_MODE: true,
+      EPIC_WORKTREE_PATH: epicWorktreePath
     };
     const agents = await this.agentManager.loadAgents(settings, templateVariables);
     const defaultSwarmModels = {
@@ -452,22 +459,49 @@ var SwarmSetupService = class {
         agents[agentName] = { ...agentConfig, model: defaultSwarmModels[agentName] };
       }
     }
-    const renderedFiles = [];
-    const metadata = {};
+    const renderedSkills = [];
+    const renderedAgents = [];
+    const standaloneAgents = /* @__PURE__ */ new Set(["iloom-wave-verifier"]);
     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}`);
+      if (standaloneAgents.has(agentName)) {
+        continue;
+      }
+      const swarmName = agentName.startsWith("iloom-") ? `iloom-swarm-${agentName.slice("iloom-".length)}` : `iloom-swarm-${agentName}`;
+      const agentFrontmatter = [
+        "---",
+        `name: ${swarmName}`,
+        `description: ${agentConfig.description}`,
+        `model: ${agentConfig.model}`,
+        "---"
+      ].join("\n");
+      const agentContent = `${agentFrontmatter}
+
+${agentConfig.prompt}
+`;
+      await fs2.writeFile(path2.join(claudeAgentsDir, `${swarmName}.md`), agentContent, "utf-8");
+      renderedAgents.push(swarmName);
+      getLogger().debug(`Rendered swarm agent: ${swarmName}`);
+      const skillDir = path2.join(claudeSkillsDir, swarmName);
+      await fs2.ensureDir(skillDir);
+      const skillFrontmatter = [
+        "---",
+        `name: ${swarmName}`,
+        `description: ${agentConfig.description}`,
+        `model: ${agentConfig.model}`,
+        "context: fork",
+        `agent: ${swarmName}`,
+        "---"
+      ].join("\n");
+      const skillContent = `${skillFrontmatter}
+
+Proceed via your system prompt.
+`;
+      await fs2.writeFile(path2.join(skillDir, "SKILL.md"), skillContent, "utf-8");
+      renderedSkills.push(swarmName);
+      getLogger().debug(`Rendered swarm skill wrapper: ${swarmName}`);
     }
-    getLogger().success(`Rendered ${renderedFiles.length} swarm agents to ${claudeAgentsDir}`);
-    return { renderedFiles, metadata };
+    getLogger().success(`Rendered ${renderedAgents.length} swarm agents and ${renderedSkills.length} skill wrappers`);
+    return { renderedSkills, renderedAgents };
   }
   /**
    * Render the swarm worker agent file to the epic worktree's .claude/agents/ directory.
@@ -481,8 +515,8 @@ var SwarmSetupService = class {
    * 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;
+  async renderSwarmWorkerAgent(epicWorktreePath) {
+    var _a, _b, _c;
     const agentsDir = path2.join(epicWorktreePath, ".claude", "agents");
     const agentOutputPath = path2.join(agentsDir, "iloom-swarm-worker.md");
     await fs2.ensureDir(agentsDir);
@@ -490,20 +524,16 @@ var SwarmSetupService = class {
       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,
         COMPLEXITY_OVERRIDE: "simple",
         EPIC_WORKTREE_PATH: epicWorktreePath,
         ISSUE_PREFIX: issuePrefix,
-        SWARM_SUB_AGENT_TIMEOUT_MS: subAgentTimeoutMs,
-        ...agentMetadata && { SWARM_AGENT_METADATA: JSON.stringify(agentMetadata) },
         ...buildReviewTemplateVariables(true, 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 workerModel = ((_c = (_b = settings == null ? void 0 : settings.agents) == null ? void 0 : _b["iloom-swarm-worker"]) == null ? void 0 : _c.model) ?? "sonnet";
       const frontmatter = [
         "---",
         "name: iloom-swarm-worker",
@@ -526,64 +556,108 @@ ${agentBody}
     }
   }
   /**
-   * Copy .claude/agents/ from the epic worktree to each child worktree.
+   * Render the wave verifier agent file to the epic worktree's .claude/agents/ directory.
    *
-   * 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.
+   * This creates an agent file at `.claude/agents/iloom-swarm-wave-verifier.md` WITH frontmatter,
+   * making it available as a custom agent type via `subagent_type: "iloom-swarm-wave-verifier"`.
+   * Unlike phase agents (which are appended as system prompts), the wave verifier is a standalone
+   * agent that the orchestrator spawns directly for verification child issues.
    */
-  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");
+  async renderSwarmWaveVerifierAgent(epicWorktreePath) {
+    var _a, _b;
+    const agentsDir = path2.join(epicWorktreePath, ".claude", "agents");
+    const agentOutputPath = path2.join(agentsDir, "iloom-swarm-wave-verifier.md");
+    await fs2.ensureDir(agentsDir);
+    try {
+      const settings = await this.settingsManager.loadSettings();
+      const templateVariables = {
+        SWARM_MODE: true,
+        EPIC_WORKTREE_PATH: epicWorktreePath
+      };
+      const agents = await this.agentManager.loadAgents(settings, templateVariables, ["iloom-wave-verifier.md"]);
+      const verifierConfig = agents["iloom-wave-verifier"];
+      if (!verifierConfig) {
+        getLogger().debug("No wave verifier agent template found \u2014 skipping");
+        return false;
+      }
+      const verifierModel = ((_b = (_a = settings == null ? void 0 : settings.agents) == null ? void 0 : _a["iloom-wave-verifier"]) == null ? void 0 : _b.model) ?? verifierConfig.model ?? "sonnet";
+      const frontmatter = [
+        "---",
+        "name: iloom-swarm-wave-verifier",
+        `description: ${verifierConfig.description ?? "Wave verification agent that checks must-have criteria after each swarm wave."}`,
+        `model: ${verifierModel}`,
+        ...verifierConfig.tools ? [`tools: ${verifierConfig.tools.join(", ")}`] : [],
+        "---"
+      ].join("\n");
+      const content = `${frontmatter}
+
+${verifierConfig.prompt}
+`;
+      await fs2.writeFile(agentOutputPath, content, "utf-8");
+      getLogger().success(`Rendered wave verifier agent to ${agentOutputPath}`);
+      return true;
+    } catch (error) {
+      getLogger().warn(
+        `Failed to render wave verifier agent: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      return false;
+    }
+  }
+  /**
+   * Copy .claude/agents/ and .claude/skills/ from the epic worktree to each child worktree.
+   *
+   * Child workers need local access to agent files (used as custom agent types) and
+   * skill files (invoked via /skill-name). Without this copy, child worktrees lack
+   * the rendered files since they only exist in the epic worktree after rendering.
+   */
+  async copyAgentsAndSkillsToChildWorktrees(epicWorktreePath, childWorktrees) {
+    const agentsSourceDir = path2.join(epicWorktreePath, ".claude", "agents");
+    const skillsSourceDir = path2.join(epicWorktreePath, ".claude", "skills");
+    const agentsExist = await fs2.pathExists(agentsSourceDir);
+    const skillsExist = await fs2.pathExists(skillsSourceDir);
+    if (!agentsExist && !skillsExist) {
+      getLogger().warn("No .claude/agents/ or .claude/skills/ 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}`);
+        if (agentsExist) {
+          const targetAgentsDir = path2.join(child.worktreePath, ".claude", "agents");
+          await fs2.copy(agentsSourceDir, targetAgentsDir, { overwrite: true });
+          getLogger().debug(`Copied .claude/agents/ to ${child.worktreePath}`);
+        }
+        if (skillsExist) {
+          const targetSkillsDir = path2.join(child.worktreePath, ".claude", "skills");
+          await fs2.copy(skillsSourceDir, targetSkillsDir, { overwrite: true });
+          getLogger().debug(`Copied .claude/skills/ to ${child.worktreePath}`);
+        }
       } catch (error) {
         getLogger().warn(
-          `Failed to copy agents to child worktree ${child.issueId}: ${error instanceof Error ? error.message : "Unknown error"}`
+          `Failed to copy agents/skills to child worktree ${child.issueId}: ${error instanceof Error ? error.message : "Unknown error"}`
         );
       }
     }));
-    getLogger().success(`Copied agents to ${successfulChildren.length} child worktrees`);
+    getLogger().success(`Copied agents and skills to ${successfulChildren.length} child worktrees`);
   }
   /**
-   * Run the full swarm setup: child worktrees, agents, and worker agent.
+   * Run the full swarm setup: render agents, worker agent, and wave verifier.
    *
    * The epic worktree already exists (created by `il start`).
+   * Child worktrees are created on-the-fly by the orchestrator as issues become unblocked.
    */
-  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)` : "")
-    );
+  async setupSwarm(epicBranch, epicWorktreePath) {
+    const { renderedSkills: skillsRendered, renderedAgents } = await this.renderSwarmAgents(epicWorktreePath);
+    const workerAgentRendered = await this.renderSwarmWorkerAgent(epicWorktreePath);
+    const verifierAgentRendered = await this.renderSwarmWaveVerifierAgent(epicWorktreePath);
+    getLogger().success("Swarm setup complete: agents and skills rendered");
     return {
       epicWorktreePath,
       epicBranch,
-      childWorktrees,
-      agentsRendered,
-      workerAgentRendered
+      skillsRendered,
+      renderedAgents,
+      workerAgentRendered,
+      verifierAgentRendered
     };
   }
 };
@@ -635,47 +709,14 @@ async function detectProjectLanguage(projectPath) {
 
 // src/utils/system-prompt-writer.ts
 import path4 from "path";
+import os2 from "os";
+import crypto from "crypto";
 import fs4 from "fs-extra";
-async function prepareSystemPromptForPlatform(systemPrompt, workspacePath, platform = process.platform) {
-  if (platform === "darwin" || platform === "linux") {
-    return { appendSystemPrompt: systemPrompt };
-  }
-  const claudeDir = path4.join(workspacePath, ".claude");
-  const promptFilePath = path4.join(claudeDir, "iloom-system-prompt.md");
-  const pluginDir = path4.join(claudeDir, "iloom-plugin");
-  await fs4.ensureDir(claudeDir);
+async function prepareSystemPromptForPlatform(systemPrompt, workspacePath) {
+  const hash = crypto.createHash("sha256").update(workspacePath).digest("hex").slice(0, 12);
+  const promptFilePath = path4.join(os2.tmpdir(), `iloom-system-prompt-${hash}.md`);
   await fs4.writeFile(promptFilePath, systemPrompt, "utf-8");
-  await createSessionStartPlugin(pluginDir, promptFilePath);
-  return {
-    pluginDir,
-    initialPromptOverride: "/clear"
-  };
-}
-async function createSessionStartPlugin(pluginDir, promptFilePath) {
-  await fs4.ensureDir(pluginDir);
-  const runnerScript = `process.stdout.write(require('fs').readFileSync(${JSON.stringify(promptFilePath)}, 'utf-8'));`;
-  await fs4.writeFile(path4.join(pluginDir, "runner.js"), runnerScript, "utf-8");
-  const portableRunnerPath = path4.join(pluginDir, "runner.js").replace(/\\/g, "/");
-  const hooksConfig = {
-    hooks: {
-      SessionStart: [
-        {
-          matcher: "*",
-          hooks: [
-            {
-              type: "command",
-              command: `node "${portableRunnerPath}"`
-            }
-          ]
-        }
-      ]
-    }
-  };
-  await fs4.writeFile(
-    path4.join(pluginDir, "hooks.json"),
-    JSON.stringify(hooksConfig, null, 2),
-    "utf-8"
-  );
+  return { appendSystemPromptFile: promptFilePath };
 }
 
 // src/commands/ignite.ts
@@ -991,11 +1032,9 @@ var IgniteCommand = class {
         systemInstructions,
         context.workspacePath
       );
-      const effectiveUserPrompt = systemPromptConfig.initialPromptOverride ?? userPrompt;
-      const claudeResult = await launchClaude(effectiveUserPrompt, {
+      const claudeResult = await launchClaude(userPrompt, {
         ...claudeOptions,
-        ...systemPromptConfig.appendSystemPrompt && { appendSystemPrompt: systemPromptConfig.appendSystemPrompt },
-        ...systemPromptConfig.pluginDir && { pluginDir: systemPromptConfig.pluginDir },
+        appendSystemPromptFile: systemPromptConfig.appendSystemPromptFile,
         ...mcpConfig && { mcpConfig },
         ...allowedTools && { allowedTools },
         ...disallowedTools && { disallowedTools },
@@ -1316,6 +1355,9 @@ var IgniteCommand = class {
     const finishedMetadata = await metadataManager.listFinishedMetadata();
     const finishedByIssueNumber = /* @__PURE__ */ new Map();
     for (const meta of finishedMetadata) {
+      if (meta.projectPath && meta.projectPath !== mainWorktreePath) {
+        continue;
+      }
       for (const issueNum of meta.issue_numbers) {
         if (!finishedByIssueNumber.has(issueNum)) {
           finishedByIssueNumber.set(issueNum, meta);
@@ -1341,33 +1383,65 @@ var IgniteCommand = class {
         logger.info(`Skipping child ${skipped.number} (state: ${skipped.state})`);
       }
     }
-    const swarmResult = await swarmSetup.setupSwarm(
-      epicIssueNumber,
+    await swarmSetup.setupSwarm(
       epicBranch,
-      epicWorktreePath,
-      pendingChildIssues,
-      mainWorktreePath,
-      providerName,
-      settings
+      epicWorktreePath
     );
-    const successfulWorktrees = swarmResult.childWorktrees.filter((c) => c.success);
-    const worktreeMap = new Map(successfulWorktrees.map((cw) => [cw.issueId, cw]));
-    const childIssuesData = pendingChildIssues.filter((ci) => worktreeMap.has(ci.number.replace(/^#/, ""))).map((ci) => {
+    const childIssuesData = pendingChildIssues.map((ci) => {
       const rawId = ci.number.replace(/^#/, "");
-      const wt = worktreeMap.get(rawId);
+      const safeId = rawId.replace(/[^a-zA-Z0-9-_]/g, "-");
+      const branchName = `issue/${safeId}`;
+      const worktreePath = generateWorktreePath(branchName, mainWorktreePath);
       return {
         number: rawId,
         title: ci.title,
         body: ci.body,
-        worktreePath: (wt == null ? void 0 : wt.worktreePath) ?? "",
-        branchName: (wt == null ? void 0 : wt.branch) ?? ""
+        worktreePath,
+        branchName
       };
     });
+    for (const child of childIssuesData) {
+      try {
+        await metadataManager.writeMetadata(child.worktreePath, {
+          description: child.title,
+          branchName: child.branchName,
+          worktreePath: child.worktreePath,
+          issueType: "issue",
+          issue_numbers: [child.number],
+          pr_numbers: [],
+          issueTracker: metadata.issueTracker ?? "github",
+          colorHex: "#808080",
+          sessionId: "",
+          projectPath: mainWorktreePath,
+          issueUrls: {},
+          prUrls: {},
+          capabilities: [],
+          state: "pending",
+          parentLoom: {
+            type: "epic",
+            identifier: epicIssueNumber,
+            branchName: epicBranch,
+            worktreePath: epicWorktreePath
+          }
+        });
+        const recapFilePath = resolveRecapFilePath(child.worktreePath);
+        await writeRecapFile(recapFilePath, { goal: child.title });
+      } catch (error) {
+        logger.warn(`Failed to pre-create metadata/recap for child #${child.number}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
     const epicMetadataPath = metadataManager.getMetadataFilePath(epicWorktreePath);
     const issuePrefix = providerName === "github" ? "#" : "";
     const postSwarmReview = ((_a = settings.spin) == null ? void 0 : _a.postSwarmReview) !== false;
+    let swarmTeamName = metadata.swarmTeamName;
+    if (!swarmTeamName) {
+      const projectSlug = path5.basename(mainWorktreePath).replace(/[^a-zA-Z0-9_-]/g, "-");
+      swarmTeamName = `swarm-${projectSlug}-${epicIssueNumber}-${Date.now()}`;
+      await metadataManager.updateMetadata(epicWorktreePath, { swarmTeamName });
+    }
     const variables = {
       EPIC_ISSUE_NUMBER: epicIssueNumber,
+      SWARM_TEAM_NAME: swarmTeamName,
       EPIC_WORKTREE_PATH: epicWorktreePath,
       EPIC_METADATA_PATH: epicMetadataPath,
       CHILD_ISSUES: JSON.stringify(childIssuesData, null, 2),
@@ -1414,7 +1488,7 @@ var IgniteCommand = class {
     logger.info(`   Model: ${model ?? "default"}`);
     logger.info(`   Permission mode: bypassPermissions`);
     logger.info(`   Agent teams: enabled`);
-    logger.info(`   Child worktrees: ${successfulWorktrees.length}`);
+    logger.info(`   Pending child issues: ${pendingChildIssues.length}`);
     let agents;
     try {
       const loadedAgents = await this.agentManager.loadAgents(
@@ -1434,7 +1508,7 @@ var IgniteCommand = class {
     const swarmStartTime = Date.now();
     try {
       TelemetryService.getInstance().track("swarm.started", {
-        child_count: successfulWorktrees.length,
+        child_count: pendingChildIssues.length,
         tracker: providerName
       });
     } catch (error) {
@@ -1444,7 +1518,7 @@ var IgniteCommand = class {
       orchestratorPrompt,
       epicWorktreePath
     );
-    const effectiveSwarmPrompt = orchestratorPromptConfig.initialPromptOverride ?? `You are the swarm orchestrator for epic #${epicIssueNumber}. Begin by reading your system prompt instructions and executing the workflow.`;
+    const swarmUserPrompt = `You are the swarm orchestrator for epic #${epicIssueNumber}. Begin by reading your system prompt instructions and executing the workflow.`;
     process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = "1";
     process.env.ILOOM_SWARM = "1";
     process.env.ENABLE_TOOL_SEARCH = "auto:30";
@@ -1452,14 +1526,13 @@ var IgniteCommand = class {
     process.env.CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
     process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
     process.env.CLAUDE_CODE_EFFORT_LEVEL = "medium";
-    await launchClaude(effectiveSwarmPrompt, {
+    await launchClaude(swarmUserPrompt, {
       model,
       permissionMode: "bypassPermissions",
       addDir: epicWorktreePath,
       headless: false,
       ...metadata.sessionId && { sessionId: metadata.sessionId },
-      ...orchestratorPromptConfig.appendSystemPrompt && { appendSystemPrompt: orchestratorPromptConfig.appendSystemPrompt },
-      ...orchestratorPromptConfig.pluginDir && { pluginDir: orchestratorPromptConfig.pluginDir },
+      appendSystemPromptFile: orchestratorPromptConfig.appendSystemPromptFile,
       mcpConfig: mcpConfigs,
       allowedTools,
       ...agents && { agents }
@@ -1468,8 +1541,12 @@ var IgniteCommand = class {
       const swarmEndTime = Date.now();
       let succeeded = 0;
       let failed = 0;
-      for (const child of successfulWorktrees) {
-        const childMeta = await metadataManager.readMetadata(child.worktreePath);
+      for (const child of pendingChildIssues) {
+        const rawId = child.number.replace(/^#/, "");
+        const safeId = rawId.replace(/[^a-zA-Z0-9-_]/g, "-");
+        const childBranch = `issue/${safeId}`;
+        const childWorktreePath = generateWorktreePath(childBranch, mainWorktreePath);
+        const childMeta = await metadataManager.readMetadata(childWorktreePath);
         const isSuccess = (childMeta == null ? void 0 : childMeta.state) === "done";
         if (isSuccess) {
           succeeded++;
@@ -1485,7 +1562,7 @@ var IgniteCommand = class {
         });
       }
       TelemetryService.getInstance().track("swarm.completed", {
-        total_children: successfulWorktrees.length,
+        total_children: pendingChildIssues.length,
         succeeded,
         failed,
         duration_minutes: Math.round((swarmEndTime - swarmStartTime) / 6e4)
@@ -1557,4 +1634,4 @@ export {
   WorktreeValidationError,
   IgniteCommand
 };
-//# sourceMappingURL=chunk-IR74O2F6.js.map
+//# sourceMappingURL=chunk-PDG74IJT.js.map