@ronkovic/aad 0.3.6 → 0.3.8

package/README.md

@@ -5,19 +5,25 @@ TypeScript/Bun製マルチエージェント開発オーケストレーター。
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue)](https://www.typescriptlang.org/)
 [![Bun](https://img.shields.io/badge/Bun-1.2+-black)](https://bun.sh/)
-[![Tests](https://img.shields.io/badge/tests-738%2B%20passing-brightgreen)]()
-[![Version](https://img.shields.io/badge/version-0.3.0-orange)]()
+[![npm](https://img.shields.io/npm/v/@ronkovic/aad)](https://www.npmjs.com/package/@ronkovic/aad)
+[![Tests](https://img.shields.io/badge/tests-913%20passing-brightgreen)]()
+[![Version](https://img.shields.io/badge/version-0.3.7-orange)]()
 
 ## 主要機能
 
 - **マルチエージェント並列実行**: 複数のClaudeエージェントが独立したタスクを並列処理
 - **TDDパイプライン**: Red → Green → Verify → Review → Merge の自動化されたテスト駆動開発
-- **マルチリポジトリ対応**: 複数リポジトリにまたがるタスクの統合管理 *(v0.3.0)*
-- **プラグインシステム**: カスタムアダプター・パイプラインステップの拡張 *(v0.3.0)*
+- **インタラクティブモード**: `aad` で対話型ウィザードを起動、認証・プロジェクト設定を簡単に *(v0.3.6)*
+- **セルフアップデート**: `aad update` で最新版に自動更新 *(v0.3.6)*
+- **スマートブランチ命名**: 要件ドキュメントから自動でconventional commit prefix付きブランチ名を生成 *(v0.3.7)*
+- **適応的エフォート調整**: タスク複雑度に応じてClaudeのeffort levelを自動調整
+- **マルチリポジトリ対応**: 複数リポジトリにまたがるタスクの統合管理
+- **プラグインシステム**: カスタムアダプター・パイプラインステップの拡張
 - **Git Workspace管理**: タスクごとに独立したworktreeを自動作成・管理
 - **依存関係解決**: タスク間の依存関係を自動検出し、適切な順序で実行
 - **リアルタイム監視**: Webダッシュボードで進捗・ログをリアルタイム表示
 - **構造化ログ**: pinoによる構造化ログで詳細なトレーシングが可能
+- **メモリ安全機構**: OOMを防止する自動メモリゲート・シーケンシャルフォールバック
 
 ## アーキテクチャ
 
@@ -129,26 +135,34 @@ bun run dev
 ### 2. タスク実行
 
 ```bash
+# 直接実行
 aad run requirements.md --workers 4
+
+# インタラクティブモード（対話型ウィザード）
+aad
 ```
 
 AADが自動的に:
-1. タスクを分解・依存関係を解析
-2. 各タスク用のworktreeを作成
-3. 4つのワーカーで並列実行 (TDD: テスト作成 → 実装 → 検証 → レビュー)
-4. 親ブランチへのマージ
+1. 要件ドキュメントからfeature名を生成（例: `feat/user-auth-impl`）
+2. タスクを分解・依存関係を解析
+3. 親ブランチ + タスクブランチをworktreeで作成
+4. ワーカーで並列実行 (TDD: テスト作成 → 実装 → 検証 → レビュー)
+5. 親ブランチへのマージ
 
-### 3. 進捗確認
+### 3. 進捗確認・管理
 
 ```bash
 # ステータス確認
-aad status
+aad status [run_id]
 
 # 実行の再開
 aad resume <run_id>
 
 # worktreeのクリーンアップ
-aad cleanup
+aad cleanup [run_id] [--force]
+
+# バージョン確認・アップデート
+aad update [--check]
 ```
 
 ### 4. Webダッシュボード
@@ -256,6 +270,20 @@ describe("MyModule", () => {
 
 設定では短縮名(`sonnet`、`opus`、`haiku`)またはフルネームが使用できます。
 
+## ブランチフロー
+
+AADは要件ドキュメントからconventional commit prefix付きのfeature名を自動生成し、以下のブランチ構造を作成します:
+
+```
+main (ソースブランチ)
+  └─ feat/user-auth-impl/parent      ← 親ブランチ + worktree
+       ├─ feat/user-auth-impl/task-001  ← タスクブランチ（parentから分岐）
+       ├─ feat/user-auth-impl/task-002
+       └─ feat/user-auth-impl/task-003
+```
+
+各タスクはparentブランチから分岐し、完了後にparentへマージされます。prefix（`feat/`, `fix/`, `refactor/`等）は要件の内容から自動判定されます。
+
 ## Claude Provider: SDK vs CLI
 
 AADはClaudeとの通信に2つのadapterを提供:
@@ -320,9 +348,7 @@ aad cleanup <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)
+- [npm Package](https://www.npmjs.com/package/@ronkovic/aad)
 - [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.6",
+  "version": "0.3.8",
   "description": "Autonomous Agent Development Orchestrator - Multi-agent TDD pipeline powered by Claude",
   "module": "src/main.ts",
   "type": "module",

package/src/__tests__/e2e/pipeline-e2e.test.ts

@@ -270,6 +270,12 @@ describe("E2E Pipeline", () => {
       result: { taskId: createTaskId("task-1"), status: "completed", duration: 50 },
     });
 
+    // Emit worker:idle to trigger dispatch (mirrors real task-dispatch-handler behavior)
+    eventBus.emit({
+      type: "worker:idle",
+      workerId: createWorkerId("w-1"),
+    });
+
     await waitFor(() => dispatchedTasks.length >= 2, 3000);
 
     expect(dispatchedTasks[1]).toBe(createTaskId("task-2"));

package/src/modules/cli/app.ts

@@ -77,16 +77,19 @@ export function createApp(options: AppOptions = {}): App {
   // 2. EventBus初期化
   const eventBus = new EventBusImpl();
 
-  // 3. Logger初期化
+  // 3. LogStore初期化 (loggerより先に必要)
+  const logStore = new LogStore();
+
+  // 4. Logger初期化 (dashboard有効時はlogStore+eventBusに橋渡し)
   const logger = createLogger({
     service: "aad-cli",
     debug: config.debug,
+    logStore: config.dashboard.enabled ? logStore : undefined,
+    eventBus: config.dashboard.enabled ? eventBus : undefined,
   });
   logger.debug({ config, options }, "AAD CLI starting");
 
-  // 4. LogStore + SSE Transport初期化
-  const logStore = new LogStore();
-  // SSE transport registers EventBus listeners internally; no direct reference needed
+  // SSE transport: EventBus経由のlog:entryをLogStoreに書く (手動emitされるログ用)
   createSSETransport({ logStore, eventBus });
 
   // 5. ProviderRegistry初期化

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

@@ -132,7 +132,7 @@ export async function resumeRun(app: App, runIdStr: string): Promise<void> {
       const branchResult = await import("../../git-workspace").then(
         (m) => m.getCurrentBranch(parentWorktreePath),
       );
-      if (branchResult?.startsWith("aad/")) {
+      if (branchResult && /^(feat|fix|docs|style|refactor|perf|test|chore)\//.test(branchResult)) {
         featureBranchName = branchResult;
       }
     } catch {

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

@@ -149,12 +149,12 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
   let parentWorktreePath: string | undefined;
   let featureBranchName: string | undefined;
   try {
-    const featureName = await generateFeatureName(
+    const { prefix, name: featureName } = await generateFeatureName(
       requirementsPath,
       providerRegistry.getProvider("implementer"),
       logger,
     );
-    featureBranchName = `aad/${featureName}/parent`;
+    featureBranchName = `${prefix}/${featureName}/parent`;
     const result = await worktreeManager.createParentWorktree(runId, parentBranch, featureBranchName);
     parentWorktreePath = result.worktreePath;
     featureBranchName = result.branch;
@@ -228,17 +228,25 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
       // List all worktrees
       const worktrees = await worktreeManager.listWorktrees();
       const worktreeBase = `${process.cwd()}/.aad/worktrees`;
+      // branch field from `git worktree list --porcelain` is full ref: "refs/heads/feat/..."
+      const featurePrefix = featureBranchName?.replace(/\/parent$/, "") ?? "";
       const runWorktrees = worktrees.filter(
-        (wt) => wt.path.startsWith(worktreeBase) 
-             && (wt.branch.includes(runId) || (featureBranchName && wt.branch.startsWith(featureBranchName.replace(/\/parent$/, ""))))  // Match by runId or feature name
-             && !wt.path.includes(`parent-${runId}`)  // Keep parent worktree (contains merge results)
+        (wt) => {
+          if (!wt.path.startsWith(worktreeBase)) return false;
+          const shortBranch = wt.branch.replace(/^refs\/heads\//, "");
+          const matchesRun = shortBranch.includes(runId) || (featurePrefix && shortBranch.startsWith(featurePrefix));
+          if (!matchesRun) return false;
+          // Keep parent worktree (contains merge results for review)
+          if (wt.path.includes(`parent-${runId}`)) return false;
+          return true;
+        }
       );
 
-      // Remove worktrees for this run
+      // Remove task worktrees (parent worktree is preserved)
       let removed = 0;
       for (const worktree of runWorktrees) {
         try {
-          await worktreeManager.removeWorktree(worktree.path, false);
+          await worktreeManager.removeWorktree(worktree.path, true);
           removed++;
           logger.debug({ path: worktree.path }, "Worktree removed");
         } catch (error) {
@@ -256,7 +264,7 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
       if (featureBranchName) {
         const featurePrefix = featureBranchName.replace(/\/parent$/, "");
         const featureBranches = await branchManager.cleanupOrphanBranches(
-          createRunId(featurePrefix.replace("aad/", "")),
+          createRunId(featurePrefix.replace(/^[^/]+\//, "")),
           true,
         );
         deletedBranches = [...deletedBranches, ...featureBranches];

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

@@ -28,7 +28,7 @@ export interface TaskDispatchContext {
   /** Path to the parent worktree where task branches are merged into.
    *  If not provided, falls back to process.cwd() (repo root). */
   parentWorktreePath?: string;
-  /** Feature branch name (e.g. aad/auth-feature/parent).
+  /** Feature branch name (e.g. feat/auth-feature/parent).
    *  Task branches are created from this branch. */
   featureBranchName?: string;
 }
@@ -61,10 +61,10 @@ export function registerTaskDispatchHandler(ctx: TaskDispatchContext): void {
       }
 
       // Derive task branch name from feature branch or runId
-      // e.g. aad/auth-feature/task-001 (from aad/auth-feature/parent)
+      // e.g. feat/auth-feature/task-001 (from feat/auth-feature/parent)
       const branchPrefix = featureBranchName
         ? featureBranchName.replace(/\/parent$/, "")
-        : `aad/${runId}`;
+        : `feat/${runId}`;
       const branchName = `${branchPrefix}/${taskId}`;
       const worktreePath = await worktreeManager.createTaskWorktree(taskId, branchName, featureBranchName);
       logger.info({ taskId, worktreePath, branchName }, "Worktree created");

package/src/modules/git-workspace/__tests__/worktree-cleanup.test.ts

@@ -34,11 +34,15 @@ describe("cleanupOrphanedFromPreviousRuns", () => {
           };
         }
         if (args[0] === "branch" && args[1] === "--list") {
-          return {
-            stdout: "  aad/run1/task-001\n  aad/run1/task-002\n",
-            stderr: "",
-            exitCode: 0,
-          };
+          // Only return branches for matching prefix pattern
+          if (args[2] === "aad/*") {
+            return {
+              stdout: "  aad/run1/task-001\n  aad/run1/task-002\n",
+              stderr: "",
+              exitCode: 0,
+            };
+          }
+          return { stdout: "", stderr: "", exitCode: 0 };
         }
         return { stdout: "", stderr: "", exitCode: 0 };
       }),

package/src/modules/git-workspace/__tests__/worktree-manager.test.ts

@@ -74,7 +74,7 @@ describe("WorktreeManager", () => {
     test("creates worktree with feature branch", async () => {
       const runId = createRunId("run-001");
       const parentBranch = "main";
-      const featureBranch = "aad/auth-feature/parent";
+      const featureBranch = "feat/auth-feature/parent";
 
       const result = await worktreeManager.createParentWorktree(runId, parentBranch, featureBranch);
 
@@ -92,9 +92,9 @@ describe("WorktreeManager", () => {
 
       const result = await worktreeManager.createParentWorktree(runId, parentBranch);
 
-      expect(result.branch).toBe("aad/run-001/parent");
+      expect(result.branch).toBe("feat/run-001/parent");
       expect(mockGitOps.gitExec).toHaveBeenCalledWith(
-        ["worktree", "add", "-b", "aad/run-001/parent", "/test/worktrees/parent-run-001", parentBranch],
+        ["worktree", "add", "-b", "feat/run-001/parent", "/test/worktrees/parent-run-001", parentBranch],
         expect.objectContaining({ cwd: repoRoot })
       );
     });

package/src/modules/git-workspace/branch-manager.ts

@@ -137,10 +137,17 @@ export class BranchManager {
    * Cleanup orphaned AAD branches (branches without worktrees)
    */
   async cleanupOrphanBranches(runId?: RunId, force = false): Promise<string[]> {
-    // Support both aad/* (slash) and aad-* (hyphen) patterns for backward compatibility
+    // Support aad/*, conventional commit prefixes (feat/*, fix/*, etc.), and legacy aad-* patterns
+    const conventionalPrefixes = ["aad", "feat", "fix", "docs", "style", "refactor", "perf", "test", "chore"];
     const patterns = runId
-      ? [`aad/${runId as string}/*`, `aad-*-${runId as string}*`]
-      : ["aad/*", "aad-*"];
+      ? [
+          ...conventionalPrefixes.map((p) => `${p}/${runId as string}/*`),
+          `aad-*-${runId as string}*`,
+        ]
+      : [
+          ...conventionalPrefixes.map((p) => `${p}/*`),
+          "aad-*",
+        ];
 
     this.logger?.info({ patterns, force }, "Cleaning up orphan branches");
 

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

@@ -1,5 +1,7 @@
 import type { Logger } from "pino";
 import type { TaskId } from "@aad/shared/types";
+import { readFile } from "node:fs/promises";
+import { resolve, join } from "node:path";
 import { gitExec } from "./git-exec";
 import { FileLock } from "../persistence";
 
@@ -14,6 +16,30 @@ export interface MergeResult {
   message?: string;
 }
 
+/**
+ * Resolve the actual .git directory for a path.
+ * Worktrees have a `.git` file containing "gitdir: <path>",
+ * while regular repos have a `.git` directory.
+ */
+async function resolveGitDir(worktreePath: string): Promise<string> {
+  const dotGit = join(worktreePath, ".git");
+  try {
+    const stat = await Bun.file(dotGit).exists();
+    if (!stat) return dotGit; // fallback
+
+    const content = await readFile(dotGit, "utf-8");
+    const match = content.match(/^gitdir:\s*(.+)$/m);
+    if (match?.[1]) {
+      const gitdir = match[1].trim();
+      // gitdir can be relative or absolute
+      return resolve(worktreePath, gitdir);
+    }
+    return dotGit; // It's a directory, not a file
+  } catch {
+    return dotGit; // fallback
+  }
+}
+
 /**
  * Merge task branches into parent branch with conflict detection
  */
@@ -35,7 +61,8 @@ export class MergeService {
     parentBranch: string,
     parentWorktree: string
   ): Promise<MergeResult> {
-    const lockDir = `${parentWorktree}/.git/aad-merge.lock`;
+    const gitDir = await resolveGitDir(parentWorktree);
+    const lockDir = join(gitDir, "aad-merge.lock");
     const lock = new FileLock({ lockDir, timeout: 60000, logger: this.logger });
 
     try {

package/src/modules/git-workspace/worktree-manager.ts

@@ -76,11 +76,11 @@ export class WorktreeManager {
    * Handles cases where a previous run left behind artifacts.
    */
   private async cleanupStaleWorktree(worktreePath: string, branch: string): Promise<void> {
-    // 1. Remove existing worktree directory if it exists
+    // 1. Remove existing worktree directory if it exists (no logger to suppress error-level output)
     try {
       await this.gitOps.gitExec(
         ["worktree", "remove", worktreePath, "--force"],
-        { cwd: this.repoRoot, logger: this.logger }
+        { cwd: this.repoRoot }
       );
       this.logger?.info({ worktreePath }, "Removed stale worktree");
     } catch {
@@ -99,11 +99,11 @@ export class WorktreeManager {
       // Non-critical
     }
 
-    // 3. Delete stale branch if it exists
+    // 3. Delete stale branch if it exists (no logger to suppress error-level git output)
     try {
       await this.gitOps.gitExec(
         ["branch", "-D", branch],
-        { cwd: this.repoRoot, logger: this.logger }
+        { cwd: this.repoRoot }
       );
       this.logger?.info({ branch }, "Deleted stale branch");
     } catch {
@@ -120,7 +120,7 @@ export class WorktreeManager {
     featureBranch?: string,
   ): Promise<{ worktreePath: string; branch: string }> {
     const worktreePath = join(this.worktreeBase, `parent-${runId as string}`);
-    const branch = featureBranch ?? `aad/${runId as string}/parent`;
+    const branch = featureBranch ?? `feat/${runId as string}/parent`;
 
     this.logger?.info({ runId, parentBranch, branch, worktreePath }, "Creating parent worktree");
 
@@ -128,7 +128,7 @@ export class WorktreeManager {
       await this.fsOps.mkdir(this.worktreeBase, { recursive: true });
 
       // Create worktree with a new branch based on parentBranch
-      // e.g. git worktree add -b aad/auth-feature/parent <path> main
+      // e.g. git worktree add -b feat/auth-feature/parent <path> main
       await this.gitOps.gitExec(
         ["worktree", "add", "-b", branch, worktreePath, parentBranch],
         { cwd: this.repoRoot, logger: this.logger }
@@ -287,28 +287,36 @@ export async function cleanupOrphanedFromPreviousRuns(
     // non-critical
   }
 
-  // 3. Delete all branches matching aad/*
+  // 3. Delete all branches matching aad/*, feat/*, fix/*, etc.
+  const branchPrefixes = ["aad", "feat", "fix", "docs", "style", "refactor", "perf", "test", "chore"];
   try {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const gitOps = (worktreeManager as any).gitOps as GitOps;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const repoRoot = (worktreeManager as any).repoRoot as string;
-    const result = await gitOps.gitExec(
-      ["branch", "--list", "aad/*"],
-      { cwd: repoRoot, logger },
-    );
-    const branches = result.stdout
-      .split("\n")
-      .map((b: string) => b.trim().replace(/^\* /, ""))
-      .filter((b: string) => b.length > 0);
 
-    for (const branch of branches) {
+    for (const prefix of branchPrefixes) {
       try {
-        await gitOps.gitExec(["branch", "-D", branch], { cwd: repoRoot, logger });
-        deletedBranches++;
-        logger.debug({ branch }, "Deleted orphaned branch");
+        const result = await gitOps.gitExec(
+          ["branch", "--list", `${prefix}/*`],
+          { cwd: repoRoot },
+        );
+        const branches = result.stdout
+          .split("\n")
+          .map((b: string) => b.trim().replace(/^[*+]\s*/, ""))
+          .filter((b: string) => b.length > 0);
+
+        for (const branch of branches) {
+          try {
+            await gitOps.gitExec(["branch", "-D", branch], { cwd: repoRoot });
+            deletedBranches++;
+            logger.debug({ branch }, "Deleted orphaned branch");
+          } catch {
+            logger.debug({ branch }, "Failed to delete orphaned branch (ignored)");
+          }
+        }
       } catch {
-        logger.debug({ branch }, "Failed to delete orphaned branch (ignored)");
+        // Pattern didn't match any branches
       }
     }
   } catch (error) {

package/src/modules/logging/logger.ts

@@ -1,13 +1,27 @@
 import pino from "pino";
+import { Writable } from "node:stream";
+import type { LogStore, LogEntry } from "./log-store";
+import type { EventBus } from "../../shared/events";
 
 export interface LoggerOptions {
   service: string;
   debug?: boolean;
   logFilePath?: string;
+  /** When provided, all pino logs are also forwarded to LogStore + EventBus for dashboard SSE */
+  logStore?: LogStore;
+  eventBus?: EventBus;
+}
+
+/** Map pino numeric levels to LogEntry level strings */
+function pinoLevelToString(level: number): "debug" | "info" | "warn" | "error" {
+  if (level <= 20) return "debug";
+  if (level <= 30) return "info";
+  if (level <= 40) return "warn";
+  return "error";
 }
 
 export function createLogger(options: LoggerOptions): pino.Logger {
-  const { service, debug = false, logFilePath } = options;
+  const { service, debug = false, logFilePath, logStore, eventBus } = options;
 
   const targets: pino.TransportTargetOptions[] = [];
 
@@ -46,10 +60,74 @@ export function createLogger(options: LoggerOptions): pino.Logger {
     });
   }
 
-  const logger = pino({
+  const baseLogger = pino({
     level: debug ? "debug" : "warn",
     transport: targets.length === 1 ? targets[0] : { targets },
   });
 
-  return logger.child({ service });
+  // If logStore and eventBus provided, create a multistream logger that also
+  // writes to the dashboard. We create a separate pino instance that writes
+  // to a custom Writable, then hook into the base logger.
+  if (logStore && eventBus) {
+    const dashboardStream = new Writable({
+      write(chunk: Buffer, _encoding: string, callback: () => void): void {
+        try {
+          const obj = JSON.parse(chunk.toString());
+          const entry: LogEntry = {
+            level: pinoLevelToString(obj.level ?? 30),
+            service: obj.service ?? service,
+            message: obj.msg ?? "",
+            timestamp: obj.time ?? Date.now(),
+            taskId: obj.taskId,
+            workerId: obj.workerId,
+          };
+          logStore.add(entry);
+          eventBus.emit({ type: "log:entry", entry });
+        } catch {
+          // ignore parse errors
+        }
+        callback();
+      },
+    });
+
+    // Use streams for everything when dashboard is active
+    // (pino transports run in worker threads, can't combine with custom streams)
+    const streams: pino.StreamEntry[] = [];
+
+    if (debug) {
+      // We can't use pino-pretty as a stream directly (it's a transport).
+      // Write raw JSON to stderr in debug mode instead.
+      streams.push({
+        level: "debug" as pino.Level,
+        stream: process.stderr,
+      });
+    } else {
+      streams.push({
+        level: "warn" as pino.Level,
+        stream: process.stderr,
+      });
+    }
+
+    if (logFilePath) {
+      streams.push({
+        level: "info" as pino.Level,
+        stream: pino.destination(logFilePath),
+      });
+    }
+
+    // Dashboard stream
+    streams.push({
+      level: (debug ? "debug" : "info") as pino.Level,
+      stream: dashboardStream,
+    });
+
+    const combinedLogger = pino(
+      { level: debug ? "debug" : "info" },
+      pino.multistream(streams)
+    );
+
+    return combinedLogger.child({ service });
+  }
+
+  return baseLogger.child({ service });
 }

package/src/modules/planning/__tests__/feature-name-generator.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "bun:test";
-import { sanitizeBranchName, generateFeatureName } from "../feature-name-generator";
+import { sanitizeBranchName, parsePrefix, generateFeatureName } from "../feature-name-generator";
 import type { ClaudeProvider } from "../../claude-provider";
 
 describe("Feature Name Generator", () => {
@@ -20,8 +20,13 @@ describe("Feature Name Generator", () => {
       expect(sanitizeBranchName("-hello-")).toBe("hello");
     });
 
-    it("truncates to 20 characters", () => {
-      expect(sanitizeBranchName("this-is-a-very-long-branch-name-that-exceeds-limit").length).toBeLessThanOrEqual(20);
+    it("truncates to 30 characters by default", () => {
+      const result = sanitizeBranchName("this-is-a-very-long-branch-name-that-exceeds-limit");
+      expect(result.length).toBeLessThanOrEqual(30);
+    });
+
+    it("accepts custom maxLength", () => {
+      expect(sanitizeBranchName("abcdefghij", 5)).toBe("abcde");
     });
 
     it("handles empty string", () => {
@@ -33,11 +38,51 @@ describe("Feature Name Generator", () => {
     });
   });
 
+  describe("parsePrefix", () => {
+    it("parses valid prefixes", () => {
+      expect(parsePrefix("feat")).toBe("feat");
+      expect(parsePrefix("fix")).toBe("fix");
+      expect(parsePrefix("docs")).toBe("docs");
+      expect(parsePrefix("refactor")).toBe("refactor");
+      expect(parsePrefix("chore")).toBe("chore");
+    });
+
+    it("handles trailing colon", () => {
+      expect(parsePrefix("feat:")).toBe("feat");
+    });
+
+    it("handles case insensitivity", () => {
+      expect(parsePrefix("FEAT")).toBe("feat");
+      expect(parsePrefix("Fix")).toBe("fix");
+    });
+
+    it("defaults to feat for unknown", () => {
+      expect(parsePrefix("unknown")).toBe("feat");
+      expect(parsePrefix("")).toBe("feat");
+    });
+  });
+
   describe("generateFeatureName", () => {
-    it("uses Claude result when successful", async () => {
+    it("parses prefix and name from two-line response", async () => {
+      const mockProvider: ClaudeProvider = {
+        call: async () => ({
+          result: "fix\nauth-login-bug\n",
+          exitCode: 0,
+          model: "claude-haiku-4-5",
+          effortLevel: "low" as const,
+          duration: 100,
+        }),
+      };
+
+      const result = await generateFeatureName("/dev/null", mockProvider);
+      expect(result.prefix).toBe("fix");
+      expect(result.name).toBe("auth-login-bug");
+    });
+
+    it("defaults prefix to feat when single line", async () => {
       const mockProvider: ClaudeProvider = {
         call: async () => ({
-          result: "  auth-login  \n",
+          result: "auth-login\n",
           exitCode: 0,
           model: "claude-haiku-4-5",
           effortLevel: "low" as const,
@@ -45,8 +90,9 @@ describe("Feature Name Generator", () => {
         }),
       };
 
-      const name = await generateFeatureName("/dev/null", mockProvider);
-      expect(name).toBe("auth-login");
+      const result = await generateFeatureName("/dev/null", mockProvider);
+      expect(result.prefix).toBe("feat");
+      expect(result.name).toBe("auth-login");
     });
 
     it("falls back to filename on provider error", async () => {
@@ -54,14 +100,15 @@ describe("Feature Name Generator", () => {
         call: async () => { throw new Error("API error"); },
       };
 
-      const name = await generateFeatureName("/some/path/auth-feature.md", mockProvider);
-      expect(name).toBe("auth-feature");
+      const result = await generateFeatureName("/some/path/auth-feature.md", mockProvider);
+      expect(result.prefix).toBe("feat");
+      expect(result.name).toBe("auth-feature");
     });
 
     it("falls back to filename when result too short", async () => {
       const mockProvider: ClaudeProvider = {
         call: async () => ({
-          result: "ab",
+          result: "feat\nab",
           exitCode: 0,
           model: "claude-haiku-4-5",
           effortLevel: "low" as const,
@@ -69,8 +116,9 @@ describe("Feature Name Generator", () => {
         }),
       };
 
-      const name = await generateFeatureName("/path/user-signup.md", mockProvider);
-      expect(name).toBe("user-signup");
+      const result = await generateFeatureName("/path/user-signup.md", mockProvider);
+      expect(result.prefix).toBe("feat");
+      expect(result.name).toBe("user-signup");
     });
   });
 });

package/src/modules/planning/feature-name-generator.ts

@@ -1,7 +1,10 @@
 /**
  * Feature Name Generator
- * Generates a short English feature name from a requirements document.
- * Used for branch naming: aad/{featureName}/parent, aad/{featureName}/task-001
+ * Generates a git branch prefix and feature name from a requirements document.
+ * Used for branch naming: {prefix}/{featureName}/parent, {prefix}/{featureName}/task-001
+ *
+ * Prefix follows conventional commit types:
+ *   feat, fix, docs, style, refactor, perf, test, chore
  *
  * Ported from .aad/scripts/run-parallel.sh extract_requirement_title()
  */
@@ -10,12 +13,24 @@ import type pino from "pino";
 import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
 
-const FEATURE_NAME_PROMPT = `You are a branch name generator. Given the requirements below, output ONLY a short English identifier suitable for a git branch name.
+const VALID_PREFIXES = [
+  "feat",
+  "fix",
+  "docs",
+  "style",
+  "refactor",
+  "perf",
+  "test",
+  "chore",
+] as const;
+
+export type BranchPrefix = (typeof VALID_PREFIXES)[number];
+
+const FEATURE_NAME_PROMPT = `You are a git branch name generator. Given the requirements below, output EXACTLY two lines:
+Line 1: The conventional commit type (one of: feat, fix, docs, style, refactor, perf, test, chore)
+Line 2: A short English identifier for the branch name (lowercase alphanumeric and hyphens only, 30 chars max)
 
-Rules:
-- Lowercase alphanumeric and hyphens only
-- 20 characters max
-- No explanation, no decoration, just the identifier
+No explanation, no decoration, just the two lines.
 
 Requirements:
 `;
@@ -23,24 +38,40 @@ Requirements:
 /**
  * Sanitize a string to be a valid git branch name component
  */
-export function sanitizeBranchName(name: string): string {
+export function sanitizeBranchName(name: string, maxLength = 30): string {
   return name
     .toLowerCase()
     .replace(/[^a-z0-9-]/g, "-")
     .replace(/-+/g, "-")
     .replace(/^-|-$/g, "")
-    .slice(0, 20);
+    .slice(0, maxLength);
 }
 
 /**
- * Generate a feature name from requirements file using Claude
+ * Parse prefix from Claude response, defaulting to "feat"
+ */
+export function parsePrefix(line: string): BranchPrefix {
+  const trimmed = line.trim().toLowerCase().replace(/:$/, "");
+  if (VALID_PREFIXES.includes(trimmed as BranchPrefix)) {
+    return trimmed as BranchPrefix;
+  }
+  return "feat";
+}
+
+export interface FeatureNameResult {
+  prefix: BranchPrefix;
+  name: string;
+}
+
+/**
+ * Generate a feature name and prefix from requirements file using Claude
  * Falls back to filename-based name on failure
  */
 export async function generateFeatureName(
   requirementsPath: string,
   provider: ClaudeProvider,
   logger?: pino.Logger,
-): Promise<string> {
+): Promise<FeatureNameResult> {
   try {
     // Read first 20 lines of requirements
     const fullContent = await readFile(requirementsPath, "utf-8");
@@ -51,13 +82,14 @@ export async function generateFeatureName(
       model: "claude-haiku-4-5",
     });
 
-    const rawName = result.result.trim();
-
+    const lines = result.result.trim().split("\n").filter(Boolean);
+    const prefix = parsePrefix(lines[0] ?? "");
+    const rawName = (lines[1] ?? lines[0] ?? "").trim();
     const sanitized = sanitizeBranchName(rawName);
 
     if (sanitized.length >= 3) {
-      logger?.info({ featureName: sanitized, raw: rawName }, "Feature name generated");
-      return sanitized;
+      logger?.info({ prefix, featureName: sanitized, raw: rawName }, "Feature name generated");
+      return { prefix, name: sanitized };
     }
   } catch (error) {
     logger?.warn({ error }, "Feature name generation failed, using fallback");
@@ -67,5 +99,5 @@ export async function generateFeatureName(
   const fallback = sanitizeBranchName(
     basename(requirementsPath).replace(/\.[^.]*$/, ""),
   );
-  return fallback || "default";
+  return { prefix: "feat", name: fallback || "default" };
 }

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

@@ -226,8 +226,11 @@ export class Dispatcher {
 
     this.deps.logger.info({ taskId }, "Task completed");
 
-    // Try to dispatch next tasks
-    await this.dispatchNext();
+    // Note: Do NOT call dispatchNext() here.
+    // The worker:idle event (emitted by task-dispatch-handler after completeTask)
+    // will trigger handleWorkerIdle → dispatchNext(). Calling it here too causes
+    // a race condition where two dispatchNext() calls run concurrently without a mutex,
+    // potentially dispatching multiple tasks to the same worker.
   }
 
   async handleTaskFailed(taskId: TaskId, error: string): Promise<void> {
@@ -259,8 +262,7 @@ export class Dispatcher {
         "Task failed, retrying"
       );
 
-      // Try to dispatch
-      await this.dispatchNext();
+      // Dispatch deferred to worker:idle event (avoids race condition)
     } else {
       // Failed permanently
       task.status = "failed";