karajan-code 1.45.0 → 1.46.0

package/README.md

@@ -90,7 +90,7 @@ This is the primary use case. Karajan runs as an MCP server inside Claude Code,
 You → Claude Code → kj_run (via MCP) → triage → coder → sonar → reviewer → tester → security
 ```
 
-The MCP server auto-registers during `npm install`. Your AI agent sees 21 tools (`kj_run`, `kj_code`, `kj_review`, etc.) and uses them as needed.
+The MCP server auto-registers during `npm install`. Your AI agent sees 23 tools (`kj_run`, `kj_code`, `kj_review`, etc.) and uses them as needed.
 
 **The problem**: when Karajan runs inside an AI agent, you lose visibility. The agent shows you the final result, but not the pipeline stages, iterations, or Solomon decisions happening in real time.
 
@@ -177,7 +177,7 @@ hu-reviewer? → triage → discover? → architect? → planner? → coder →
 
 Mix and match. Use Claude as coder and Codex as reviewer. Karajan auto-detects installed agents during `kj init`.
 
-## MCP server (21 tools)
+## MCP server (23 tools)
 
 After `npm install -g karajan-code`, the MCP server auto-registers in Claude and Codex. Manual config if needed:
 
@@ -189,7 +189,7 @@ After `npm install -g karajan-code`, the MCP server auto-registers in Claude and
 # command = "karajan-mcp"
 ```
 
