ralph-mcp 1.0.8 → 1.0.10

package/README.md

@@ -39,6 +39,8 @@ Claude: ralph_start → Task Agent handles everything automatically
 - **2-Step Workflow** - Just create PRD and run `ralph_start`, everything else is automatic
 - **Parallel Execution** - Run 5+ PRDs simultaneously with Claude Code Task tool
 - **Git Worktree Isolation** - Each PRD runs in its own worktree, zero conflicts
+- **Agent Memory** - Persistent "Progress Log" learns from mistakes across User Stories
+- **Context Injection** - Inject project rules (CLAUDE.md) into agent context
 - **Auto Quality Gates** - Type check, lint, build before every commit
 - **Auto Merge** - Merges to main when all User Stories pass
 - **Doc Sync** - Automatically updates TODO.md with completed items
@@ -276,6 +278,7 @@ Override data directory with `RALPH_DATA_DIR` environment variable.
 | `autoMerge` | `false` | Auto-merge when all stories pass |
 | `notifyOnComplete` | `true` | Show Windows notification on completion |
 | `onConflict` | `"agent"` | Conflict resolution: `auto_theirs`, `auto_ours`, `notify`, `agent` |
+| `contextInjectionPath` | `undefined` | Optional path to file (e.g. CLAUDE.md) to inject into prompt |
 
 ### Example with options
 

package/dist/index.js

@@ -3,6 +3,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { start, startInputSchema } from "./tools/start.js";
+import { batchStart, batchStartInputSchema } from "./tools/batch-start.js";
 import { status, statusInputSchema } from "./tools/status.js";
 import { get, getInputSchema } from "./tools/get.js";
 import { update, updateInputSchema } from "./tools/update.js";
@@ -208,6 +209,55 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["branch", "agentTaskId"],
                 },
             },
+            {
+                name: "ralph_batch_start",
+                description: "Start multiple PRDs with dependency resolution. Parses all PRDs, creates worktrees, runs pnpm install serially (avoids store lock), and returns agent prompts for PRDs whose dependencies are satisfied.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        prdPaths: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of paths to PRD markdown files",
+                        },
+                        projectRoot: {
+                            type: "string",
+                            description: "Project root directory (defaults to cwd)",
+                        },
+                        worktree: {
+                            type: "boolean",
+                            description: "Create worktrees for isolation (default: true)",
+                            default: true,
+                        },
+                        autoMerge: {
+                            type: "boolean",
+                            description: "Auto add to merge queue when all stories pass (default: true)",
+                            default: true,
+                        },
+                        notifyOnComplete: {
+                            type: "boolean",
+                            description: "Show Windows notification when all stories complete (default: true)",
+                            default: true,
+                        },
+                        onConflict: {
+                            type: "string",
+                            enum: ["auto_theirs", "auto_ours", "notify", "agent"],
+                            description: "Conflict resolution strategy for merge (default: agent)",
+                            default: "agent",
+                        },
+                        contextInjectionPath: {
+                            type: "string",
+                            description: "Path to a file (e.g., CLAUDE.md) to inject into the agent prompt",
+                        },
+                        preheat: {
+                            type: "boolean",
+                            description: "Run pnpm install serially before starting agents (default: true)",
+                            default: true,
+                        },
+                    },
+                    required: ["prdPaths"],
+                },
+            },
         ],
     };
 });
@@ -241,6 +291,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "ralph_set_agent_id":
                 result = await setAgentId(setAgentIdInputSchema.parse(args));
                 break;
+            case "ralph_batch_start":
+                result = await batchStart(batchStartInputSchema.parse(args));
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/store/state.d.ts

@@ -14,6 +14,7 @@ export interface ExecutionRecord {
     onConflict: ConflictStrategy | null;
     autoMerge: boolean;
     notifyOnComplete: boolean;
+    dependencies: string[];
     createdAt: Date;
     updatedAt: Date;
 }
@@ -53,3 +54,15 @@ export declare function findMergeQueueItemByExecutionId(executionId: string): Pr
 export declare function insertMergeQueueItem(item: Omit<MergeQueueItem, "id">): Promise<MergeQueueItem>;
 export declare function updateMergeQueueItem(id: number, patch: Partial<Omit<MergeQueueItem, "id" | "executionId" | "createdAt">>): Promise<void>;
 export declare function deleteMergeQueueByExecutionId(executionId: string): Promise<void>;
