@cliangdev/flux-plugin 0.2.0-dev.4f12f3f → 0.2.0-dev.71255d1

package/src/server/adapters/__tests__/dependency-ops.test.ts

@@ -194,8 +194,12 @@ describe("LinearAdapter - Dependency Operations", () => {
       const mockRelation = {
         id: "relation_1",
         type: "blocks",
-        issue: { id: "issue_epic_1", identifier: "ENG-42" },
-        relatedIssue: { id: "issue_epic_2", identifier: "ENG-43" },
+        // Linear SDK returns promises for lazy-loaded related objects
+        issue: Promise.resolve({ id: "issue_epic_1", identifier: "ENG-42" }),
+        relatedIssue: Promise.resolve({
+          id: "issue_epic_2",
+          identifier: "ENG-43",
+        }),
         delete: mockDelete,
       };
 
@@ -208,7 +212,7 @@ describe("LinearAdapter - Dependency Operations", () => {
         id: "issue_epic_2",
         identifier: "ENG-43",
         _raw: {
-          relations: mock(async () => ({
+          inverseRelations: mock(async () => ({
             nodes: [mockRelation],
           })),
         },
@@ -235,7 +239,7 @@ describe("LinearAdapter - Dependency Operations", () => {
         id: "issue_epic_1",
         identifier: "ENG-42",
         _raw: {
-          relations: mock(async () => ({ nodes: [] })),
+          inverseRelations: mock(async () => ({ nodes: [] })),
         },
       });
 
@@ -265,7 +269,7 @@ describe("LinearAdapter - Dependency Operations", () => {
         id: "issue_epic_2",
         identifier: "ENG-43",
         _raw: {
-          relations: mock(async () => ({
+          inverseRelations: mock(async () => ({
             nodes: [], // No relations
           })),
         },
@@ -294,19 +298,31 @@ describe("LinearAdapter - Dependency Operations", () => {
         id: "issue_epic_1",
         identifier: "ENG-43",
         _raw: {
-          relations: mock(async () => ({
+          inverseRelations: mock(async () => ({
             nodes: [
               {
                 id: "relation_1",
                 type: "blocks",
-                issue: { id: "issue_epic_2", identifier: "ENG-42" },
-                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+                issue: Promise.resolve({
+                  id: "issue_epic_2",
+                  identifier: "ENG-42",
+                }),
+                relatedIssue: Promise.resolve({
+                  id: "issue_epic_1",
+                  identifier: "ENG-43",
+                }),
               },
               {
                 id: "relation_2",
                 type: "blocks",
-                issue: { id: "issue_epic_3", identifier: "ENG-44" },
-                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+                issue: Promise.resolve({
+                  id: "issue_epic_3",
+                  identifier: "ENG-44",
+                }),
+                relatedIssue: Promise.resolve({
+                  id: "issue_epic_1",
+                  identifier: "ENG-43",
+                }),
               },
             ],
           })),
@@ -328,7 +344,7 @@ describe("LinearAdapter - Dependency Operations", () => {
         id: "issue_epic_1",
         identifier: "ENG-42",
         _raw: {
-          relations: mock(async () => ({
+          inverseRelations: mock(async () => ({
             nodes: [],
           })),
         },
@@ -349,25 +365,43 @@ describe("LinearAdapter - Dependency Operations", () => {
         id: "issue_epic_1",
         identifier: "ENG-43",
         _raw: {
-          relations: mock(async () => ({
+          inverseRelations: mock(async () => ({
             nodes: [
               {
                 id: "relation_1",
                 type: "blocks",
-                issue: { id: "issue_epic_2", identifier: "ENG-42" },
-                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+                issue: Promise.resolve({
+                  id: "issue_epic_2",
+                  identifier: "ENG-42",
+                }),
+                relatedIssue: Promise.resolve({
+                  id: "issue_epic_1",
+                  identifier: "ENG-43",
+                }),
               },
               {
                 id: "relation_2",
                 type: "duplicate",
-                issue: { id: "issue_epic_3", identifier: "ENG-44" },
-                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+                issue: Promise.resolve({
+                  id: "issue_epic_3",
+                  identifier: "ENG-44",
+                }),
+                relatedIssue: Promise.resolve({
+                  id: "issue_epic_1",
+                  identifier: "ENG-43",
+                }),
               },
               {
                 id: "relation_3",
                 type: "related",
-                issue: { id: "issue_epic_4", identifier: "ENG-45" },
-                relatedIssue: { id: "issue_epic_1", identifier: "ENG-43" },
+                issue: Promise.resolve({
+                  id: "issue_epic_4",
+                  identifier: "ENG-45",
+                }),
+                relatedIssue: Promise.resolve({
+                  id: "issue_epic_1",
+                  identifier: "ENG-43",
+                }),
               },
             ],
           })),

package/src/server/adapters/linear/adapter.ts

@@ -887,16 +887,22 @@ export class LinearAdapter implements BackendAdapter {
     if (!blockedIssue) throw new Error(`Issue not found: ${ref}`);
     if (!blockerIssue) throw new Error(`Issue not found: ${dependsOnRef}`);
 
+    // Use inverseRelations to find relations where blockedIssue is the target
     const relations = await this.client.execute<any>(() =>
-      blockedIssue._raw.relations(),
+      blockedIssue._raw.inverseRelations(),
     );
 
-    const relationToDelete = relations.nodes.find(
-      (rel: any) =>
-        rel.type === "blocks" &&
-        rel.issue.id === blockerIssue.id &&
-        rel.relatedIssue.id === blockedIssue.id,
-    );
+    // Find the relation to delete - need to await rel.issue since it's lazy-loaded
+    let relationToDelete: any = null;
+    for (const rel of relations.nodes) {
+      if (rel.type === "blocks") {
+        const relIssue = await rel.issue;
+        if (relIssue?.id === blockerIssue.id) {
+          relationToDelete = rel;
+          break;
+        }
+      }
+    }
 
     if (!relationToDelete) {
       throw new Error(
@@ -911,18 +917,17 @@ export class LinearAdapter implements BackendAdapter {
     const issue = await this.fetchIssue(ref);
     if (!issue) throw new Error(`Issue not found: ${ref}`);
 
+    // Use inverseRelations to get relations where this issue is the target (relatedIssueId)
+    // This finds issues that block this one
     const relations = await this.client.execute<any>(() =>
-      issue._raw.relations(),
+      issue._raw.inverseRelations(),
     );
 
     const blockingRefs: string[] = [];
     for (const rel of relations.nodes) {
-      if (
-        rel.type === "blocks" &&
-        rel.relatedIssue &&
-        (rel.relatedIssue as any).id === issue.id
-      ) {
-        const blockerIssue = rel.issue as any;
+      if (rel.type === "blocks") {
+        // Linear SDK returns lazy-loaded promises for related objects
+        const blockerIssue = await rel.issue;
         if (blockerIssue?.identifier) {
           blockingRefs.push(blockerIssue.identifier);
         }

package/src/server/adapters/local-adapter.ts

@@ -312,6 +312,14 @@ export class LocalAdapter implements BackendAdapter {
       cascade.epics++;
     }
 
+    // Delete PRD dependencies
+    const deletedDeps = db
+      .query(
+        "DELETE FROM prd_dependencies WHERE prd_id = ? OR depends_on_prd_id = ?",
+      )
+      .run(prd.id, prd.id);
+    cascade.dependencies += deletedDeps.changes;
+
     remove(db, "prds", prd.id);
 
     return { deleted: ref, cascade };
@@ -710,7 +718,15 @@ export class LocalAdapter implements BackendAdapter {
       throw new Error("Dependencies must be between entities of the same type");
     }
 
-    if (entityType === "E") {
+    if (entityType === "P") {
+      const prd = findByRef<PrdRow>(db, "prds", ref);
+      const dependsOnPrd = findByRef<PrdRow>(db, "prds", dependsOnRef);
+      if (!prd || !dependsOnPrd) throw new Error("PRD not found");
+
+      db.query(
+        "INSERT OR IGNORE INTO prd_dependencies (prd_id, depends_on_prd_id) VALUES (?, ?)",
+      ).run(prd.id, dependsOnPrd.id);
+    } else if (entityType === "E") {
       const epic = findByRef<EpicRow>(db, "epics", ref);
       const dependsOnEpic = findByRef<EpicRow>(db, "epics", dependsOnRef);
       if (!epic || !dependsOnEpic) throw new Error("Epic not found");
@@ -726,8 +742,6 @@ export class LocalAdapter implements BackendAdapter {
       db.query(
         "INSERT OR IGNORE INTO task_dependencies (task_id, depends_on_task_id) VALUES (?, ?)",
       ).run(task.id, dependsOnTask.id);
-    } else {
-      throw new Error("Dependencies can only be added to Epics or Tasks");
     }
   }
 
@@ -735,7 +749,15 @@ export class LocalAdapter implements BackendAdapter {
     const db = getDb();
     const entityType = getEntityType(ref);
 
-    if (entityType === "E") {
+    if (entityType === "P") {
+      const prd = findByRef<PrdRow>(db, "prds", ref);
+      const dependsOnPrd = findByRef<PrdRow>(db, "prds", dependsOnRef);
+      if (!prd || !dependsOnPrd) throw new Error("PRD not found");
+
+      db.query(
+        "DELETE FROM prd_dependencies WHERE prd_id = ? AND depends_on_prd_id = ?",
+      ).run(prd.id, dependsOnPrd.id);
+    } else if (entityType === "E") {
       const epic = findByRef<EpicRow>(db, "epics", ref);
       const dependsOnEpic = findByRef<EpicRow>(db, "epics", dependsOnRef);
       if (!epic || !dependsOnEpic) throw new Error("Epic not found");
@@ -758,7 +780,20 @@ export class LocalAdapter implements BackendAdapter {
     const db = getDb();
     const entityType = getEntityType(ref);
 
-    if (entityType === "E") {
+    if (entityType === "P") {
+      const prd = findByRef<PrdRow>(db, "prds", ref);
+      if (!prd) return [];
+
+      const deps = db
+        .query(
+          `SELECT p.ref FROM prd_dependencies pd
+           JOIN prds p ON pd.depends_on_prd_id = p.id
+           WHERE pd.prd_id = ?`,
+        )
+        .all(prd.id) as { ref: string }[];
+
+      return deps.map((d) => d.ref);
+    } else if (entityType === "E") {
       const epic = findByRef<EpicRow>(db, "epics", ref);
       if (!epic) return [];
 

package/src/server/db/schema.ts

@@ -77,6 +77,15 @@ CREATE TABLE IF NOT EXISTS task_dependencies (
   FOREIGN KEY (depends_on_task_id) REFERENCES tasks(id)
 );
 
+-- PRD Dependencies
+CREATE TABLE IF NOT EXISTS prd_dependencies (
+  prd_id TEXT NOT NULL,
+  depends_on_prd_id TEXT NOT NULL,
+  PRIMARY KEY (prd_id, depends_on_prd_id),
+  FOREIGN KEY (prd_id) REFERENCES prds(id),
+  FOREIGN KEY (depends_on_prd_id) REFERENCES prds(id)
+);
+
 -- Indexes for common queries
 CREATE INDEX IF NOT EXISTS idx_prds_project ON prds(project_id);
 CREATE INDEX IF NOT EXISTS idx_prds_status ON prds(status);

package/src/server/tools/__tests__/crud.test.ts

@@ -53,6 +53,7 @@ describe("CRUD MCP Tools", () => {
       expect(result.ref).toBeDefined();
       expect(result.status).toBe("DRAFT");
       expect(result.id).toBeDefined();
+      expect(result.dependencies).toEqual([]);
     });
 
     test("creates PRD with optional fields", async () => {
@@ -64,6 +65,17 @@ describe("CRUD MCP Tools", () => {
       expect(result.description).toBe("A description");
       expect(result.tag).toBe("mvp");
     });
+
+    test("creates PRD with depends_on", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+      const prd3 = (await createPrdTool.handler({
+        title: "PRD 3",
+        depends_on: [prd1.ref, prd2.ref],
+      })) as any;
+
+      expect(prd3.dependencies).toEqual([prd1.ref, prd2.ref]);
+    });
   });
 
   describe("create_epic", () => {
@@ -77,6 +89,7 @@ describe("CRUD MCP Tools", () => {
       expect(epic.title).toBe("Test Epic");
       expect(epic.ref).toBeDefined();
       expect(epic.status).toBe("PENDING");
+      expect(epic.dependencies).toEqual([]);
     });
 
     test("creates epic with acceptance criteria", async () => {
@@ -94,6 +107,25 @@ describe("CRUD MCP Tools", () => {
         createEpicTool.handler({ prd_ref: "INVALID-P999", title: "Test" }),
       ).rejects.toThrow("PRD not found");
     });
+
+    test("creates epic with depends_on", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic1 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 1",
+      })) as any;
+      const epic2 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 2",
+      })) as any;
+      const epic3 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 3",
+        depends_on: [epic1.ref, epic2.ref],
+      })) as any;
+
+      expect(epic3.dependencies).toEqual([epic1.ref, epic2.ref]);
+    });
   });
 
   describe("create_task", () => {
@@ -111,6 +143,7 @@ describe("CRUD MCP Tools", () => {
       expect(task.title).toBe("Test Task");
       expect(task.ref).toBeDefined();
       expect(task.priority).toBe("MEDIUM");
+      expect(task.dependencies).toEqual([]);
     });
 
     test("creates task with priority", async () => {
@@ -126,6 +159,29 @@ describe("CRUD MCP Tools", () => {
       })) as any;
       expect(task.priority).toBe("HIGH");
     });
+
+    test("creates task with depends_on", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Test Epic",
+      })) as any;
+      const task1 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 1",
+      })) as any;
+      const task2 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 2",
+      })) as any;
+      const task3 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 3",
+        depends_on: [task1.ref, task2.ref],
+      })) as any;
+
+      expect(task3.dependencies).toEqual([task1.ref, task2.ref]);
+    });
   });
 
   describe("update_entity", () => {
@@ -183,6 +239,19 @@ describe("CRUD MCP Tools", () => {
       const result = (await deleteEntityTool.handler({ ref: epic.ref })) as any;
       expect(result.cascade.tasks).toBe(2);
     });
+
+    test("cascade deletes PRD with dependencies", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+      await addDependencyTool.handler({
+        ref: prd2.ref,
+        depends_on_ref: prd1.ref,
+      });
+
+      const result = (await deleteEntityTool.handler({ ref: prd1.ref })) as any;
+      expect(result.deleted).toBe(prd1.ref);
+      expect(result.cascade.dependencies).toBe(1);
+    });
   });
 
   describe("dependencies", () => {
@@ -210,6 +279,26 @@ describe("CRUD MCP Tools", () => {
       expect(removeResult.success).toBe(true);
     });
 
+    test("adds and removes PRD dependency", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+
+      const addResult = (await addDependencyTool.handler({
+        ref: prd2.ref,
+        depends_on_ref: prd1.ref,
+      })) as any;
+      expect(addResult.success).toBe(true);
+      expect(addResult.ref).toBe(prd2.ref);
+      expect(addResult.depends_on).toBe(prd1.ref);
+
+      const removeResult = (await removeDependencyTool.handler({
+        ref: prd2.ref,
+        depends_on_ref: prd1.ref,
+      })) as any;
+      expect(removeResult.success).toBe(true);
+      expect(removeResult.removed_dependency).toBe(prd1.ref);
+    });
+
     test("prevents self-dependency", async () => {
       const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
       const epic = (await createEpicTool.handler({
@@ -221,6 +310,26 @@ describe("CRUD MCP Tools", () => {
         addDependencyTool.handler({ ref: epic.ref, depends_on_ref: epic.ref }),
       ).rejects.toThrow("depend on itself");
     });
+
+    test("prevents PRD self-dependency", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+
+      await expect(
+        addDependencyTool.handler({ ref: prd.ref, depends_on_ref: prd.ref }),
+      ).rejects.toThrow("depend on itself");
+    });
+
+    test("prevents cross-type dependencies between PRD and Epic", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic",
+      })) as any;
+
+      await expect(
+        addDependencyTool.handler({ ref: prd.ref, depends_on_ref: epic.ref }),
+      ).rejects.toThrow("same type");
+    });
   });
 
   describe("criteria", () => {

package/src/server/tools/__tests__/query.test.ts

@@ -114,6 +114,75 @@ describe("Query MCP Tools", () => {
       expect(result.dependencies[0]).toBe(epic1.ref);
     });
 
+    test("returns dependencies by default for PRD without include", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+      await addDependencyTool.handler({
+        ref: prd2.ref,
+        depends_on_ref: prd1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: prd2.ref,
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      expect(result.dependencies[0]).toBe(prd1.ref);
+    });
+
+    test("returns dependencies by default for Epic without include", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic1 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 1",
+      })) as any;
+      const epic2 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 2",
+      })) as any;
+      await addDependencyTool.handler({
+        ref: epic2.ref,
+        depends_on_ref: epic1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: epic2.ref,
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      expect(result.dependencies[0]).toBe(epic1.ref);
+    });
+
+    test("returns dependencies by default for Task without include", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Test Epic",
+      })) as any;
+      const task1 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 1",
+      })) as any;
+      const task2 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 2",
+      })) as any;
+      await addDependencyTool.handler({
+        ref: task2.ref,
+        depends_on_ref: task1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: task2.ref,
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      expect(result.dependencies[0]).toBe(task1.ref);
+    });
+
     test("throws error for invalid ref", async () => {
       await expect(
         getEntityTool.handler({ ref: "INVALID-P999" }),

package/src/server/tools/create-epic.ts

@@ -8,6 +8,7 @@ const inputSchema = z.object({
   title: z.string().min(1, "Title is required"),
   description: z.string().optional(),
   acceptance_criteria: z.array(z.string()).optional(),
+  depends_on: z.array(z.string()).optional(),
 });
 
 async function handler(input: unknown) {
@@ -23,13 +24,21 @@ async function handler(input: unknown) {
 
   const criteriaCount = parsed.acceptance_criteria?.length || 0;
 
-  return { ...toMcpEpic(epic), criteria_count: criteriaCount };
+  const dependencies: string[] = [];
+  if (parsed.depends_on && parsed.depends_on.length > 0) {
+    for (const depRef of parsed.depends_on) {
+      await adapter.addDependency(epic.ref, depRef);
+      dependencies.push(depRef);
+    }
+  }
+
+  return { ...toMcpEpic(epic), criteria_count: criteriaCount, dependencies };
 }
 
 export const createEpicTool: ToolDefinition = {
   name: "create_epic",
   description:
-    "Create a new Epic under a PRD. Required: prd_ref (e.g., 'FLUX-P1'), title. Optional: description, acceptance_criteria (string array). Returns {id, ref, title, status, criteria_count}. Status starts as PENDING.",
+    "Create a new Epic under a PRD. Required: prd_ref (e.g., 'FLUX-P1'), title. Optional: description, acceptance_criteria (string array), depends_on (array of Epic refs this Epic depends on, e.g., ['FLUX-E1']). Returns {id, ref, title, status, criteria_count, dependencies}. Status starts as PENDING.",
   inputSchema,
   handler,
 };

package/src/server/tools/create-prd.ts

@@ -7,6 +7,7 @@ const inputSchema = z.object({
   title: z.string().min(1, "Title is required"),
   description: z.string().optional(),
   tag: z.string().optional(),
+  depends_on: z.array(z.string()).optional(),
 });
 
 async function handler(input: unknown) {
@@ -19,13 +20,21 @@ async function handler(input: unknown) {
     tag: parsed.tag,
   });
 
-  return toMcpPrd(prd);
+  const dependencies: string[] = [];
+  if (parsed.depends_on && parsed.depends_on.length > 0) {
+    for (const depRef of parsed.depends_on) {
+      await adapter.addDependency(prd.ref, depRef);
+      dependencies.push(depRef);
+    }
+  }
+
+  return { ...toMcpPrd(prd), dependencies };
 }
 
 export const createPrdTool: ToolDefinition = {
   name: "create_prd",
   description:
-    "Create a new PRD (Product Requirements Document). Required: title. Optional: description, tag. Returns the created PRD with {id, ref, title, description, status, tag}. Status starts as DRAFT.",
+    "Create a new PRD (Product Requirements Document). Required: title. Optional: description, tag, depends_on (array of PRD refs this PRD depends on, e.g., ['FLUX-P1', 'FLUX-P2']). Returns the created PRD with {id, ref, title, description, status, tag, dependencies}. Status starts as DRAFT.",
   inputSchema,
   handler,
 };

package/src/server/tools/create-task.ts

@@ -10,6 +10,7 @@ const inputSchema = z.object({
   description: z.string().optional(),
   priority: z.enum(["LOW", "MEDIUM", "HIGH"]).optional().default("MEDIUM"),
   acceptance_criteria: z.array(z.string()).optional(),
+  depends_on: z.array(z.string()).optional(),
 });
 
 async function handler(input: unknown) {
@@ -26,13 +27,21 @@ async function handler(input: unknown) {
 
   const criteriaCount = parsed.acceptance_criteria?.length || 0;
 
-  return { ...toMcpTask(task), criteria_count: criteriaCount };
+  const dependencies: string[] = [];
+  if (parsed.depends_on && parsed.depends_on.length > 0) {
+    for (const depRef of parsed.depends_on) {
+      await adapter.addDependency(task.ref, depRef);
+      dependencies.push(depRef);
+    }
+  }
+
+  return { ...toMcpTask(task), criteria_count: criteriaCount, dependencies };
 }
 
 export const createTaskTool: ToolDefinition = {
   name: "create_task",
   description:
-    "Create a new Task under an Epic. Required: epic_ref (e.g., 'FLUX-E1'), title. Optional: description, priority (LOW|MEDIUM|HIGH, default MEDIUM), acceptance_criteria (string array). Returns {id, ref, title, status, priority, criteria_count}.",
+    "Create a new Task under an Epic. Required: epic_ref (e.g., 'FLUX-E1'), title. Optional: description, priority (LOW|MEDIUM|HIGH, default MEDIUM), acceptance_criteria (string array), depends_on (array of Task refs this Task depends on, e.g., ['FLUX-T1']). Returns {id, ref, title, status, priority, criteria_count, dependencies}.",
   inputSchema,
   handler,
 };

package/src/server/tools/dependencies.ts

@@ -41,7 +41,7 @@ async function removeDependencyHandler(input: unknown) {
 export const addDependencyTool: ToolDefinition = {
   name: "add_dependency",
   description:
-    "Add a dependency between two entities of the same type. Required: ref (depends on depends_on_ref), depends_on_ref. Both must be Epics (FLUX-E*) or both Tasks (FLUX-T*). Validates no circular dependencies. Returns {success, ref, depends_on}.",
+    "Add a dependency between two entities of the same type. Required: ref (depends on depends_on_ref), depends_on_ref. Both must be PRDs (FLUX-P*), Epics (FLUX-E*), or Tasks (FLUX-T*). Validates no circular dependencies. Returns {success, ref, depends_on}.",
   inputSchema: addDependencySchema,
   handler: addDependencyHandler,
 };
@@ -49,7 +49,7 @@ export const addDependencyTool: ToolDefinition = {
 export const removeDependencyTool: ToolDefinition = {
   name: "remove_dependency",
   description:
-    "Remove a dependency between two entities. Required: ref, depends_on_ref. Both must be same type (Epic or Task). Returns {success, ref, removed_dependency}.",
+    "Remove a dependency between two entities. Required: ref, depends_on_ref. Both must be same type (PRD, Epic, or Task). Returns {success, ref, removed_dependency}.",
   inputSchema: removeDependencySchema,
   handler: removeDependencyHandler,
 };