-**21 tools** available: `kj_run`, `kj_code`, `kj_review`, `kj_plan`, `kj_audit`, `kj_scan`, `kj_doctor`, `kj_config`, `kj_report`, `kj_resume`, `kj_roles`, `kj_agents`, `kj_preflight`, `kj_status`, `kj_init`, `kj_discover`, `kj_triage`, `kj_researcher`, `kj_architect`, `kj_impeccable`, `kj_hu`.
+**23 tools** available: `kj_run`, `kj_code`, `kj_review`, `kj_plan`, `kj_audit`, `kj_scan`, `kj_doctor`, `kj_config`, `kj_report`, `kj_resume`, `kj_roles`, `kj_agents`, `kj_preflight`, `kj_status`, `kj_init`, `kj_discover`, `kj_triage`, `kj_researcher`, `kj_architect`, `kj_impeccable`, `kj_hu`, `kj_skills`, `kj_suggest`.
 
 Use `kj-tail` in a separate terminal to see what the pipeline is doing in real time (see [Three ways to use Karajan](#three-ways-to-use-karajan)).
 
@@ -243,7 +243,7 @@ Not nostalgia, not stubbornness. I've been using JavaScript since 1997, when Bre
 git clone https://github.com/manufosela/karajan-code.git
 cd karajan-code
 npm install
-npm test              # Run 2142 tests with Vitest
+npm test              # Run 2318 tests with Vitest
 npm run validate      # Lint + test
 ```
 

package/docs/README.es.md

@@ -82,7 +82,7 @@ Este es el caso de uso principal. Karajan corre como servidor MCP dentro de Clau
 Tu → Claude Code → kj_run (via MCP) → triage → coder → sonar → reviewer → tester → security
 ```
 
-El servidor MCP se auto-registra durante `npm install`. Tu agente de IA ve 21 herramientas (`kj_run`, `kj_code`, `kj_review`, `kj_hu`, etc.) y las usa segun necesite.
+El servidor MCP se auto-registra durante `npm install`. Tu agente de IA ve 23 herramientas (`kj_run`, `kj_code`, `kj_review`, `kj_hu`, etc.) y las usa segun necesite.
 
 **El problema**: cuando Karajan corre dentro de un agente de IA, pierdes visibilidad. El agente te muestra el resultado final, pero no las etapas del pipeline, iteraciones o decisiones de Solomon en tiempo real.
 
@@ -147,7 +147,7 @@ hu-reviewer? → triage → discover? → architect? → planner? → coder →
 
 Mezcla y combina. Usa Claude como coder y Codex como reviewer. Karajan auto-detecta agentes instalados durante `kj init`.
 
-## Servidor MCP (21 herramientas)
+## Servidor MCP (23 herramientas)
 
 Tras `npm install -g karajan-code`, el servidor MCP se auto-registra en Claude y Codex. Config manual si es necesario:
 
@@ -159,7 +159,7 @@ Tras `npm install -g karajan-code`, el servidor MCP se auto-registra en Claude y
 # command = "karajan-mcp"
 ```
 
-**21 herramientas** disponibles: `kj_run`, `kj_code`, `kj_review`, `kj_plan`, `kj_audit`, `kj_scan`, `kj_doctor`, `kj_config`, `kj_report`, `kj_resume`, `kj_roles`, `kj_agents`, `kj_preflight`, `kj_status`, `kj_init`, `kj_discover`, `kj_triage`, `kj_researcher`, `kj_architect`, `kj_impeccable`, `kj_hu`.
+**23 herramientas** disponibles: `kj_run`, `kj_code`, `kj_review`, `kj_plan`, `kj_audit`, `kj_scan`, `kj_doctor`, `kj_config`, `kj_report`, `kj_resume`, `kj_roles`, `kj_agents`, `kj_preflight`, `kj_status`, `kj_init`, `kj_discover`, `kj_triage`, `kj_researcher`, `kj_architect`, `kj_impeccable`, `kj_hu`, `kj_skills`, `kj_suggest`.
 
 Usa `kj-tail` en un terminal separado para ver lo que el pipeline esta haciendo en tiempo real (ver [Tres formas de usar Karajan](#tres-formas-de-usar-karajan)).
 
@@ -213,7 +213,7 @@ No es nostalgia ni cabezoneria. Es que llevo usando JavaScript desde 1997, cuand
 git clone https://github.com/manufosela/karajan-code.git
 cd karajan-code
 npm install
-npm test              # Ejecutar 2142 tests con Vitest
+npm test              # Ejecutar 2318 tests con Vitest
 npm run validate      # Lint + test
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "1.45.0",
+  "version": "1.46.0",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",

package/scripts/build-sea.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+/**
+ * build-sea.mjs — Build a Node.js Single Executable Application (SEA) binary.
+ *
+ * Steps:
+ *   1. esbuild bundles src/cli.js -> dist/kj-bundle.cjs (CJS, all deps inlined)
+ *   2. Generate SEA preparation blob via node --experimental-sea-config
+ *   3. Copy the current node binary to dist/kj (or dist/kj.exe on Windows)
+ *   4. Inject the blob into the binary with postject
+ *   5. (macOS only) Re-sign the binary with ad-hoc signature
+ *
+ * Requirements (installed globally or via npx):
+ *   - esbuild
+ *   - postject
+ *
+ * Usage:
+ *   node scripts/build-sea.mjs
+ */
+
+import { execSync } from "node:child_process";
+import { cpSync, mkdirSync, writeFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT = path.resolve(__dirname, "..");
+const DIST = path.join(ROOT, "dist");
+
+const isWindows = process.platform === "win32";
+const isMac = process.platform === "darwin";
+const binaryName = isWindows ? "kj.exe" : "kj";
+const binaryPath = path.join(DIST, binaryName);
+
+function run(cmd, opts = {}) {
+  console.log(`  $ ${cmd}`);
+  execSync(cmd, { cwd: ROOT, stdio: "inherit", ...opts });
+}
+
+function formatBytes(bytes) {
+  const mb = bytes / (1024 * 1024);
+  return `${mb.toFixed(1)} MB`;
+}
+
+async function main() {
+  try {
+    console.log("\n=== Karajan Code — SEA Build ===\n");
+
+    // ── Step 0: Prepare dist directory ──────────────────────────────
+    mkdirSync(DIST, { recursive: true });
+
+    // ── Step 1: Bundle with esbuild ─────────────────────────────────
+    console.log("[1/5] Bundling with esbuild...");
+    const { seaBuildOptions } = await import("./esbuild-sea.config.mjs");
+    const esbuild = await import("esbuild");
+    await esbuild.build(seaBuildOptions);
+    console.log("      -> dist/kj-bundle.cjs created.\n");
+
+    // ── Step 2: Generate SEA blob ───────────────────────────────────
+    console.log("[2/5] Generating SEA preparation blob...");
+    const seaConfig = {
+      main: "dist/kj-bundle.cjs",
+      output: "dist/sea-prep.blob",
+      disableExperimentalSEAWarning: true,
+    };
+    writeFileSync(
+      path.join(DIST, "sea-config.json"),
+      JSON.stringify(seaConfig, null, 2),
+    );
+    run("node --experimental-sea-config dist/sea-config.json");
+    console.log("      -> dist/sea-prep.blob created.\n");
+
+    // ── Step 3: Copy node binary ────────────────────────────────────
+    console.log("[3/5] Copying node binary...");
+    cpSync(process.execPath, binaryPath);
+    console.log(`      -> ${binaryName} copied.\n`);
+
+    // ── Step 3.5: Remove signature on macOS (required before postject)
+    if (isMac) {
+      console.log("[3.5] Removing macOS code signature...");
+      run(`codesign --remove-signature ${binaryPath}`);
+      console.log("      -> Signature removed.\n");
+    }
+
+    // ── Step 4: Inject blob with postject ───────────────────────────
+    console.log("[4/5] Injecting SEA blob with postject...");
+    const postjectCmd = [
+      `npx postject ${binaryPath}`,
+      "NODE_SEA_BLOB dist/sea-prep.blob",
+      "--sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2",
+    ].join(" ");
+    run(postjectCmd);
+    console.log("      -> Blob injected.\n");
+
+    // ── Step 4.5: Re-sign on macOS ──────────────────────────────────
+    if (isMac) {
+      console.log("[4.5] Re-signing binary (ad-hoc)...");
+      run(`codesign --sign - ${binaryPath}`);
+      console.log("      -> Binary signed.\n");
+    }
+
+    // ── Done ────────────────────────────────────────────────────────
+    const stat = statSync(binaryPath);
+    console.log("[5/5] Done!");
+    console.log(`      Binary: ${binaryPath}`);
+    console.log(`      Size:   ${formatBytes(stat.size)}`);
+    console.log("");
+  } catch (err) {
+    console.error("\n=== SEA Build FAILED ===\n");
+    console.error(err.message || err);
+    console.error(
+      "\nNote: esbuild may fail to bundle certain ESM-only dependencies",
+    );
+    console.error(
+      "or native modules. Check the error above for details.\n",
+    );
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/esbuild-sea.config.mjs

@@ -0,0 +1,33 @@
+/**
+ * esbuild configuration for Node.js SEA (Single Executable Application) bundle.
+ *
+ * Bundles the entire CLI into a single CJS file suitable for SEA injection.
+ * SEA requires CJS format — ESM entry points are transpiled by esbuild.
+ */
+
+/** @type {import('esbuild').BuildOptions} */
+export const seaBuildOptions = {
+  entryPoints: ["src/cli.js"],
+  outfile: "dist/kj-bundle.cjs",
+  format: "cjs",
+  platform: "node",
+  target: "node20",
+  bundle: true,
+  minify: false,
+  // Bundle everything — no externals. The binary must be fully self-contained.
+  external: [],
+  // Shim for CJS compatibility in the SEA context.
+  banner: {
+    js: [
+      "/* Karajan Code — SEA bundle */",
+      "/* eslint-disable */",
+      'const __importMetaUrl = require("node:url").pathToFileURL(__filename).href;',
+    ].join("\n"),
+  },
+  // Replace import.meta.url references with the CJS-compatible shim variable.
+  define: {
+    "import.meta.url": "__importMetaUrl",
+  },
+  // Log level for debugging build issues.
+  logLevel: "info",
+};

package/src/hu/parallel-executor.js

@@ -0,0 +1,94 @@
+/**
+ * Parallel HU execution using git worktrees.
+ *
+ * Analyses the dependency graph to find groups of HUs that can run
+ * concurrently, creates isolated git worktrees for each parallel HU,
+ * and merges results back sequentially.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path from "node:path";
+
+const execFileAsync = promisify(execFile);
+
+/** Directory inside the project where worktrees are created. */
+const WORKTREE_DIR = ".kj/worktrees";
+
+/**
+ * Given stories and their topological order, return groups (batches) of HUs
+ * that can execute in parallel.  Two HUs can run in parallel when neither
+ * depends (directly or transitively) on the other.
+ *
+ * The algorithm walks the topological order and assigns each HU to the
+ * earliest batch where all its dependencies have already been placed in
+ * a previous batch.
+ *
+ * @param {Array<{id: string, blocked_by?: string[]}>} stories
+ * @param {string[]} order - topologically sorted story IDs
+ * @returns {string[][]} Array of batches; each batch is an array of story IDs.
+ */
+export function findParallelGroups(stories, order) {
+  if (!order.length) return [];
+
+  const storyMap = new Map(stories.map(s => [s.id, s]));
+  // batchIndex[id] = index of the batch the story was assigned to
+  const batchIndex = new Map();
+  const batches = [];
+
+  for (const id of order) {
+    const story = storyMap.get(id);
+    const deps = story?.blocked_by || [];
+    // This HU must go into the batch *after* the latest dependency batch
+    let earliest = 0;
+    for (const dep of deps) {
+      if (batchIndex.has(dep)) {
+        earliest = Math.max(earliest, batchIndex.get(dep) + 1);
+      }
+    }
+    if (!batches[earliest]) batches[earliest] = [];
+    batches[earliest].push(id);
+    batchIndex.set(id, earliest);
+  }
+
+  return batches;
+}
+
+/**
+ * Create a git worktree for a given HU.
+ *
+ * @param {string} projectDir - Root directory of the git repo.
+ * @param {string} huId - Story identifier (used for branch and directory name).
+ * @returns {Promise<string>} Absolute path to the created worktree.
+ */
+export async function createWorktree(projectDir, huId) {
+  const worktreePath = path.join(projectDir, WORKTREE_DIR, huId);
+  const branchName = `kj-hu-${huId}`;
+  await execFileAsync("git", ["worktree", "add", worktreePath, "-b", branchName], { cwd: projectDir });
+  return worktreePath;
+}
+
+/**
+ * Remove a git worktree (forcefully).
+ *
+ * @param {string} projectDir - Root directory of the git repo.
+ * @param {string} huId - Story identifier.
+ * @returns {Promise<void>}
+ */
+export async function removeWorktree(projectDir, huId) {
+  const worktreePath = path.join(projectDir, WORKTREE_DIR, huId);
+  await execFileAsync("git", ["worktree", "remove", worktreePath, "--force"], { cwd: projectDir });
+}
+
+/**
+ * Merge a worktree branch back into the current branch and clean up.
+ *
+ * @param {string} projectDir - Root directory of the git repo.
+ * @param {string} huId - Story identifier.
+ * @returns {Promise<void>}
+ */
+export async function mergeWorktree(projectDir, huId) {
+  const branchName = `kj-hu-${huId}`;
+  await execFileAsync("git", ["merge", branchName, "--no-edit"], { cwd: projectDir });
+  await removeWorktree(projectDir, huId);
+  await execFileAsync("git", ["branch", "-d", branchName], { cwd: projectDir });
+}

package/src/orchestrator/hu-sub-pipeline.js

@@ -6,6 +6,7 @@ import { topologicalSort } from "../hu/graph.js";
 import { updateStoryStatus, loadHuBatch, saveHuBatch, HU_STATUS } from "../hu/store.js";
 import { emitProgress, makeEvent } from "../utils/events.js";
 import { refineHuWithContext } from "../hu/lazy-planner.js";
+import { findParallelGroups, createWorktree, mergeWorktree, removeWorktree } from "../hu/parallel-executor.js";
 
 /**
  * Determine whether the HU reviewer result requires a sub-pipeline
@@ -60,6 +61,92 @@ function buildHuTask(story) {
   return `Implement HU ${story.id}`;
 }
 
+/**
+ * Execute a single HU through the coder→sonar→reviewer sub-pipeline.
+ * Extracted to support both sequential and parallel execution paths.
+ *
+ * @param {object} params
+ * @returns {Promise<{huId: string, approved: boolean, result?: object, error?: string, blockedDependents?: string[]}>}
+ */
+async function runSingleHu({ storyId, batch, batchSessionId, runIterationFn, emitter, eventBase, logger, config, results, worktreePath }) {
+  const story = batch.stories.find(s => s.id === storyId);
+
+  // --- Lazy refinement ---
+  if (story.needsRefinement && config) {
+    const completedHus = results
+      .filter(r => r.approved)
+      .map(r => {
+        const completedStory = batch.stories.find(s => s.id === r.huId);
+        return {
+          ...completedStory,
+          resultSummary: r.result?.summary || r.result?.reason || null
+        };
+      });
+
+    emitProgress(emitter, makeEvent("hu:refine-start", { ...eventBase, stage: "hu-sub-pipeline" }, {
+      message: `Refining HU ${story.id} with context from ${completedHus.length} completed HU(s)`,
+      detail: { huId: story.id, completedCount: completedHus.length }
+    }));
+
+    try {
+      const refined = await refineHuWithContext(story, completedHus, config, logger);
+      Object.assign(story, refined);
+      story.needsRefinement = false;
+      await saveHuBatch(batchSessionId, batch);
+
+      emitProgress(emitter, makeEvent("hu:refine-end", { ...eventBase, stage: "hu-sub-pipeline" }, {
+        message: `HU ${story.id} refined successfully`,
+        detail: { huId: story.id }
+      }));
+    } catch (err) {
+      logger.warn(`Lazy refinement failed for HU ${story.id}: ${err.message} — proceeding with original`);
+      story.needsRefinement = false;
+    }
+  }
+
+  const huTask = buildHuTask(story);
+
+  // --- hu:start ---
+  emitProgress(emitter, makeEvent("hu:start", { ...eventBase, stage: "hu-sub-pipeline" }, {
+    message: `Starting HU ${story.id}`,
+    detail: { huId: story.id, title: story.certified?.title || story.id, worktreePath: worktreePath || null }
+  }));
+
+  updateStoryStatus(batch, story.id, HU_STATUS.CODING);
+  await saveHuBatch(batchSessionId, batch);
+
+  try {
+    const iterResult = await runIterationFn(huTask);
+    const approved = Boolean(iterResult?.approved);
+
+    if (approved) {
+      updateStoryStatus(batch, story.id, HU_STATUS.DONE);
+      emitProgress(emitter, makeEvent("hu:end", { ...eventBase, stage: "hu-sub-pipeline" }, {
+        status: "ok",
+        message: `HU ${story.id} completed successfully`,
+        detail: { huId: story.id, approved: true }
+      }));
+      return { huId: story.id, approved: true, result: iterResult };
+    } else {
+      updateStoryStatus(batch, story.id, HU_STATUS.FAILED);
+      emitProgress(emitter, makeEvent("hu:end", { ...eventBase, stage: "hu-sub-pipeline" }, {
+        status: "fail",
+        message: `HU ${story.id} failed`,
+        detail: { huId: story.id, approved: false, reason: iterResult?.reason }
+      }));
+      return { huId: story.id, approved: false, result: iterResult };
+    }
+  } catch (err) {
+    updateStoryStatus(batch, story.id, HU_STATUS.FAILED);
+    emitProgress(emitter, makeEvent("hu:end", { ...eventBase, stage: "hu-sub-pipeline" }, {
+      status: "fail",
+      message: `HU ${story.id} threw: ${err.message}`,
+      detail: { huId: story.id, approved: false, error: err.message }
+    }));
+    return { huId: story.id, approved: false, error: err.message };
+  }
+}
+
 /**
  * Run all certified HUs as sub-pipelines in topological order.
  *
@@ -99,102 +186,85 @@ export async function runHuSubPipeline({ huReviewerResult, runIterationFn, emitt
   const blockedIds = [];
   let allApproved = true;
 
-  for (const storyId of orderedIds) {
-    const story = batch.stories.find(s => s.id === storyId);
-    if (!story) continue;
+  // --- Group HUs into parallel batches ---
+  const parallelBatches = findParallelGroups(certifiedStories, orderedIds);
 
-    // Skip if already blocked by a failed dependency
-    if (story.status === HU_STATUS.BLOCKED) {
-      blockedIds.push(story.id);
-      continue;
-    }
+  for (const group of parallelBatches) {
+    // Filter out HUs that were blocked by a failed dependency in a previous batch
+    const runnableIds = group.filter(id => {
+      const story = batch.stories.find(s => s.id === id);
+      return story && story.status !== HU_STATUS.BLOCKED;
+    });
 
-    // --- Lazy refinement: refine HU if it needs it, using completed HU context ---
-    if (story.needsRefinement && config) {
-      const completedHus = results
-        .filter(r => r.approved)
-        .map(r => {
-          const completedStory = batch.stories.find(s => s.id === r.huId);
-          return {
-            ...completedStory,
-            resultSummary: r.result?.summary || r.result?.reason || null
-          };
-        });
+    if (runnableIds.length === 0) continue;
 
-      emitProgress(emitter, makeEvent("hu:refine-start", { ...eventBase, stage: "hu-sub-pipeline" }, {
-        message: `Refining HU ${story.id} with context from ${completedHus.length} completed HU(s)`,
-        detail: { huId: story.id, completedCount: completedHus.length }
-      }));
+    // Emit parallel batch start event
+    emitProgress(emitter, makeEvent("hu:parallel-start", { ...eventBase, stage: "hu-sub-pipeline" }, {
+      message: `Starting parallel batch of ${runnableIds.length} HU(s): ${runnableIds.join(", ")}`,
+      detail: { batchIds: runnableIds, parallel: runnableIds.length > 1 }
+    }));
 
-      try {
-        const refined = await refineHuWithContext(story, completedHus, config, logger);
-        // Apply refinement to the batch story in-place
-        Object.assign(story, refined);
-        story.needsRefinement = false;
-        await saveHuBatch(batchSessionId, batch);
-
-        emitProgress(emitter, makeEvent("hu:refine-end", { ...eventBase, stage: "hu-sub-pipeline" }, {
-          message: `HU ${story.id} refined successfully`,
-          detail: { huId: story.id }
-        }));
-      } catch (err) {
-        logger.warn(`Lazy refinement failed for HU ${story.id}: ${err.message} — proceeding with original`);
-        story.needsRefinement = false;
+    if (runnableIds.length === 1) {
+      // Single HU: run as before, no worktree needed
+      const singleResult = await runSingleHu({
+        storyId: runnableIds[0], batch, batchSessionId, runIterationFn,
+        emitter, eventBase, logger, config, results
+      });
+      results.push(singleResult);
+      if (!singleResult.approved) {
+        allApproved = false;
+        const newlyBlocked = blockDependents(batch, singleResult.huId);
+        blockedIds.push(...newlyBlocked);
       }
-    }
-
-    const huTask = buildHuTask(story);
+      await saveHuBatch(batchSessionId, batch);
+    } else {
+      // Multiple HUs: create worktrees, run in parallel
+      const projectDir = config?.projectDir || process.cwd();
+      const worktrees = new Map();
 
-    // --- hu:start ---
-    emitProgress(emitter, makeEvent("hu:start", { ...eventBase, stage: "hu-sub-pipeline" }, {
-      message: `Starting HU ${story.id}`,
-      detail: { huId: story.id, title: story.certified?.title || story.id }
-    }));
+      // Create worktrees for each HU in the batch
+      for (const id of runnableIds) {
+        try {
+          const wtPath = await createWorktree(projectDir, id);
+          worktrees.set(id, wtPath);
+        } catch (err) {
+          logger.warn(`Failed to create worktree for HU ${id}: ${err.message} — will run sequentially`);
+        }
+      }
 
-    // Update status to coding
-    updateStoryStatus(batch, story.id, HU_STATUS.CODING);
-    await saveHuBatch(batchSessionId, batch);
+      // Run all HUs in the batch concurrently
+      const batchPromises = runnableIds.map(async (storyId) => {
+        return runSingleHu({
+          storyId, batch, batchSessionId, runIterationFn,
+          emitter, eventBase, logger, config, results,
+          worktreePath: worktrees.get(storyId)
+        });
+      });
 
-    try {
-      const iterResult = await runIterationFn(huTask);
-      const approved = Boolean(iterResult?.approved);
-
-      if (approved) {
-        updateStoryStatus(batch, story.id, HU_STATUS.DONE);
-        emitProgress(emitter, makeEvent("hu:end", { ...eventBase, stage: "hu-sub-pipeline" }, {
-          status: "ok",
-          message: `HU ${story.id} completed successfully`,
-          detail: { huId: story.id, approved: true }
-        }));
-        results.push({ huId: story.id, approved: true, result: iterResult });
-      } else {
-        updateStoryStatus(batch, story.id, HU_STATUS.FAILED);
-        const newlyBlocked = blockDependents(batch, story.id);
-        blockedIds.push(...newlyBlocked);
-        allApproved = false;
+      const batchResults = await Promise.all(batchPromises);
 
-        emitProgress(emitter, makeEvent("hu:end", { ...eventBase, stage: "hu-sub-pipeline" }, {
-          status: "fail",
-          message: `HU ${story.id} failed — ${newlyBlocked.length} dependent(s) blocked`,
-          detail: { huId: story.id, approved: false, blockedDependents: newlyBlocked, reason: iterResult?.reason }
-        }));
-        results.push({ huId: story.id, approved: false, result: iterResult, blockedDependents: newlyBlocked });
+      // Process results: merge successful worktrees sequentially, clean up failed ones
+      for (const res of batchResults) {
+        results.push(res);
+        if (res.approved && worktrees.has(res.huId)) {
+          try {
+            await mergeWorktree(projectDir, res.huId);
+          } catch (err) {
+            logger.warn(`Failed to merge worktree for HU ${res.huId}: ${err.message}`);
+          }
+        } else if (!res.approved) {
+          allApproved = false;
+          const newlyBlocked = blockDependents(batch, res.huId);
+          blockedIds.push(...newlyBlocked);
+          // Clean up failed worktree
+          if (worktrees.has(res.huId)) {
+            try { await removeWorktree(projectDir, res.huId); } catch { /* ignore */ }
+          }
+        }
       }
-    } catch (err) {
-      updateStoryStatus(batch, story.id, HU_STATUS.FAILED);
-      const newlyBlocked = blockDependents(batch, story.id);
-      blockedIds.push(...newlyBlocked);
-      allApproved = false;
 
-      emitProgress(emitter, makeEvent("hu:end", { ...eventBase, stage: "hu-sub-pipeline" }, {
-        status: "fail",
-        message: `HU ${story.id} threw: ${err.message}`,
-        detail: { huId: story.id, approved: false, error: err.message, blockedDependents: newlyBlocked }
-      }));
-      results.push({ huId: story.id, approved: false, error: err.message, blockedDependents: newlyBlocked });
+      await saveHuBatch(batchSessionId, batch);
     }
-
-    await saveHuBatch(batchSessionId, batch);
   }
 
   return { approved: allApproved, results, blockedIds };