@ronkovic/aad 0.3.1 → 0.3.3

package/README.md

@@ -91,6 +91,21 @@ bun install
 bun run dev
 ```
 
+## システム要件
+
+| | RAM | 推奨ワーカー数 |
+|---|---|---|
+| **最小** | 8GB | 1（シングルワーカー） |
+| **推奨** | 16GB | 2（並列ワーカー） |
+
+**メモリ安全機能:**
+- **自動メモリゲート** — 空きメモリが閾値を下回ると新規ワーカーの起動を抑制
+- **シーケンシャルフォールバック** — メモリ不足時に並列実行から逐次実行へ自動切替
+- **グレースフルシャットダウン** — メモリ圧迫時に安全にプロセスを終了
+- **ランタイム監視** — 実行中のメモリ使用量をリアルタイムで監視
+
+> **macOS:** メモリ監視は `vm_stat` ベースで実装されています。Linux環境では `/proc/meminfo` を使用します。
+
 ## クイックスタート
 
 ### 1. 要件ファイルの作成
@@ -303,6 +318,7 @@ aad cleanup --run <run_id> --force
 ## リンク
 
 - [Architecture Documentation](docs/architecture.md)
+- [Case Studies](docs/case-studies/) - Real-world execution examples
 - [Rewrite Plan (Internal)](docs/rewrite-plan/README.md)
 - [Project Guidelines](CLAUDE.md)
 - [Issue Tracker](https://github.com/ronkovic/aad/issues)

package/package.json

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

package/src/main.ts

@@ -27,7 +27,7 @@ program
   .option("--persist <mode>", "Persistence mode: memory or fs", "memory")
   .option("--debug", "Enable debug logging", false)
   .option("--no-dashboard", "Disable dashboard server")
-  .option("--provider <type>", "Default provider: cli or sdk", "cli");
+  .option("--provider <type>", "Default provider: cli or sdk", "sdk");
 
 // App factory with global options
 const getApp = (): App => {

package/src/modules/claude-provider/claude-provider.port.ts

@@ -15,6 +15,7 @@ export interface ClaudeRequest {
   maxRetries?: number;
   allowedTools?: string[];
   outputFormat?: "text" | "json";
+  jsonSchema?: Record<string, unknown>;  // JSON schema for structured output (when outputFormat="json")
   permissionMode?: "acceptEdits" | "bypassPermissions" | "default" | "delegate" | "dontAsk" | "plan";
   cwd?: string;
   appendSystemPrompt?: string;

package/src/modules/claude-provider/claude-sdk.adapter.ts

@@ -2,6 +2,7 @@ import type { ClaudeProvider, ClaudeRequest, ClaudeResponse } from "./claude-pro
 import type { Config } from "../../shared/config";
 import type pino from "pino";
 import { ClaudeProviderError } from "../../shared/errors";
+import { createMemoryMonitor } from "../../shared/memory-monitor";
 import {
   query,
   type Options,
@@ -26,10 +27,32 @@ export class ClaudeSdkAdapter implements ClaudeProvider {
     const startTime = Date.now();
     const childLogger = this.logger.child({ adapter: "sdk", prompt: request.prompt.slice(0, 50) });
 
+    const memMonitor = createMemoryMonitor({
+      logger: childLogger,
+      checkIntervalMs: 2000,
+      criticalFreeGB: 0.8,
+    });
+
     try {
       childLogger.info("Starting SDK query");
 
       const options = this.buildOptions(request);
+
+      // Memory monitor: abort query if memory becomes critical
+      const memoryAbortController = new AbortController();
+      memMonitor.onCritical(() => {
+        childLogger.error("Critical memory: aborting SDK query");
+        memoryAbortController.abort();
+      });
+
+      // Chain abort controllers if request already has a timeout
+      if (options.abortController) {
+        const originalController = options.abortController;
+        originalController.signal.addEventListener("abort", () => memoryAbortController.abort());
+      }
+      options.abortController = memoryAbortController;
+
+      memMonitor.start();
       const q = query({ prompt: request.prompt, options });
 
       // AsyncGeneratorを消費してClaudeResponseにマッピング
@@ -48,10 +71,21 @@ export class ClaudeSdkAdapter implements ClaudeProvider {
           const textBlocks = assistantMsg.message.content.filter(
             (block: { type: string }) => block.type === "text"
           );
+          
+          childLogger.debug({ 
+            contentLength: assistantMsg.message.content.length, 
+            textBlockCount: textBlocks.length,
+            blockTypes: assistantMsg.message.content.map((b: { type: string }) => b.type)
+          }, "Assistant message content");
+          
           if (textBlocks.length > 0) {
             lastAssistantMessage = textBlocks
               .map((block: { text?: string }) => block.text ?? "")
               .join("\n");
+            childLogger.debug({ 
+              textLength: lastAssistantMessage.length, 
+              textPreview: lastAssistantMessage.slice(0, 300) 
+            }, "Extracted text from assistant message");
           }
           actualModel = assistantMsg.message.model ?? actualModel;
 
@@ -64,8 +98,22 @@ export class ClaudeSdkAdapter implements ClaudeProvider {
           resultMessage = message as SDKResultMessage;
           if (resultMessage.subtype === "success") {
             const successMsg = resultMessage as SDKResultSuccess;
-            lastAssistantMessage = successMsg.result;
+            childLogger.debug({ 
+              sdkResultLength: successMsg.result?.length ?? 0, 
+              sdkResultPreview: successMsg.result?.slice(0, 200) ?? "",
+              hasResult: !!successMsg.result,
+              willOverwrite: !!lastAssistantMessage
+            }, "SDK result message received");
+            
+            // Result message contains the final output; use it if available
+            if (successMsg.result) {
+              lastAssistantMessage = successMsg.result;
+            }
             exitCode = 0;
+            childLogger.debug({ 
+              finalLength: lastAssistantMessage.length, 
+              finalPreview: lastAssistantMessage.slice(0, 200) 
+            }, "Result success");
           } else {
             const errorMsg = resultMessage as SDKResultError;
             error = errorMsg.errors.join("; ");
@@ -74,6 +122,7 @@ export class ClaudeSdkAdapter implements ClaudeProvider {
         }
       }
 
+      memMonitor.stop();
       const duration = Date.now() - startTime;
 
       if (exitCode !== 0) {
@@ -85,14 +134,22 @@ export class ClaudeSdkAdapter implements ClaudeProvider {
 
       childLogger.info({ duration, model: actualModel }, "SDK query completed");
 
-      return {
+      const response: ClaudeResponse = {
         result: lastAssistantMessage,
         exitCode,
         model: actualModel,
         effortLevel: request.effortLevel ?? "medium",
         duration,
       };
+      
+      childLogger.debug({ 
+        responseLength: response.result.length, 
+        responsePreview: response.result.slice(0, 300) 
+      }, "Returning response");
+
+      return response;
     } catch (err) {
+      memMonitor.stop();
       const duration = Date.now() - startTime;
       childLogger.error({ err, duration }, "SDK query error");
 
@@ -121,10 +178,10 @@ export class ClaudeSdkAdapter implements ClaudeProvider {
     // Output Format
     if (request.outputFormat === "json") {
       // JSON出力を要求する場合、schema指定が必要
-      // ここでは汎用的なschemaを使用
+      // jsonSchemaが指定されていればそれを使用、なければ汎用的なschemaを使用
       options.outputFormat = {
         type: "json_schema",
-        schema: {
+        schema: request.jsonSchema ?? {
           type: "object",
           properties: {
             result: { type: "string" },

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

@@ -39,9 +39,13 @@ describe("runPipeline", () => {
       logger: {
         info: mock(() => {}),
         error: mock(() => {}),
+        warn: mock(() => {}),
+        debug: mock(() => {}),
         child: mock(() => ({
           info: mock(() => {}),
           error: mock(() => {}),
+          warn: mock(() => {}),
+          debug: mock(() => {}),
         })),
       } as any,
       stores: {
@@ -113,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,18 +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 } from "../../git-workspace";
-import { executeTddPipeline } from "../../task-execution";
-import {
-  detectProjectType,
-  detectPackageManager,
-  detectTestFramework,
-  detectFramework,
-  detectOrm,
-  detectArchitecturePattern,
-  createBunFileChecker,
-} from "../../planning";
+import { getCurrentBranch, cleanupOrphanedFromPreviousRuns } from "../../git-workspace";
+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")
@@ -29,14 +21,15 @@ export function createRunCommand(getApp: () => App): Command {
     .option("--persist <mode>", "Persistence mode: memory or fs", "memory")
     .option("--debug", "Enable debug logging")
     .option("--no-dashboard", "Disable dashboard server")
-    .option("--provider <type>", "Default provider: cli or sdk", "cli")
+    .option("--provider <type>", "Default provider: cli or sdk", "sdk")
     .option("--repos <paths>", "Comma-separated repository paths for multi-repo mode")
     .option("--strategy <type>", "Multi-repo strategy: independent or coordinated", "independent")
     .option("--plugins <paths>", "Comma-separated plugin paths to load")
-    .action(async (requirementsPath: string) => {
+    .option("--keep-worktrees", "Keep worktrees and branches after completion (default: auto-cleanup)", false)
+    .action(async (requirementsPath: string, cmdOptions: { keepWorktrees?: boolean }) => {
       try {
         const app = getApp();
-        await runPipeline(app, requirementsPath);
+        await runPipeline(app, requirementsPath, cmdOptions.keepWorktrees ?? false);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         console.error("Run pipeline failed:", message);
@@ -50,8 +43,8 @@ export function createRunCommand(getApp: () => App): Command {
 /**
  * メインパイプライン実行
  */
-export async function runPipeline(app: App, requirementsPath: string): Promise<void> {
-  const { config, logger, eventBus, planningService, dispatcher, processManager, worktreeManager, providerRegistry, stores } = app;
+export async function runPipeline(app: App, requirementsPath: string, keepWorktrees = false): Promise<void> {
+  const { config, logger, eventBus, planningService, dispatcher, processManager, worktreeManager, stores, branchManager } = app;
 
   // Validate requirements file exists
   const reqFile = Bun.file(requirementsPath);
@@ -61,6 +54,16 @@ export async function runPipeline(app: App, requirementsPath: string): Promise<v
 
   logger.info({ requirementsPath }, "Starting AAD pipeline");
 
+  // 0. Memory check
+  await checkMemoryAndWarn(logger);
+
+  // 0.5. Cleanup orphaned worktrees/branches from previous runs
+  try {
+    await cleanupOrphanedFromPreviousRuns(worktreeManager, logger);
+  } catch (error) {
+    logger.warn({ error }, "Orphaned worktree cleanup failed (non-critical)");
+  }
+
   // 1. RunId生成 + 現在ブランチ取得
   const runId = createRunId(randomUUID());
   const parentBranch = await getCurrentBranch(process.cwd());
@@ -124,9 +127,9 @@ export async function runPipeline(app: App, requirementsPath: string): Promise<v
     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",
@@ -134,60 +137,15 @@ export async function runPipeline(app: App, requirementsPath: string): Promise<v
     });
   }
 
-  // 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;
-      logger.info({ taskId, workerId }, "Task dispatched, starting TDD pipeline");
+  // 4.5. Install graceful shutdown handler
+  installShutdownHandler({
+    runId,
+    stores: { runStore: stores.runStore, taskStore: stores.taskStore },
+    logger,
+  });
 
-      void (async () => {
-        try {
-          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 });
-        } 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...");
@@ -207,16 +165,23 @@ export async function runPipeline(app: App, requirementsPath: string): Promise<v
   // 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);
   });
 
@@ -233,90 +198,49 @@ export async function runPipeline(app: App, requirementsPath: string): Promise<v
     logger.info({ runId }, "Pipeline completed successfully");
     console.log("✅ Pipeline completed successfully!");
   }
-}
 
-/**
- * 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,
-    };
+  // 9. Auto-cleanup worktrees and branches (unless --keep-worktrees)
+  if (!keepWorktrees) {
+    console.log("\n🧹 Cleaning up worktrees and branches...");
+    logger.info({ runId }, "Auto-cleanup started");
+
+    try {
+      // List all worktrees
+      const worktrees = await worktreeManager.listWorktrees();
+      const worktreeBase = `${process.cwd()}/.aad/worktrees`;
+      const runWorktrees = worktrees.filter(
+        (wt) => wt.path.startsWith(worktreeBase) 
+             && wt.branch.includes(runId)  // Check branch name for runId
+             && !wt.path.includes(`parent-${runId}`)  // Keep parent worktree (contains merge results)
+      );
+
+      // Remove worktrees for this run
+      let removed = 0;
+      for (const worktree of runWorktrees) {
+        try {
+          await worktreeManager.removeWorktree(worktree.path, false);
+          removed++;
+          logger.debug({ path: worktree.path }, "Worktree removed");
+        } catch (error) {
+          logger.error({ path: worktree.path, error }, "Failed to remove worktree");
+        }
+      }
 
-    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",
-    };
-  }
-}
+      // Prune orphaned worktrees
+      await worktreeManager.pruneWorktrees();
 
-/**
- * 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];
-}
+      // Cleanup orphaned branches for this run (force delete merged branches)
+      const deletedBranches = await branchManager.cleanupOrphanBranches(runId, true);
 
-/**
- * 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";
+      console.log(`  Removed ${removed} worktree(s)`);
+      console.log(`  Deleted ${deletedBranches.length} branch(es)`);
+      logger.info({ runId, removedWorktrees: removed, deletedBranches: deletedBranches.length }, "Auto-cleanup completed");
+    } catch (error) {
+      logger.error({ runId, error }, "Auto-cleanup failed");
+      console.error("  ⚠️  Cleanup failed (non-critical)");
+    }
+  } else {
+    logger.info({ runId }, "Auto-cleanup skipped (--keep-worktrees)");
+  }
 }
+