@ronkovic/aad 0.3.9 → 0.4.0

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

@@ -0,0 +1,149 @@
+/**
+ * Planning Service Tests
+ * Verifies task planning orchestration and task_plan.json persistence
+ */
+
+import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
+import { PlanningService } from "../planning.service";
+import { EventBus } from "@aad/shared/events";
+import { loadConfig } from "@aad/shared/config";
+import { pino } from "pino";
+import { createRunId } from "@aad/shared/types";
+import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { ClaudeProvider } from "../../claude-provider";
+
+describe("PlanningService - task_plan.json persistence", () => {
+  let service: PlanningService;
+  let mockProvider: ClaudeProvider;
+  let eventBus: EventBus;
+  let logger: import("pino").Logger;
+  let testDocsDir: string;
+
+  beforeEach(async () => {
+    eventBus = new EventBus();
+    logger = pino({ level: "silent" });
+    const config = loadConfig({ AAD_NUM_WORKERS: "2" });
+
+    // Create temp docs directory for testing
+    testDocsDir = join(tmpdir(), `aad-test-docs-${Date.now()}`);
+    await mkdir(testDocsDir, { recursive: true });
+
+    // Mock Claude provider that writes valid task_plan.json
+    mockProvider = {
+      call: mock(async (request) => {
+        // Extract taskPlanFilePath from prompt
+        const match = request.prompt.match(/Write.*to the following path:\s*([^\n]+)/);
+        if (!match?.[1]) {
+          throw new Error("Could not find task_plan.json path in prompt");
+        }
+        const taskPlanFilePath = match[1].trim();
+
+        // Write valid task_plan.json
+        const taskPlan = {
+          run_id: "test-run-123",
+          parent_branch: "main",
+          tasks: [
+            {
+              task_id: "task-001",
+              title: "Test Task 1",
+              description: "Test description",
+              files_to_modify: ["file1.ts"],
+              depends_on: [],
+              priority: 1,
+            },
+          ],
+        };
+
+        await writeFile(taskPlanFilePath, JSON.stringify(taskPlan, null, 2));
+
+        return {
+          exitCode: 0,
+          result: "Task plan written successfully",
+        };
+      }) as any,
+    };
+
+    service = new PlanningService(mockProvider, eventBus, config, logger);
+  });
+
+  afterEach(async () => {
+    // Cleanup test docs directory
+    await rm(testDocsDir, { recursive: true, force: true });
+  });
+
+  test("persists task_plan.json to docs directory on successful planning", async () => {
+    const runId = createRunId("test-run-123");
+    const requirementsPath = join(testDocsDir, "requirements.md");
+    await writeFile(requirementsPath, "# Test Requirements\n\nTest content");
+
+    const taskPlan = await service.planTasks({
+      runId,
+      parentBranch: "main",
+      requirementsPath,
+      targetDocsDir: testDocsDir,
+      projectRoot: process.cwd(),
+    });
+
+    expect(taskPlan).toBeDefined();
+    expect(taskPlan.tasks.length).toBe(1);
+
+    // Verify task_plan.json was persisted to docs directory
+    const persistedPath = join(testDocsDir, "task_plan.json");
+    const persistedContent = await readFile(persistedPath, "utf-8");
+    const persistedPlan = JSON.parse(persistedContent);
+
+    expect(persistedPlan.run_id).toBe("test-run-123");
+    expect(persistedPlan.parent_branch).toBe("main");
+    expect(persistedPlan.tasks.length).toBe(1);
+    expect(persistedPlan.tasks[0].task_id).toBe("task-001");
+  });
+
+  test("handles persistence error gracefully (non-critical)", async () => {
+    const runId = createRunId("test-run-456");
+    const requirementsPath = join(testDocsDir, "requirements.md");
+    await writeFile(requirementsPath, "# Test Requirements\n\nTest content");
+
+    // Use invalid docs directory (permission denied scenario)
+    const invalidDocsDir = "/invalid/path/that/does/not/exist";
+
+    // Planning should succeed even if persistence fails
+    const taskPlan = await service.planTasks({
+      runId,
+      parentBranch: "main",
+      requirementsPath,
+      targetDocsDir: invalidDocsDir,
+      projectRoot: process.cwd(),
+    });
+
+    expect(taskPlan).toBeDefined();
+    expect(taskPlan.tasks.length).toBe(1);
+  });
+
+  test("creates target directory if it does not exist", async () => {
+    const runId = createRunId("test-run-789");
+    const requirementsPath = join(testDocsDir, "requirements.md");
+    await writeFile(requirementsPath, "# Test Requirements\n\nTest content");
+
+    // Use nested directory that doesn't exist yet
+    const nestedDocsDir = join(testDocsDir, "nested", "docs", "dir");
+
+    const taskPlan = await service.planTasks({
+      runId,
+      parentBranch: "main",
+      requirementsPath,
+      targetDocsDir: nestedDocsDir,
+      projectRoot: process.cwd(),
+    });
+
+    expect(taskPlan).toBeDefined();
+
+    // Verify directory was created and file was persisted
+    const persistedPath = join(nestedDocsDir, "task_plan.json");
+    const persistedContent = await readFile(persistedPath, "utf-8");
+    const persistedPlan = JSON.parse(persistedContent);
+
+    expect(persistedPlan.tasks.length).toBe(1);
+  });
+});

