@ronkovic/aad 0.3.2 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronkovic/aad",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Autonomous Agent Development Orchestrator - Multi-agent TDD pipeline powered by Claude",
   "module": "src/main.ts",
   "type": "module",

package/src/modules/cli/__tests__/commands.test.ts

@@ -46,12 +46,20 @@ describe("Resume Command", () => {
       stores: {
         runStore: {
           get: mock(async () => mockRunState),
+          save: mock(async () => {}),
         } as any,
         taskStore: {
           list: mock(async () => [mockTask]),
           getAll: mock(async () => [mockTask]),
           save: mock(async () => {}),
         } as any,
+        workerStore: {
+          save: mock(async () => {}),
+          getAll: mock(async () => []),
+          getIdle: mock(async () => []),
+          get: mock(async () => null),
+          delete: mock(async () => {}),
+        } as any,
       } as any,
       dispatcher: {
         initialize: mock(async () => {}),

package/src/modules/cli/__tests__/resume.test.ts

@@ -83,7 +83,7 @@ describe("resumeRun", () => {
           getAll: mock(async () => mockTasks),
           save: mock(async () => {}),
         } as any,
-        workerStore: {} as any,
+        workerStore: { save: async () => {}, getAll: async () => [], getIdle: async () => [], get: async () => null, delete: async () => {} } as any,
       },
       dispatcher: {
         initialize: mock(async () => {}),

package/src/modules/cli/__tests__/run.test.ts

@@ -117,12 +117,15 @@ describe("runPipeline", () => {
   });
 
   test("runs pipeline with valid requirements", async () => {
-    // Mock dispatcher.start to emit run:completed immediately
+    // Mock dispatcher.start to emit run:completed with the actual runId
     mockApp.dispatcher.start = mock(async () => {
-      // Emit run:completed after a short delay to allow setup
       setTimeout(() => {
-        // Use any runId that matches the pattern
-        eventBus.emit({ type: "run:completed", runId: createRunId("any-run-id") });
+        // Capture runId from the queue:initialized event or use wildcard listener
+        // The run:completed handler checks runId, so we need to match it.
+        // Listen for queue:initialized to get the actual runId from dispatcher.initialize call.
+        const initCall = (mockApp.dispatcher.initialize as any).mock?.calls?.[0]?.[0];
+        const actualRunId = initCall?.runId ?? createRunId("fallback-run-id");
+        eventBus.emit({ type: "run:completed", runId: actualRunId });
       }, 50);
     });
 

package/src/modules/cli/app.ts

@@ -86,13 +86,13 @@ export function createApp(options: AppOptions = {}): App {
 
   // 4. LogStore + SSE Transport初期化
   const logStore = new LogStore();
-  const sseTransport = createSSETransport({ logStore, eventBus });
-  void sseTransport;
+  // SSE transport registers EventBus listeners internally; no direct reference needed
+  createSSETransport({ logStore, eventBus });
 
   // 5. ProviderRegistry初期化
   const providerRegistry = createProviderRegistry(
     {
-      default: options.providerDefault ?? "cli",
+      default: options.providerDefault ?? "sdk",
       overrides: options.providerOverrides,
     },
     config,
@@ -128,6 +128,7 @@ export function createApp(options: AppOptions = {}): App {
       staleTaskThreshold: config.timeouts.staleTask * 1000, // Convert seconds to milliseconds
     },
     logger: logger.child({ service: "task-queue" }),
+    getIdleWorkerIds: () => processManager.getIdleWorkers(),
   });
   logger.debug("Dispatcher initialized");
 

package/src/modules/cli/commands/resume.ts

@@ -5,7 +5,9 @@
 
 import { Command } from "commander";
 import type { App } from "../app";
-import { createRunId } from "../../../shared/types";
+import { createRunId, createWorkerId } from "../../../shared/types";
+import { registerTaskDispatchHandler } from "./task-dispatch-handler";
+import { installShutdownHandler } from "../../../shared/shutdown-handler";
 
 export function createResumeCommand(getApp: () => App): Command {
   const command = new Command("resume")
@@ -45,9 +47,10 @@ export async function resumeRun(app: App, runIdStr: string): Promise<void> {
 
   // 2. タスク一覧を読み込み
   const allTasks = await stores.taskStore.getAll();
-  const runTasks = allTasks.filter((task) => {
-    return task.taskId.includes(runIdStr);
-  });
+  // In-memory store contains only one run's tasks (no cross-run contamination).
+  // For fs persistence, tasks are scoped to the run directory.
+  // Use all tasks — the dispatcher was initialized with this run's task plan.
+  const runTasks = allTasks;
 
   logger.info({ taskCount: runTasks.length }, "Tasks loaded");
 
@@ -104,9 +107,23 @@ export async function resumeRun(app: App, runIdStr: string): Promise<void> {
   await dispatcher.initialize(taskPlan);
   await processManager.initializePool(app.config.workers.num);
 
+  // Worker state初期化 (ProcessManagerと同じ1-indexedに合わせる)
+  for (let i = 0; i < app.config.workers.num; i++) {
+    const workerId = createWorkerId(`worker-${i + 1}`);
+    await stores.workerStore.save({ workerId, status: "idle", currentTask: null });
+  }
+
   logger.info("Dispatcher and ProcessManager re-initialized");
   console.log("✅ Dispatcher and ProcessManager re-initialized\n");
 
+  // 5.5. Install shutdown handler + task dispatch handler
+  installShutdownHandler({
+    runId,
+    stores: { runStore: stores.runStore, taskStore: stores.taskStore },
+    logger,
+  });
+  registerTaskDispatchHandler({ app, runId, parentBranch: runState.parentBranch });
+
   // 6. Dispatcher.start()
   dispatcher.start();
   logger.info({ runId }, "Run resumed");

package/src/modules/cli/commands/run.ts

@@ -8,20 +8,10 @@ import { randomUUID } from "node:crypto";
 import type { App } from "../app";
 import { formatProgress, formatTaskTable, createSpinner } from "../output";
 import { createRunId, createWorkerId } from "../../../shared/types";
-import type { WorkspaceInfo } from "../../../shared/types";
 import { getCurrentBranch, cleanupOrphanedFromPreviousRuns } from "../../git-workspace";
-import { executeTddPipeline } from "../../task-execution";
-import { checkMemoryAndWarn, waitForMemory } from "../../../shared/memory-check";
-import { installShutdownHandler, isShuttingDown } from "../../../shared/shutdown-handler";
-import {
-  detectProjectType,
-  detectPackageManager,
-  detectTestFramework,
-  detectFramework,
-  detectOrm,
-  detectArchitecturePattern,
-  createBunFileChecker,
-} from "../../planning";
+import { checkMemoryAndWarn } from "../../../shared/memory-check";
+import { installShutdownHandler } from "../../../shared/shutdown-handler";
+import { registerTaskDispatchHandler } from "./task-dispatch-handler";
 
 export function createRunCommand(getApp: () => App): Command {
   const command = new Command("run")
@@ -54,7 +44,7 @@ export function createRunCommand(getApp: () => App): Command {
  * メインパイプライン実行
  */
 export async function runPipeline(app: App, requirementsPath: string, keepWorktrees = false): Promise<void> {
-  const { config, logger, eventBus, planningService, dispatcher, processManager, worktreeManager, providerRegistry, stores, branchManager } = app;
+  const { config, logger, eventBus, planningService, dispatcher, processManager, worktreeManager, stores, branchManager } = app;
 
   // Validate requirements file exists
   const reqFile = Bun.file(requirementsPath);
@@ -74,9 +64,6 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
     logger.warn({ error }, "Orphaned worktree cleanup failed (non-critical)");
   }
 
-  // Semaphore for serializing tasks under memory pressure
-  let memoryGateLock: Promise<void> = Promise.resolve();
-
   // 1. RunId生成 + 現在ブランチ取得
   const runId = createRunId(randomUUID());
   const parentBranch = await getCurrentBranch(process.cwd());
@@ -140,9 +127,9 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
     startTime: new Date().toISOString(),
   });
 
-  // Worker state初期化
+  // Worker state初期化 (ProcessManagerと同じ1-indexedに合わせる)
   for (let i = 0; i < app.config.workers.num; i++) {
-    const workerId = createWorkerId(`worker-${i}`);
+    const workerId = createWorkerId(`worker-${i + 1}`);
     await stores.workerStore.save({
       workerId,
       status: "idle",
@@ -157,99 +144,8 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
     logger,
   });
 
-  // 5. EventBus: task:dispatched → TDDパイプライン起動
-  eventBus.on<Extract<import("../../../shared/events").AADEvent, { type: "task:dispatched" }>>(
-    "task:dispatched",
-    (event) => {
-      const taskId = event.taskId;
-      const workerId = event.workerId;
-
-      if (isShuttingDown()) {
-        logger.warn({ taskId }, "Shutdown in progress, skipping dispatch");
-        return;
-      }
-
-      logger.info({ taskId, workerId }, "Task dispatched, starting TDD pipeline");
-
-      void (async () => {
-        try {
-          // Memory gate: wait for sufficient memory before dispatch
-          try {
-            const memResult = await waitForMemory(logger);
-            if (memResult.shouldReduceWorkers && config.workers.num > 1) {
-              logger.warn(
-                { freeGB: memResult.freeGB, workers: config.workers.num },
-                "Low memory: serializing task execution",
-              );
-              // Serialize by waiting for previous task's lock
-              const previousLock = memoryGateLock;
-              let releaseLock: () => void;
-              memoryGateLock = new Promise<void>((r) => { releaseLock = r; });
-              await previousLock;
-              // releaseLock will be called at the end of this task
-              try {
-                await runTask();
-              } finally {
-                releaseLock!();
-              }
-              return;
-            }
-          } catch (memError) {
-            // MemoryError → abort task gracefully
-            logger.error({ taskId, error: memError }, "Memory gate failed");
-            eventBus.emit({ type: "task:failed", taskId, error: String(memError) });
-            return;
-          }
-
-          await runTask();
-
-          async function runTask() {
-          const task = await stores.taskStore.get(taskId);
-          if (!task) {
-            throw new Error(`Task not found: ${taskId}`);
-          }
-
-          // Worktree作成
-          const branchName = `aad/${runId}/${taskId}`;
-          const worktreePath = await worktreeManager.createTaskWorktree(taskId, branchName);
-          logger.info({ taskId, worktreePath, branchName }, "Worktree created");
-
-          // Workspace情報 (project detectionから自動検出)
-          const workspace = await detectWorkspace(worktreePath, logger);
-
-          // Run before:execution hook
-          await app.pluginManager.runHook("before:execution", { taskId, task, worktreePath });
-
-          // TDDパイプライン実行
-          const provider = providerRegistry.getProvider("implementer");
-          const result = await executeTddPipeline(
-            task,
-            workspace,
-            branchName,
-            parentBranch,
-            process.cwd(),
-            runId,
-            app.config,
-            provider,
-            app.mergeService,
-            eventBus,
-            undefined // testSpawner: use default
-          );
-
-          // Run after:execution hook
-          await app.pluginManager.runHook("after:execution", { taskId, result });
-
-          // 結果をEventBusに通知
-          eventBus.emit({ type: "task:completed", taskId, result });
-          } // end runTask
-
-        } catch (error) {
-          logger.error({ taskId, workerId, error }, "TDD pipeline failed");
-          eventBus.emit({ type: "task:failed", taskId, error: String(error) });
-        }
-      })();
-    }
-  );
+  // 5. Register task dispatch handler (shared with resume)
+  registerTaskDispatchHandler({ app, runId, parentBranch });
 
   // 6. 進捗表示
   const progressSpinner = createSpinner("Executing tasks...");
@@ -269,16 +165,23 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
   // 7. Dispatcher.start() (イベントドリブン)
   void dispatcher.start();
 
-  // 8. run:completed待機 → 結果表示
-  await new Promise<void>((resolve) => {
+  // 8. run:completed待機 → 結果表示 (with timeout)
+  const pipelineTimeoutMs = (config.timeouts.staleTask || 5400) * taskPlan.tasks.length * 1000;
+  await new Promise<void>((resolve, reject) => {
     const handler: import("../../../shared/events").EventListener<
       Extract<import("../../../shared/events").AADEvent, { type: "run:completed" }>
-    > = () => {
-      // runIdの一致をチェック (テスト時はany runIdでも許可)
+    > = (event) => {
+      if (event.runId !== runId) return;
+      clearTimeout(timer);
       progressSpinner.stop();
       eventBus.off("run:completed", handler);
       resolve();
     };
+    const timer = setTimeout(() => {
+      progressSpinner.stop();
+      eventBus.off("run:completed", handler);
+      reject(new Error(`Pipeline timed out after ${Math.round(pipelineTimeoutMs / 1000)}s`));
+    }, pipelineTimeoutMs);
     eventBus.on("run:completed", handler);
   });
 
@@ -341,88 +244,3 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
   }
 }
 
-/**
- * Detect workspace information from worktree path
- */
-async function detectWorkspace(
-  worktreePath: string,
-  logger: import("pino").Logger
-): Promise<WorkspaceInfo> {
-  try {
-    const fileChecker = createBunFileChecker();
-    const projectType = await detectProjectType(worktreePath, fileChecker);
-    const packageManager = await detectPackageManager(worktreePath, fileChecker);
-    const testFramework = await detectTestFramework(worktreePath, projectType, fileChecker);
-    const framework = await detectFramework(worktreePath, projectType, fileChecker);
-    const orm = await detectOrm(worktreePath, projectType, fileChecker);
-    const architecture = await detectArchitecturePattern(worktreePath, fileChecker);
-
-    // Map planning module types → shared types
-    const workspace: WorkspaceInfo = {
-      path: worktreePath,
-      language: mapProjectTypeToLanguage(projectType),
-      packageManager,
-      framework: framework !== "unknown" ? framework : "none",
-      testFramework: mapTestFramework(testFramework),
-      orm: orm !== "unknown" ? orm : undefined,
-      architecturePattern: architecture !== "custom" && architecture !== "unknown" ? architecture : undefined,
-    };
-
-    logger.debug({ workspace }, "Workspace detected");
-    return workspace;
-  } catch (error) {
-    // Fallback to defaults on detection failure
-    logger.warn({ error, worktreePath }, "Project detection failed, using fallback");
-    return {
-      path: worktreePath,
-      language: "typescript",
-      packageManager: "bun",
-      framework: "none",
-      testFramework: "bun-test",
-    };
-  }
-}
-
-/**
- * Map ProjectType → language string
- */
-function mapProjectTypeToLanguage(projectType: import("../../planning").ProjectType): string {
-  const mapping: Record<import("../../planning").ProjectType, string> = {
-    go: "go",
-    "go-workspace": "go",
-    rust: "rust",
-    python: "python",
-    nodejs: "typescript",
-    nextjs: "typescript",
-    express: "typescript",
-    react: "typescript",
-    terraform: "hcl",
-    unknown: "typescript",
-  };
-  return mapping[projectType];
-}
-
-/**
- * Map planning TestFramework → shared TestFramework
- */
-function mapTestFramework(tf: import("../../planning").TestFramework): import("../../../shared/types").TestFramework {
-  // "bun:test" → "bun-test"
-  if (tf === "bun:test") return "bun-test";
-  // "unittest" は shared types にないので "pytest" にフォールバック
-  if (tf === "unittest") return "pytest";
-  // "terraform-validate" は shared types にないので "unknown" にフォールバック
-  if (tf === "terraform-validate") return "unknown";
-
-  // その他は1:1マッピング ("pytest", "vitest", "jest", "mocha", "go-test", "cargo-test", "unknown")
-  const mapping: Partial<Record<import("../../planning").TestFramework, import("../../../shared/types").TestFramework>> = {
-    pytest: "pytest",
-    vitest: "vitest",
-    jest: "jest",
-    mocha: "mocha",
-    "go-test": "go-test",
-    "cargo-test": "cargo",
-    unknown: "unknown",
-  };
-
-  return mapping[tf] ?? "unknown";
-}

package/src/modules/cli/commands/task-dispatch-handler.ts

@@ -0,0 +1,206 @@
+/**
+ * Task Dispatch Handler
+ * Shared logic for registering task:dispatched event handler.
+ * Used by both `run` and `resume` commands.
+ */
+
+import type { App } from "../app";
+import type { TaskId, WorkerId, WorkspaceInfo } from "../../../shared/types";
+import type { RunId } from "../../../shared/types";
+import type { AADEvent } from "../../../shared/events";
+import { executeTddPipeline } from "../../task-execution";
+import { waitForMemory } from "../../../shared/memory-check";
+import { isShuttingDown } from "../../../shared/shutdown-handler";
+import {
+  detectProjectType,
+  detectPackageManager,
+  detectTestFramework,
+  detectFramework,
+  detectOrm,
+  detectArchitecturePattern,
+  createBunFileChecker,
+} from "../../planning";
+
+export interface TaskDispatchContext {
+  app: App;
+  runId: RunId;
+  parentBranch: string;
+}
+
+/**
+ * Register task:dispatched event handler on the EventBus.
+ * Handles memory gate, worker state, worktree creation, and TDD pipeline execution.
+ */
+export function registerTaskDispatchHandler(ctx: TaskDispatchContext): void {
+  const { app, runId, parentBranch } = ctx;
+  const { eventBus, logger, config, processManager, worktreeManager, providerRegistry, stores } = app;
+
+  let memoryGateLock: Promise<void> = Promise.resolve();
+
+  async function executeTask(taskId: TaskId, workerId: WorkerId): Promise<void> {
+    try {
+      await stores.workerStore.save({ workerId, status: "busy", currentTask: taskId });
+    } catch (storeError) {
+      logger.warn({ workerId, error: storeError }, "Worker store update failed");
+    }
+
+    let releaseMemoryGate: (() => void) | null = null;
+    try {
+      releaseMemoryGate = await acquireMemoryGate();
+
+      const task = await stores.taskStore.get(taskId);
+      if (!task) {
+        throw new Error(`Task not found: ${taskId}`);
+      }
+
+      const branchName = `aad/${runId}/${taskId}`;
+      const worktreePath = await worktreeManager.createTaskWorktree(taskId, branchName);
+      logger.info({ taskId, worktreePath, branchName }, "Worktree created");
+
+      const workspace = await detectWorkspace(worktreePath, logger);
+
+      await app.pluginManager.runHook("before:execution", { taskId, task, worktreePath });
+
+      const provider = providerRegistry.getProvider("implementer");
+      const result = await executeTddPipeline(
+        task, workspace, branchName, parentBranch, process.cwd(),
+        runId, app.config, provider, app.mergeService, eventBus,
+      );
+
+      await app.pluginManager.runHook("after:execution", { taskId, result });
+      eventBus.emit({ type: "task:completed", taskId, result });
+    } catch (error) {
+      logger.error({ taskId, workerId, error }, "TDD pipeline failed");
+      eventBus.emit({ type: "task:failed", taskId, error: String(error) });
+    } finally {
+      releaseMemoryGate?.();
+      try {
+        processManager.completeTask(workerId);
+        await stores.workerStore.save({ workerId, status: "idle", currentTask: null });
+      } catch (stateError) {
+        logger.warn({ workerId, taskId, error: stateError }, "Worker state recovery failed");
+      }
+    }
+  }
+
+  async function acquireMemoryGate(): Promise<(() => void) | null> {
+    const memResult = await waitForMemory(logger);
+    if (memResult.shouldReduceWorkers && config.workers.num > 1) {
+      logger.warn({ freeGB: memResult.freeGB }, "Low memory: serializing task execution");
+      const previousLock = memoryGateLock;
+      let releaseLock: () => void;
+      memoryGateLock = new Promise<void>((r) => { releaseLock = r; });
+      await previousLock;
+      return () => releaseLock!();
+    }
+    return null;
+  }
+
+  eventBus.on<Extract<AADEvent, { type: "task:dispatched" }>>(
+    "task:dispatched",
+    (event) => {
+      const taskId = event.taskId;
+      const workerId = event.workerId;
+
+      if (isShuttingDown()) {
+        logger.warn({ taskId }, "Shutdown in progress, skipping dispatch");
+        return;
+      }
+
+      logger.info({ taskId, workerId }, "Task dispatched, starting TDD pipeline");
+
+      try {
+        processManager.assignTask(workerId, taskId);
+      } catch (stateError) {
+        logger.warn({ workerId, taskId, error: stateError }, "Worker state transition failed");
+      }
+
+      void executeTask(taskId, workerId);
+    }
+  );
+}
+
+/**
+ * Detect workspace information from worktree path
+ */
+async function detectWorkspace(
+  worktreePath: string,
+  logger: import("pino").Logger
+): Promise<WorkspaceInfo> {
+  try {
+    const fileChecker = createBunFileChecker();
+    const projectType = await detectProjectType(worktreePath, fileChecker);
+    const packageManager = await detectPackageManager(worktreePath, fileChecker);
+    const testFramework = await detectTestFramework(worktreePath, projectType, fileChecker);
+    const framework = await detectFramework(worktreePath, projectType, fileChecker);
+    const orm = await detectOrm(worktreePath, projectType, fileChecker);
+    const architecture = await detectArchitecturePattern(worktreePath, fileChecker);
+
+    const language = await detectLanguage(worktreePath, projectType);
+
+    const workspace: WorkspaceInfo = {
+      path: worktreePath,
+      language,
+      packageManager,
+      framework: framework !== "unknown" ? framework : "none",
+      testFramework: mapTestFramework(testFramework),
+      orm: orm !== "unknown" ? orm : undefined,
+      architecturePattern: architecture !== "custom" && architecture !== "unknown" ? architecture : undefined,
+    };
+
+    logger.debug({ workspace }, "Workspace detected");
+    return workspace;
+  } catch (error) {
+    logger.warn({ error, worktreePath }, "Project detection failed, using fallback");
+    return {
+      path: worktreePath,
+      language: "typescript",
+      packageManager: "bun",
+      framework: "none",
+      testFramework: "bun-test",
+    };
+  }
+}
+
+async function detectLanguage(worktreePath: string, projectType: import("../../planning").ProjectType): Promise<string> {
+  const nodeTypes = ["nodejs", "nextjs", "express", "react"];
+  if (nodeTypes.includes(projectType)) {
+    const tsConfigExists = await Bun.file(`${worktreePath}/tsconfig.json`).exists();
+    return tsConfigExists ? "typescript" : "javascript";
+  }
+  return mapProjectTypeToLanguage(projectType);
+}
+
+function mapProjectTypeToLanguage(projectType: import("../../planning").ProjectType): string {
+  const mapping: Record<import("../../planning").ProjectType, string> = {
+    go: "go",
+    "go-workspace": "go",
+    rust: "rust",
+    python: "python",
+    nodejs: "javascript",
+    nextjs: "typescript",
+    express: "javascript",
+    react: "javascript",
+    terraform: "hcl",
+    unknown: "typescript",
+  };
+  return mapping[projectType];
+}
+
+function mapTestFramework(tf: import("../../planning").TestFramework): import("../../../shared/types").TestFramework {
+  if (tf === "bun:test") return "bun-test";
+  if (tf === "unittest") return "pytest";
+  if (tf === "terraform-validate") return "unknown";
+
+  const mapping: Partial<Record<import("../../planning").TestFramework, import("../../../shared/types").TestFramework>> = {
+    pytest: "pytest",
+    vitest: "vitest",
+    jest: "jest",
+    mocha: "mocha",
+    "go-test": "go-test",
+    "cargo-test": "cargo",
+    unknown: "unknown",
+  };
+
+  return mapping[tf] ?? "unknown";
+}

package/src/modules/cli/shutdown.ts

@@ -1,6 +1,9 @@
 /**
- * Shutdown Manager
+ * Shutdown Manager (Public API)
  * LIFO順でshutdownハンドラを実行し、二重shutdown防止、シグナルハンドリングを提供
+ *
+ * Note: Currently unused internally — run/resume use shared/shutdown-handler.ts instead.
+ * Retained as public API for plugin/external integrations.
  */
 
 import type { Logger } from "pino";

package/src/modules/git-workspace/merge-service.ts

@@ -67,14 +67,10 @@ export class MergeService {
         const conflicts = await this.detectConflicts(parentWorktree);
 
         if (conflicts.length > 0) {
-          // Abort merge
-          await gitExec(
-            ["merge", "--abort"],
-            { cwd: parentWorktree, logger: this.logger }
-          );
-
-          this.logger?.warn({ taskId, conflicts }, "Merge conflict detected");
+          this.logger?.warn({ taskId, conflicts }, "Merge conflict detected (merge left in progress for resolution)");
 
+          // Do NOT abort — leave the merge in progress so the resolver can
+          // edit conflicted files, `git add` them, and then commit.
           return {
             success: false,
             conflicts,

package/src/modules/planning/planning.service.ts

@@ -152,7 +152,9 @@ export class PlanningService {
       throw error;
     } finally {
       // Cleanup temp directory
-      await rm(tempDir, { recursive: true, force: true }).catch(() => {});
+      await rm(tempDir, { recursive: true, force: true }).catch((cleanupErr) => {
+        this.logger.warn({ tempDir, error: cleanupErr }, "Failed to cleanup planning temp directory");
+      });
     }
   }
 

package/src/modules/process-manager/process-manager.ts

@@ -29,7 +29,7 @@ export class ProcessManager {
   /**
    * Initialize worker pool
    */
-  initializePool(numWorkers: number): void {
+  async initializePool(numWorkers: number): Promise<void> {
     if (this.initialized) {
       throw new ProcessManagerError("ProcessManager already initialized");
     }

package/src/modules/task-execution/executor.ts

@@ -11,6 +11,7 @@ import type { EventBus } from "@aad/shared/events";
 import type { ProcessSpawner } from "./phases/tester-verify";
 
 import { estimateTaskComplexity, getAdaptiveEffortLevel } from "@aad/claude-provider";
+import { gitExec } from "@aad/git-workspace";
 import { runTesterRed } from "./phases/tester-red";
 import { runImplementerGreen } from "./phases/implementer-green";
 import { runTests } from "./phases/tester-verify";
@@ -136,8 +137,11 @@ export async function executeTddPipeline(
     // ===== Commit generated code =====
     // Commit changes after Green phase so they can be merged later
     try {
-      await Bun.$`git -C ${workspace.path} add -A`.quiet();
-      await Bun.$`git -C ${workspace.path} commit -m ${"feat: Implement " + task.title}`.quiet();
+      await gitExec(["add", "-A"], { cwd: workspace.path });
+      await gitExec(
+        ["commit", "--no-gpg-sign", "-m", `feat: Implement ${task.title}`],
+        { cwd: workspace.path }
+      );
     } catch (_error) {
       // If commit fails (e.g., no changes), log but don't fail the pipeline
       // This can happen if Claude didn't generate any new files
@@ -256,11 +260,10 @@ export async function executeTddPipeline(
     }
 
     if (mergeResult.hadConflict) {
-      // Emit conflict event for monitoring
       eventBus.emit({
         type: "execution:merge:conflict",
         taskId: task.taskId,
-        conflictedFiles: [], // MergeService would provide this
+        conflictedFiles: mergeResult.output ? [mergeResult.output] : [],
       });
     }
 

package/src/modules/task-execution/index.ts

@@ -1,18 +1,18 @@
 // Main executor
 export { executeTddPipeline } from "./executor";
 
+// Shared PhaseResult type (moved from individual phases)
+export type { PhaseResult } from "@aad/shared/types";
+
 // Phase functions
 export { runTesterRed, buildRedPhasePrompt } from "./phases/tester-red";
-export type { PhaseResult as TesterRedResult, TesterRedOptions } from "./phases/tester-red";
+export type { TesterRedOptions } from "./phases/tester-red";
 
 export {
   runImplementerGreen,
   buildGreenPhasePrompt,
 } from "./phases/implementer-green";
-export type {
-  PhaseResult as ImplementerGreenResult,
-  ImplementerGreenOptions,
-} from "./phases/implementer-green";
+export type { ImplementerGreenOptions } from "./phases/implementer-green";
 
 export { runTests, buildTestCommand } from "./phases/tester-verify";
 export type {
@@ -27,7 +27,6 @@ export {
   buildTeamsReviewPrompt,
 } from "./phases/reviewer";
 export type {
-  PhaseResult as ReviewerResult,
   ReviewerOptions,
   ReviewConfig,
 } from "./phases/reviewer";

package/src/modules/task-execution/phases/implementer-green.ts

@@ -1,12 +1,6 @@
-import type { Task, WorkspaceInfo, EffortLevel } from "@aad/shared/types";
+import type { Task, WorkspaceInfo, EffortLevel, PhaseResult } from "@aad/shared/types";
 import type { ClaudeProvider } from "@aad/claude-provider";
 
-export interface PhaseResult {
-  success: boolean;
-  output: string;
-  duration?: number;
-}
-
 export interface ImplementerGreenOptions {
   effortLevel?: EffortLevel;
   model?: string;

package/src/modules/task-execution/phases/merge.ts

@@ -1,6 +1,7 @@
 import type { Task, WorkspaceInfo } from "@aad/shared/types";
 import type { ClaudeProvider } from "@aad/claude-provider";
 import type { MergeService } from "@aad/git-workspace";
+import { gitExec } from "@aad/git-workspace";
 
 export interface MergePhaseResult {
   success: boolean;
@@ -105,6 +106,29 @@ export async function runMergePhase(
   const duration = Date.now() - startTime;
 
   if (response.exitCode === 0) {
+    // Finalize the merge commit after conflict resolution
+    try {
+      const statusResult = await gitExec(["diff", "--name-only", "--diff-filter=U"], { cwd: parentWorktree });
+      if (statusResult.stdout.trim() === "") {
+        // All conflicts resolved — complete the merge commit
+        await gitExec(
+          ["commit", "--no-gpg-sign", "--no-edit"],
+          { cwd: parentWorktree }
+        );
+      } else {
+        // Still unresolved — abort and report failure
+        await gitExec(["merge", "--abort"], { cwd: parentWorktree });
+        return {
+          success: false,
+          output: `Unresolved conflicts remain: ${statusResult.stdout.trim()}`,
+          hadConflict: true,
+          duration,
+        };
+      }
+    } catch (_commitError) {
+      // Commit may already be done by Claude via Bash tool — not fatal
+    }
+
     return {
       success: true,
       output: response.result,

package/src/modules/task-execution/phases/reviewer.ts

@@ -1,12 +1,6 @@
-import type { Task, WorkspaceInfo, RunId } from "@aad/shared/types";
+import type { Task, WorkspaceInfo, RunId, PhaseResult } from "@aad/shared/types";
 import type { ClaudeProvider, SubagentConfig } from "@aad/claude-provider";
 
-export interface PhaseResult {
-  success: boolean;
-  output: string;
-  duration?: number;
-}
-
 export interface ReviewerOptions {
   model?: string;
   timeout?: number;

package/src/modules/task-execution/phases/tester-red.ts

@@ -1,12 +1,6 @@
-import type { Task, WorkspaceInfo, EffortLevel } from "@aad/shared/types";
+import type { Task, WorkspaceInfo, EffortLevel, PhaseResult } from "@aad/shared/types";
 import type { ClaudeProvider } from "@aad/claude-provider";
 
-export interface PhaseResult {
-  success: boolean;
-  output: string;
-  duration?: number;
-}
-
 export interface TesterRedOptions {
   effortLevel?: EffortLevel;
   model?: string;

package/src/modules/task-queue/dispatcher.ts

@@ -39,6 +39,8 @@ export interface DispatcherDeps {
   eventBus: EventBus;
   config: DispatcherConfig;
   logger: Logger;
+  /** Optional synchronous idle worker provider (e.g. ProcessManager) */
+  getIdleWorkerIds?: () => WorkerId[];
 }
 
 /**
@@ -161,8 +163,10 @@ export class Dispatcher {
       return false;
     }
 
-    // Get idle workers
-    const idleWorkers = await this.deps.workerStore.getIdle();
+    // Get idle workers (prefer synchronous source if available)
+    const idleWorkers = this.deps.getIdleWorkerIds
+      ? this.deps.getIdleWorkerIds().map(id => ({ workerId: id, status: "idle" as const, currentTask: null }))
+      : await this.deps.workerStore.getIdle();
 
     if (idleWorkers.length === 0) {
       this.deps.logger.debug("No idle workers available");

package/src/shared/events.ts

@@ -158,6 +158,18 @@ export class EventBus {
     this.emitter.emit("*", event);
   }
 
+  /**
+   * Get current listener count for monitoring
+   */
+  getListenerCount(type?: EventType): number {
+    if (type) {
+      return this.emitter.listenerCount(type);
+    }
+    return this.emitter.eventNames().reduce(
+      (sum, name) => sum + this.emitter.listenerCount(name), 0
+    );
+  }
+
   off<T extends AADEvent>(
     type: T["type"] | "*",
     listener: EventListener<T>

package/src/shared/memory-check.ts

@@ -19,14 +19,10 @@ export interface MemoryStatus {
  * Get current system memory status (macOS only)
  */
 export async function getMemoryStatus(): Promise<MemoryStatus> {
-  const { stdout } = await Bun.spawn(["vm_stat"], {
-    stdout: "pipe",
-  }).exited.then(async (code) => {
-    if (code !== 0) throw new Error("vm_stat failed");
-    return {
-      stdout: await new Response(Bun.spawn(["vm_stat"], { stdout: "pipe" }).stdout).text(),
-    };
-  });
+  const proc = Bun.spawn(["vm_stat"], { stdout: "pipe" });
+  const stdout = await new Response(proc.stdout).text();
+  const code = await proc.exited;
+  if (code !== 0) throw new Error("vm_stat failed");
 
   // Parse vm_stat output
   const pageSizeMatch = stdout.match(/page size of (\d+) bytes/);

package/src/shared/shutdown-handler.ts

@@ -46,7 +46,11 @@ export function _resetShutdownState(): void {
  * Install signal handlers for graceful shutdown with state persistence.
  */
 export function installShutdownHandler(options: ShutdownHandlerOptions): void {
-  if (_installed) return;
+  // Allow re-installation with new options (e.g. resume after run)
+  if (_installed && _cleanup) {
+    _cleanup();
+    _cleanup = null;
+  }
   _installed = true;
 
   const { runId, stores, logger, exitFn = (code: number) => process.exit(code) } = options;

package/src/shared/types.ts

@@ -141,3 +141,12 @@ export interface WorkspaceInfo {
   orm?: string;
   architecturePattern?: string;
 }
+
+/**
+ * Common result type for TDD pipeline phases (Red/Green/Review)
+ */
+export interface PhaseResult {
+  success: boolean;
+  output: string;
+  duration?: number;
+}