+/**
+ * Find all executions that depend on a given branch.
+ */
+export declare function findExecutionsDependingOn(branch: string): Promise<ExecutionRecord[]>;
+/**
+ * Check if all dependencies of an execution are completed.
+ */
+export declare function areDependenciesSatisfied(execution: ExecutionRecord): Promise<{
+    satisfied: boolean;
+    pending: string[];
+    completed: string[];
+}>;

package/dist/store/state.js

@@ -45,6 +45,7 @@ function deserializeState(file) {
     return {
         executions: file.executions.map((e) => ({
             ...e,
+            dependencies: Array.isArray(e.dependencies) ? e.dependencies : [],
             createdAt: parseDate(e.createdAt, "executions.createdAt"),
             updatedAt: parseDate(e.updatedAt, "executions.updatedAt"),
         })),
@@ -203,3 +204,35 @@ export async function deleteMergeQueueByExecutionId(executionId) {
         s.mergeQueue = s.mergeQueue.filter((q) => q.executionId !== executionId);
     });
 }
+/**
+ * Find all executions that depend on a given branch.
+ */
+export async function findExecutionsDependingOn(branch) {
+    return readState((s) => s.executions.filter((e) => e.dependencies.includes(branch)));
+}
+/**
+ * Check if all dependencies of an execution are completed.
+ */
+export async function areDependenciesSatisfied(execution) {
+    if (!execution.dependencies || execution.dependencies.length === 0) {
+        return { satisfied: true, pending: [], completed: [] };
+    }
+    return readState((s) => {
+        const pending = [];
+        const completed = [];
+        for (const depBranch of execution.dependencies) {
+            const depExec = s.executions.find((e) => e.branch === depBranch);
+            if (depExec && depExec.status === "completed") {
+                completed.push(depBranch);
+            }
+            else {
+                pending.push(depBranch);
+            }
+        }
+        return {
+            satisfied: pending.length === 0,
+            pending,
+            completed,
+        };
+    });
+}

package/dist/tools/batch-start.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export declare const batchStartInputSchema: z.ZodObject<{
+    prdPaths: z.ZodArray<z.ZodString, "many">;
+    projectRoot: z.ZodOptional<z.ZodString>;
+    worktree: z.ZodDefault<z.ZodBoolean>;
+    autoMerge: z.ZodDefault<z.ZodBoolean>;
+    notifyOnComplete: z.ZodDefault<z.ZodBoolean>;
+    onConflict: z.ZodDefault<z.ZodEnum<["auto_theirs", "auto_ours", "notify", "agent"]>>;
+    contextInjectionPath: z.ZodOptional<z.ZodString>;
+    preheat: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    onConflict: "auto_theirs" | "auto_ours" | "notify" | "agent";
+    autoMerge: boolean;
+    notifyOnComplete: boolean;
+    worktree: boolean;
+    prdPaths: string[];
+    preheat: boolean;
+    projectRoot?: string | undefined;
+    contextInjectionPath?: string | undefined;
+}, {
+    prdPaths: string[];
+    projectRoot?: string | undefined;
+    onConflict?: "auto_theirs" | "auto_ours" | "notify" | "agent" | undefined;
+    autoMerge?: boolean | undefined;
+    notifyOnComplete?: boolean | undefined;
+    worktree?: boolean | undefined;
+    contextInjectionPath?: string | undefined;
+    preheat?: boolean | undefined;
+}>;
+export type BatchStartInput = z.infer<typeof batchStartInputSchema>;
+export interface BatchStartResult {
+    total: number;
+    created: number;
+    skipped: Array<{
+        prdPath: string;
+        reason: string;
+    }>;
+    readyToStart: Array<{
+        branch: string;
+        agentPrompt: string;
+        dependencies: string[];
+    }>;
+    waitingForDependencies: Array<{
+        branch: string;
+        pendingDependencies: string[];
+    }>;
+    dependencyGraph: Record<string, string[]>;
+    preheatCompleted: boolean;
+}
+export declare function batchStart(input: BatchStartInput): Promise<BatchStartResult>;

package/dist/tools/batch-start.js