package/src/modules/planning/__tests__/project-detection.test.ts

@@ -162,7 +162,13 @@ describe("detectPackageManager", () => {
     expect(result).toBe("npm");
   });
 
-  test("detects bun", async () => {
+  test("detects bun (text lockfile)", async () => {
+    const checker = createMockFileChecker({ "bun.lock": "" });
+    const result = await detectPackageManager("/test", checker);
+    expect(result).toBe("bun");
+  });
+
+  test("detects bun (binary lockfile)", async () => {
     const checker = createMockFileChecker({ "bun.lockb": "" });
     const result = await detectPackageManager("/test", checker);
     expect(result).toBe("bun");

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

@@ -11,7 +11,7 @@ import { parseTaskPlan, validateTaskPlan } from "../task-queue";
 import { validateFileConflicts, formatConflictErrors } from "./file-conflict-validator";
 import { analyzeProject, createBunFileChecker, type FileChecker } from "./project-detection";
 import { join } from "node:path";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { mkdtemp, readFile, rm, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 
 export interface PlanTasksParams {
@@ -141,6 +141,15 @@ export class PlanningService {
         taskCount: taskPlan.tasks.length,
       });
 
+      // Save task_plan.json to targetDocsDir
+      try {
+        await mkdir(targetDocsDir, { recursive: true });
+        await Bun.write(join(targetDocsDir, "task_plan.json"), taskPlanJsonStr);
+        this.logger.debug({ targetDocsDir }, "Persisted task_plan.json");
+      } catch (error) {
+        this.logger.warn({ error, targetDocsDir }, "Failed to persist task_plan.json (non-critical)");
+      }
+
       return taskPlan;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -202,7 +211,12 @@ Parent branch: ${parentBranch}
 Instructions:
 1. Read the requirements file/directory
 2. Split into independent tasks with clear file assignments
-3. Set depends_on for tasks that modify the same files (later task depends on earlier)
+3. Set depends_on based on:
+   - File overlap: tasks that modify the same files (later task depends on earlier)
+   - Logical dependency: tasks whose output is consumed by another task
+     (e.g., DB schema → API that queries the DB → Frontend that calls the API)
+   - Import dependency: tasks that create modules imported by other tasks
+   If no dependency exists, use an empty array []
 4. Set priority (1 = highest)
 5. CRITICAL: Write the result as a JSON file to the following path:
    ${taskPlanFilePath}

package/src/modules/planning/project-detection.ts

@@ -36,6 +36,7 @@ export type TestFramework =
   | "jest"
   | "bun:test"
   | "mocha"
+  | "playwright"
   | "go-test"
   | "cargo-test"
   | "terraform-validate"
@@ -204,7 +205,8 @@ export async function detectPackageManager(
   if (await checker.exists(path.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
   if (await checker.exists(path.join(projectRoot, "yarn.lock"))) return "yarn";
   if (await checker.exists(path.join(projectRoot, "package-lock.json"))) return "npm";
-  if (await checker.exists(path.join(projectRoot, "bun.lockb"))) return "bun";
+  if (await checker.exists(path.join(projectRoot, "bun.lock"))) return "bun"; // text format (v1.2+)
+  if (await checker.exists(path.join(projectRoot, "bun.lockb"))) return "bun"; // binary format (legacy)
 
   // Rust/Go
   if (await checker.exists(path.join(projectRoot, "Cargo.lock"))) return "cargo";
@@ -290,6 +292,7 @@ export async function detectTestFramework(
         if (content.includes('"bun-types"') || content.includes('"@types/bun"')) {
           return "bun:test";
         }
+        if (content.includes('"@playwright/test"')) return "playwright";
         if (content.includes('"vitest"')) return "vitest";
         if (content.includes('"jest"')) return "jest";
         if (content.includes('"mocha"')) return "mocha";

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

@@ -24,6 +24,7 @@ describe("ProcessManager", () => {
         teams: { splitter: false, reviewer: false },
         memorySync: false,
         dashboard: { enabled: false, port: 7333, host: "localhost" },
+        git: { autoPush: false },
       },
       logger,
     });

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

@@ -43,6 +43,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     const mockProvider: ClaudeProvider = {
@@ -139,6 +140,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     let callCount = 0;
@@ -225,6 +227,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     const mockProvider: ClaudeProvider = {
@@ -315,6 +318,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     let phaseCount = 0;
@@ -416,6 +420,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     const mockProvider: ClaudeProvider = {
@@ -512,6 +517,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     let callCount = 0;
@@ -572,6 +578,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     const mockProvider: ClaudeProvider = {
@@ -629,6 +636,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     const mockProvider: ClaudeProvider = {
@@ -687,6 +695,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     const mockProvider: ClaudeProvider = {
@@ -738,6 +747,7 @@ describe("executeTddPipeline", () => {
       teams: { splitter: false, reviewer: false },
       memorySync: true,
       dashboard: { enabled: true, port: 7333, host: "localhost" },
+    git: { autoPush: false },
     };
 
     const mockProvider: ClaudeProvider = {
@@ -757,4 +767,80 @@ describe("executeTddPipeline", () => {
     expect(result.status).toBe("failed");
     expect(result.error).toBe("Unknown error");
   });
+
+  test("emits warn log events when commit fails (invalid workspace)", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-commit-warn"),
+      title: "Commit warning test",
+      description: "Test warn logs on commit failure",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    // workspace.path が無効 → git add/commit は全て失敗する想定
+    const workspace: WorkspaceInfo = {
+      path: "/nonexistent-invalid-workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+      git: { autoPush: false },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return { result: "OK", exitCode: 0, model: "claude-sonnet-4-5", effortLevel: "medium", duration: 1000 };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return { success: true, message: "Merged" };
+      },
+    } as unknown as MergeService;
+
+    const events: Array<{ type: string; entry?: { level?: string; message?: string } }> = [];
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit(event: any) {
+        events.push(event);
+      },
+    } as unknown as EventBus;
+
+    const mockSpawner = {
+      async spawn() {
+        return { exitCode: 0, stdout: "OK", stderr: "" };
+      },
+    };
+
+    await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-cw"), config,
+      mockProvider, mockMergeService, mockEventBus, mockSpawner
+    );
+
+    const warnEvents = events.filter(
+      (e) => e.type === "log:entry" && e.entry?.level === "warn"
+    );
+
+    // Red/Green 両フェーズのコミット失敗 warn が発火
+    expect(warnEvents.length).toBeGreaterThanOrEqual(2);
+    expect(warnEvents.some((e) => e.entry?.message?.includes("Red phase"))).toBe(true);
+    expect(warnEvents.some((e) => e.entry?.message?.includes("Green phase"))).toBe(true);
+  });
 });

package/src/modules/task-execution/__tests__/tester-verify.test.ts

@@ -200,16 +200,17 @@ describe("buildTestCommand", () => {
     expect(buildTestCommand(workspace)).toEqual(["./gradlew", "test"]);
   });
 
-  test("throws error for unknown test framework", () => {
+  test("returns fallback for unknown test framework", () => {
     const workspace: WorkspaceInfo = {
       path: "/path/to/workspace",
       language: "unknown",
-      packageManager: "unknown",
+      packageManager: "npm",
       framework: "unknown",
       testFramework: "unknown",
     };
 
-    expect(() => buildTestCommand(workspace)).toThrow("Unsupported test framework");
+    // After fallback implementation, unknown should return npm test
+    expect(buildTestCommand(workspace)).toEqual(["npm", "test"]);
   });
 });
 

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

@@ -3,6 +3,7 @@ import type {
   WorkspaceInfo,
   RunId,
   TaskExecutionResult,
+  PreviousFailure,
 } from "@aad/shared/types";
 import type { Config } from "@aad/shared/config";
 import type { ClaudeProvider } from "@aad/claude-provider";
@@ -19,6 +20,14 @@ import { runReviewer } from "./phases/reviewer";
 import { runMergePhase } from "./phases/merge";
 import { PhaseError } from "@aad/shared/errors";
 
+/**
+ * Retry context for TDD pipeline execution
+ */
+export interface RetryContext {
+  retryCount: number;
+  previousFailure?: PreviousFailure;
+}
+
 /**
  * Execute full TDD pipeline for a task
  * Phases: Red → Green → Verify → Review → Merge
@@ -34,7 +43,8 @@ export async function executeTddPipeline(
   provider: ClaudeProvider,
   mergeService: MergeService,
   eventBus: EventBus,
-  testSpawner?: ProcessSpawner
+  testSpawner?: ProcessSpawner,
+  retryContext?: RetryContext
 ): Promise<TaskExecutionResult> {
   const startTime = Date.now();
 
@@ -74,7 +84,7 @@ export async function executeTddPipeline(
       effortLevel: testerEffort,
       model: config.models.tester,
       timeout: config.timeouts.claude * 1000,
-    });
+    }, retryContext);
 
     if (!redResult.success) {
       eventBus.emit({
@@ -98,6 +108,33 @@ export async function executeTddPipeline(
       duration: Date.now() - redStart,
     });
 
+    // ===== Commit failing tests =====
+    try {
+      await gitExec(["add", "-A"], { cwd: workspace.path });
+      try {
+        await gitExec(["reset", "HEAD", "--", ".claude/"], { cwd: workspace.path });
+      } catch {
+        // .claude/ がない場合は無視
+      }
+      await gitExec(
+        ["commit", "--no-gpg-sign", "-m", `test: Add failing tests for ${task.title}`],
+        { cwd: workspace.path }
+      );
+    } catch (commitError) {
+      // If commit fails (e.g., no changes), log but don't fail the pipeline
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "warn",
+          service: "task-execution",
+          message: "Commit after Red phase failed (no changes?)",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+          error: String(commitError),
+        },
+      });
+    }
+
     // ===== Phase 2: Green - Implement minimal code =====
     eventBus.emit({
       type: "execution:phase:started",
@@ -110,7 +147,7 @@ export async function executeTddPipeline(
       effortLevel: implementerEffort,
       model: config.models.implementer,
       timeout: config.timeouts.claude * 1000,
-    });
+    }, retryContext);
 
     if (!greenResult.success) {
       eventBus.emit({
@@ -138,13 +175,29 @@ export async function executeTddPipeline(
     // Commit changes after Green phase so they can be merged later
     try {
       await gitExec(["add", "-A"], { cwd: workspace.path });
+      try {
+        await gitExec(["reset", "HEAD", "--", ".claude/"], { cwd: workspace.path });
+      } catch {
+        // .claude/ がない場合は無視
+      }
       await gitExec(
         ["commit", "--no-gpg-sign", "-m", `feat: Implement ${task.title}`],
         { cwd: workspace.path }
       );
-    } catch (_error) {
+    } catch (commitError) {
       // 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
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "warn",
+          service: "task-execution",
+          message: "Commit after Green phase failed (no changes?)",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+          error: String(commitError),
+        },
+      });
     }
 
     // ===== Phase 3: Verify - Run tests =====
@@ -221,6 +274,36 @@ export async function executeTddPipeline(
       });
     }
 
+    // ===== Commit review changes (if any) =====
+    try {
+      const statusResult = await gitExec(["status", "--porcelain"], { cwd: workspace.path });
+      if (statusResult.stdout.trim() !== "") {
+        await gitExec(["add", "-A"], { cwd: workspace.path });
+        try {
+          await gitExec(["reset", "HEAD", "--", ".claude/"], { cwd: workspace.path });
+        } catch {
+          // .claude/ がない場合は無視
+        }
+        await gitExec(
+          ["commit", "--no-gpg-sign", "-m", `refactor: Apply review feedback for ${task.title}`],
+          { cwd: workspace.path }
+        );
+      }
+    } catch (commitError) {
+      // If commit fails, log but don't fail the pipeline
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "warn",
+          service: "task-execution",
+          message: "Commit after Review phase failed",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+          error: String(commitError),
+        },
+      });
+    }
+
     // ===== Phase 5: Merge - Merge to parent branch =====
     eventBus.emit({
       type: "execution:phase:started",

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

@@ -1,5 +1,6 @@
 import type { Task, WorkspaceInfo, EffortLevel, PhaseResult } from "@aad/shared/types";
 import type { ClaudeProvider } from "@aad/claude-provider";
+import type { RetryContext } from "../executor";
 
 export interface ImplementerGreenOptions {
   effortLevel?: EffortLevel;
@@ -10,10 +11,10 @@ export interface ImplementerGreenOptions {
 /**
  * Build TDD Green phase prompt for implementer agent
  */
-export function buildGreenPhasePrompt(task: Task, workspace: WorkspaceInfo): string {
+export function buildGreenPhasePrompt(task: Task, workspace: WorkspaceInfo, retryContext?: RetryContext): string {
   const codingConventions = getCodingConventions(workspace.language);
 
-  return `implementerエージェントとして、TDD Green フェーズを実行してください。
+  let prompt = `implementerエージェントとして、TDD Green フェーズを実行してください。
 
 Task ID: ${task.taskId as string}
 Task Title: ${task.title}
@@ -28,10 +29,25 @@ Task Description: ${task.description}
 
 実行内容:
 1. 作成されたテストを確認する
-2. テストをパスするための最小限の実装を書く（${codingConventions}）
+2. テストをパスするための最小限の実装を書く(${codingConventions})
 3. テストを実行してパスすることを確認する
 
 注意: 過度な最適化やリファクタリングは行わず、テストをパスするための最小限のコードを書いてください。`;
+
+  if (retryContext?.previousFailure) {
+    prompt += `\n\n⚠️ リトライ情報 (${retryContext.retryCount}回目):
+前回のフェーズ「${retryContext.previousFailure.phase}」で失敗しました。
+エラー: ${retryContext.previousFailure.error}`;
+
+    if (retryContext.previousFailure.testOutput) {
+      prompt += `\n\n前回のテスト出力:
+${retryContext.previousFailure.testOutput}`;
+    }
+
+    prompt += `\n\n前回の失敗パターンを特に注意して実装してください。`;
+  }
+
+  return prompt;
 }
 
 /**
@@ -72,9 +88,10 @@ export async function runImplementerGreen(
   task: Task,
   workspace: WorkspaceInfo,
   provider: ClaudeProvider,
-  options: ImplementerGreenOptions = {}
+  options: ImplementerGreenOptions = {},
+  retryContext?: RetryContext
 ): Promise<PhaseResult> {
-  const prompt = buildGreenPhasePrompt(task, workspace);
+  const prompt = buildGreenPhasePrompt(task, workspace, retryContext);
 
   const response = await provider.call({
     prompt,

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

@@ -78,7 +78,7 @@ export async function runMergePhase(
   }
 
   // Merge failed with conflicts
-  const conflicts = mergeResult.conflicts ?? [];
+  let conflicts = mergeResult.conflicts ?? [];
 
   if (conflicts.length === 0) {
     // Merge failed but no conflicts detected (unexpected error)
@@ -90,7 +90,49 @@ export async function runMergePhase(
     };
   }
 
-  // Resolve conflicts with Claude
+  // Auto-resolve generated files (lockfiles, snapshots)
+  const AUTO_RESOLVE_PATTERNS = [
+    "package-lock.json",
+    "yarn.lock",
+    "bun.lockb",
+    "pnpm-lock.yaml",
+    "go.sum",
+    "Cargo.lock",
+    ".snap",
+  ];
+
+  const autoResolved: string[] = [];
+  for (const conflict of conflicts) {
+    if (AUTO_RESOLVE_PATTERNS.some((pattern) => conflict.includes(pattern))) {
+      try {
+        await gitExec(["checkout", "--theirs", conflict], { cwd: parentWorktree });
+        await gitExec(["add", conflict], { cwd: parentWorktree });
+        autoResolved.push(conflict);
+      } catch (_resolveError) {
+        // If auto-resolve fails, leave it for Claude
+      }
+    }
+  }
+
+  // Remove auto-resolved conflicts from list
+  conflicts = conflicts.filter((c) => !autoResolved.includes(c));
+
+  // If all conflicts are auto-resolved, complete merge
+  if (conflicts.length === 0) {
+    try {
+      await gitExec(["commit", "--no-gpg-sign", "--no-edit"], { cwd: parentWorktree });
+      return {
+        success: true,
+        output: `Auto-resolved conflicts: ${autoResolved.join(", ")}`,
+        hadConflict: true,
+        duration: Date.now() - startTime,
+      };
+    } catch (_commitError) {
+      // Commit failed, fall through to Claude resolution
+    }
+  }
+
+  // Resolve remaining conflicts with Claude
   const prompt = buildConflictResolutionPrompt(task, conflicts);
 
   const response = await provider.call({