@ronkovic/aad 0.3.6 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronkovic/aad",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "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/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;
@@ -256,7 +256,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/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/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";