@@ -0,0 +1,225 @@
+import { z } from "zod";
+import { resolve, basename } from "path";
+import { randomUUID } from "crypto";
+import { execSync } from "child_process";
+import { parsePrdFile } from "../utils/prd-parser.js";
+import { createWorktree } from "../utils/worktree.js";
+import { generateAgentPrompt } from "../utils/agent.js";
+import { detectPackageManager, getInstallCommand, } from "../utils/package-manager.js";
+import { areDependenciesSatisfied, findExecutionByBranch, insertExecution, insertUserStories, } from "../store/state.js";
+export const batchStartInputSchema = z.object({
+    prdPaths: z.array(z.string()).describe("Array of paths to PRD markdown files"),
+    projectRoot: z.string().optional().describe("Project root directory (defaults to cwd)"),
+    worktree: z.boolean().default(true).describe("Create worktrees for isolation"),
+    autoMerge: z.boolean().default(true).describe("Auto add to merge queue when all stories pass"),
+    notifyOnComplete: z.boolean().default(true).describe("Show Windows notification when all stories complete"),
+    onConflict: z
+        .enum(["auto_theirs", "auto_ours", "notify", "agent"])
+        .default("agent")
+        .describe("Conflict resolution strategy for merge"),
+    contextInjectionPath: z
+        .string()
+        .optional()
+        .describe("Path to a file (e.g., CLAUDE.md) to inject into the agent prompt"),
+    preheat: z.boolean().default(true).describe("Run install command serially before starting agents (avoids store lock)"),
+});
+/**
+ * Topological sort to determine execution order based on dependencies.
+ */
+function topologicalSort(prds) {
+    const branchToPrd = new Map();
+    for (const prd of prds) {
+        branchToPrd.set(prd.branch, prd);
+    }
+    const visited = new Set();
+    const result = [];
+    function visit(branch) {
+        if (visited.has(branch))
+            return;
+        visited.add(branch);
+        const prd = branchToPrd.get(branch);
+        if (!prd)
+            return;
+        // Visit dependencies first
+        for (const dep of prd.dependencies) {
+            if (branchToPrd.has(dep)) {
+                visit(dep);
+            }
+        }
+        result.push(prd);
+    }
+    for (const prd of prds) {
+        visit(prd.branch);
+    }
+    return result;
+}
+/**
+ * Run install command in a worktree directory.
+ */
+function preheatWorktree(worktreePath, installCmd) {
+    const cmd = `${installCmd.command} ${installCmd.args.join(" ")}`;
+    try {
+        execSync(cmd, {
+            cwd: worktreePath,
+            stdio: "pipe",
+            timeout: 300000, // 5 minutes
+        });
+    }
+    catch (error) {
+        // Try fallback if available
+        if (installCmd.fallbackArgs.length > 0) {
+            const fallbackCmd = `${installCmd.command} ${installCmd.fallbackArgs.join(" ")}`;
+            execSync(fallbackCmd, {
+                cwd: worktreePath,
+                stdio: "pipe",
+                timeout: 300000,
+            });
+        }
+        else {
+            throw error;
+        }
+    }
+}
+export async function batchStart(input) {
+    const projectRoot = input.projectRoot || process.cwd();
+    const projectName = basename(projectRoot);
+    const contextPath = input.contextInjectionPath
+        ? resolve(projectRoot, input.contextInjectionPath)
+        : undefined;
+    // Detect package manager
+    const pm = detectPackageManager(projectRoot);
+    const installCmd = getInstallCommand(pm);
+    const skipped = [];
+    const prdInfos = [];
+    // Phase 1: Parse all PRDs and create execution records
+    for (const prdPath of input.prdPaths) {
+        const fullPath = resolve(projectRoot, prdPath);
+        try {
+            const prd = parsePrdFile(fullPath);
+            // Check if execution already exists
+            const existing = await findExecutionByBranch(prd.branchName);
+            if (existing) {
+                skipped.push({
+                    prdPath,
+                    reason: `Execution already exists for branch ${prd.branchName}`,
+                });
+                continue;
+            }
+            // Create worktree if requested
+            let worktreePath = null;
+            if (input.worktree) {
+                worktreePath = await createWorktree(projectRoot, prd.branchName);
+            }
+            // Create execution record
+            const executionId = randomUUID();
+            const now = new Date();
+            await insertExecution({
+                id: executionId,
+                project: projectName,
+                branch: prd.branchName,
+                description: prd.description,
+                prdPath: fullPath,
+                projectRoot: projectRoot,
+                worktreePath: worktreePath,
+                status: "pending",
+                agentTaskId: null,
+                onConflict: input.onConflict,
+                autoMerge: input.autoMerge,
+                notifyOnComplete: input.notifyOnComplete,
+                dependencies: prd.dependencies,
+                createdAt: now,
+                updatedAt: now,
+            });
+            // Create user story records
+            const storyRecords = prd.userStories.map((story) => ({
+                id: `${executionId}:${story.id}`,
+                executionId: executionId,
+                storyId: story.id,
+                title: story.title,
+                description: story.description,
+                acceptanceCriteria: story.acceptanceCriteria,
+                priority: story.priority,
+                passes: false,
+                notes: "",
+            }));
+            if (storyRecords.length > 0) {
+                await insertUserStories(storyRecords);
+            }
+            prdInfos.push({
+                prdPath,
+                branch: prd.branchName,
+                dependencies: prd.dependencies,
+                worktreePath,
+                executionId,
+                stories: storyRecords.map((s) => ({
+                    storyId: s.storyId,
+                    title: s.title,
+                    description: s.description,
+                    acceptanceCriteria: s.acceptanceCriteria,
+                    priority: s.priority,
+                    passes: s.passes,
+                })),
+            });
+        }
+        catch (error) {
+            skipped.push({
+                prdPath,
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Phase 2: Topological sort for preheat order
+    const sortedPrds = topologicalSort(prdInfos);
+    // Phase 3: Preheat worktrees serially (avoids store lock contention)
+    let preheatCompleted = false;
+    if (input.preheat && input.worktree) {
+        for (const prd of sortedPrds) {
+            if (prd.worktreePath) {
+                try {
+                    preheatWorktree(prd.worktreePath, installCmd);
+                }
+                catch (error) {
+                    console.error(`Preheat failed for ${prd.branch}:`, error);
+                    // Continue with other worktrees
+                }
+            }
+        }
+        preheatCompleted = true;
+    }
+    // Phase 4: Determine which PRDs can start immediately
+    const readyToStart = [];
+    const waitingForDependencies = [];
+    for (const prd of prdInfos) {
+        const tempExec = { dependencies: prd.dependencies };
+        const depStatus = await areDependenciesSatisfied(tempExec);
+        if (depStatus.satisfied) {
+            const agentPrompt = generateAgentPrompt(prd.branch, "", // description not stored in prdInfo
+            prd.worktreePath || projectRoot, prd.stories, contextPath);
+            readyToStart.push({
+                branch: prd.branch,
+                agentPrompt,
+                dependencies: prd.dependencies,
+            });
+        }
+        else {
+            waitingForDependencies.push({
+                branch: prd.branch,
+                pendingDependencies: depStatus.pending,
+            });
+        }
+    }
+    // Build dependency graph for visualization
+    const dependencyGraph = {};
+    for (const prd of prdInfos) {
+        dependencyGraph[prd.branch] = prd.dependencies;
+    }
+    return {
+        total: input.prdPaths.length,
+        created: prdInfos.length,
+        skipped,
+        readyToStart,
+        waitingForDependencies,
+        dependencyGraph,
+        preheatCompleted,
+    };
+}

package/dist/tools/start.d.ts

@@ -33,6 +33,9 @@ export interface StartResult {
     branch: string;
     worktreePath: string | null;
     agentPrompt: string | null;
+    dependencies: string[];
+    dependenciesSatisfied: boolean;
+    pendingDependencies: string[];
     stories: Array<{
         storyId: string;
         title: string;

package/dist/tools/start.js

@@ -4,7 +4,7 @@ import { parsePrdFile } from "../utils/prd-parser.js";
 import { createWorktree } from "../utils/worktree.js";
 import { generateAgentPrompt } from "../utils/agent.js";
 import { resolve, basename } from "path";
-import { findExecutionByBranch, insertExecution, insertUserStories, } from "../store/state.js";
+import { areDependenciesSatisfied, findExecutionByBranch, insertExecution, insertUserStories, } from "../store/state.js";
 export const startInputSchema = z.object({
     prdPath: z.string().describe("Path to the PRD markdown file"),
     projectRoot: z.string().optional().describe("Project root directory (defaults to cwd)"),
@@ -53,6 +53,7 @@ export async function start(input) {
         onConflict: input.onConflict,
         autoMerge: input.autoMerge,
         notifyOnComplete: input.notifyOnComplete,
+        dependencies: prd.dependencies,
         createdAt: now,
         updatedAt: now,
     });
@@ -71,9 +72,14 @@ export async function start(input) {
     if (storyRecords.length > 0) {
         await insertUserStories(storyRecords);
     }
-    // Generate agent prompt if auto-start
+    // Check if dependencies are satisfied
+    const tempExec = {
+        dependencies: prd.dependencies,
+    };
+    const depStatus = await areDependenciesSatisfied(tempExec);
+    // Generate agent prompt only if auto-start AND dependencies are satisfied
     let agentPrompt = null;
-    if (input.autoStart) {
+    if (input.autoStart && depStatus.satisfied) {
         const contextPath = input.contextInjectionPath
             ? resolve(projectRoot, input.contextInjectionPath)
             : undefined;
@@ -91,6 +97,9 @@ export async function start(input) {
         branch: prd.branchName,
         worktreePath,
         agentPrompt,
+        dependencies: prd.dependencies,
+        dependenciesSatisfied: depStatus.satisfied,
+        pendingDependencies: depStatus.pending,
         stories: storyRecords.map((s) => ({
             storyId: s.storyId,
             title: s.title,

package/dist/tools/update.d.ts

@@ -24,5 +24,9 @@ export interface UpdateResult {
     allComplete: boolean;
     progress: string;
     addedToMergeQueue: boolean;
+    triggeredDependents: Array<{
+        branch: string;
+        agentPrompt: string | null;
+    }>;
 }
 export declare function update(input: UpdateInput): Promise<UpdateResult>;

package/dist/tools/update.js

@@ -3,8 +3,9 @@ import notifier from "node-notifier";
 import { appendFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
 import { join, dirname } from "path";
-import { findExecutionByBranch, findMergeQueueItemByExecutionId, findUserStoryById, insertMergeQueueItem, listMergeQueue, listUserStoriesByExecutionId, updateExecution, updateUserStory, } from "../store/state.js";
+import { areDependenciesSatisfied, findExecutionByBranch, findExecutionsDependingOn, findMergeQueueItemByExecutionId, findUserStoryById, insertMergeQueueItem, listMergeQueue, listUserStoriesByExecutionId, updateExecution, updateUserStory, } from "../store/state.js";
 import { mergeQueueAction } from "./merge.js";
+import { generateAgentPrompt } from "../utils/agent.js";
 export const updateInputSchema = z.object({
     branch: z.string().describe("Branch name (e.g., ralph/task1-agent)"),
     storyId: z.string().describe("Story ID (e.g., US-001)"),
@@ -99,6 +100,37 @@ export async function update(input) {
             sound: true,
         });
     }
+    // Trigger dependent executions when this PRD completes
+    const triggeredDependents = [];
+    if (allComplete) {
+        const dependents = await findExecutionsDependingOn(exec.branch);
+        for (const dep of dependents) {
+            // Skip if already running or completed
+            if (dep.status !== "pending") {
+                continue;
+            }
+            // Check if all dependencies are now satisfied
+            const depStatus = await areDependenciesSatisfied(dep);
+            if (depStatus.satisfied) {
+                // Get user stories for this dependent execution
+                const depStories = await listUserStoriesByExecutionId(dep.id);
+                // Generate agent prompt for the dependent
+                const agentPrompt = generateAgentPrompt(dep.branch, dep.description, dep.worktreePath || dep.projectRoot, depStories.map((s) => ({
+                    storyId: s.storyId,
+                    title: s.title,
+                    description: s.description,
+                    acceptanceCriteria: s.acceptanceCriteria,
+                    priority: s.priority,
+                    passes: s.passes,
+                })), undefined // contextPath not stored, would need to re-parse PRD if needed
+                );
+                triggeredDependents.push({
+                    branch: dep.branch,
+                    agentPrompt,
+                });
+            }
+        }
+    }
     return {
         success: true,
         branch: input.branch,
@@ -107,5 +139,6 @@ export async function update(input) {
         allComplete,
         progress: `${completedCount}/${allStories.length} US`,
         addedToMergeQueue,
+        triggeredDependents,
     };
 }

package/dist/utils/package-manager.d.ts

@@ -0,0 +1,8 @@
+export type PackageManager = "pnpm" | "npm" | "yarn" | "bun";
+export interface InstallCommand {
+    command: string;
+    args: string[];
+    fallbackArgs: string[];
+}
+export declare function detectPackageManager(projectRoot: string): PackageManager;
+export declare function getInstallCommand(pm: PackageManager): InstallCommand;

package/dist/utils/package-manager.js

@@ -0,0 +1,44 @@
+import { existsSync } from "fs";
+import { join } from "path";
+export function detectPackageManager(projectRoot) {
+    if (existsSync(join(projectRoot, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    if (existsSync(join(projectRoot, "yarn.lock"))) {
+        return "yarn";
+    }
+    if (existsSync(join(projectRoot, "bun.lockb"))) {
+        return "bun";
+    }
+    // Default to npm if package-lock.json exists or as fallback
+    return "npm";
+}
+export function getInstallCommand(pm) {
+    switch (pm) {
+        case "pnpm":
+            return {
+                command: "pnpm",
+                args: ["install", "--frozen-lockfile"],
+                fallbackArgs: ["install"],
+            };
+        case "yarn":
+            return {
+                command: "yarn",
+                args: ["install", "--frozen-lockfile"],
+                fallbackArgs: ["install"],
+            };
+        case "bun":
+            return {
+                command: "bun",
+                args: ["install", "--frozen-lockfile"],
+                fallbackArgs: ["install"],
+            };
+        case "npm":
+        default:
+            return {
+                command: "npm",
+                args: ["ci"],
+                fallbackArgs: ["install"],
+            };
+    }
+}

package/dist/utils/prd-parser.d.ts

@@ -10,6 +10,7 @@ export interface ParsedPrd {
     description: string;
     branchName: string;
     userStories: ParsedUserStory[];
+    dependencies: string[];
 }
 /**
  * Parse a PRD markdown file into structured data.

package/dist/utils/prd-parser.js

@@ -25,6 +25,7 @@ function parsePrdJson(content) {
             acceptanceCriteria: us.acceptanceCriteria || [],
             priority: us.priority || index + 1,
         })),
+        dependencies: Array.isArray(data.dependencies) ? data.dependencies : [],
     };
 }
 function parsePrdMarkdown(content) {
@@ -39,6 +40,8 @@ function parsePrdMarkdown(content) {
     // Extract description
     const descMatch = body.match(/##\s*(?:Description|描述|Overview|概述)\s*\n([\s\S]*?)(?=\n##|\n$)/i);
     const description = descMatch?.[1]?.trim() || title;
+    // Extract dependencies from frontmatter or body
+    const dependencies = extractDependencies(frontmatter, body);
     // Extract user stories
     const userStories = extractUserStories(body);
     return {
@@ -46,8 +49,59 @@ function parsePrdMarkdown(content) {
         description,
         branchName,
         userStories,
+        dependencies,
     };
 }
+/**
+ * Extract dependencies from frontmatter or body.
+ * Supports:
+ * - Frontmatter: `dependencies: [ralph/prd-a, ralph/prd-b]`
+ * - Body section: `## Dependencies\n- depends_on: prd-a.md`
+ */
+function extractDependencies(frontmatter, body) {
+    const deps = [];
+    // From frontmatter (array of branch names)
+    if (Array.isArray(frontmatter.dependencies)) {
+        for (const dep of frontmatter.dependencies) {
+            if (typeof dep === "string" && dep.trim()) {
+                deps.push(normalizeDependency(dep.trim()));
+            }
+        }
+    }
+    // From body: ## Dependencies section
+    const depsSection = body.match(/##\s*(?:Dependencies|依赖)\s*\n([\s\S]*?)(?=\n##[^#]|$)/i);
+    if (depsSection) {
+        // Match patterns like:
+        // - depends_on: prd-shared-logic.md
+        // - ralph/prd-shared-logic
+        // - prd-shared-logic
+        const depPattern = /[-*]\s*(?:depends_on:\s*)?(.+?)(?:\n|$)/gi;
+        let match;
+        while ((match = depPattern.exec(depsSection[1])) !== null) {
+            const dep = match[1].trim();
+            if (dep && !dep.startsWith("#")) {
+                deps.push(normalizeDependency(dep));
+            }
+        }
+    }
+    return [...new Set(deps)]; // Deduplicate
+}
+/**
+ * Normalize dependency to branch name format.
+ * - "prd-shared-logic.md" -> "ralph/prd-shared-logic"
+ * - "ralph/prd-shared-logic" -> "ralph/prd-shared-logic"
+ * - "prd-shared-logic" -> "ralph/prd-shared-logic"
+ */
+function normalizeDependency(dep) {
+    // Remove .md extension if present
+    dep = dep.replace(/\.md$/i, "");
+    // If already has ralph/ prefix, return as-is
+    if (dep.startsWith("ralph/")) {
+        return dep;
+    }
+    // Add ralph/ prefix
+    return `ralph/${dep}`;
+}
 function extractUserStories(content) {
     const stories = [];
     // First, try to find the User Stories section

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-mcp",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "MCP server for autonomous PRD execution with Claude Code. Git worktree isolation, progress tracking, auto-merge.",
   "type": "module",
   "main": "dist/index.js",