@cliangdev/flux-plugin 0.1.0-dev.588ae42 → 0.2.0-dev.2b9c207

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

@@ -16,7 +16,6 @@ import { createPrdTool } from "../create-prd.js";
 import { createTaskTool } from "../create-task.js";
 import { addDependencyTool } from "../dependencies.js";
 import { getEntityTool } from "../get-entity.js";
-import { getProjectContextTool } from "../get-project-context.js";
 import { getStatsTool } from "../get-stats.js";
 import { initProjectTool } from "../init-project.js";
 import { queryEntitiesTool } from "../query-entities.js";
@@ -115,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" }),
@@ -242,24 +310,6 @@ describe("Query MCP Tools", () => {
     });
   });
 
-  describe("get_project_context", () => {
-    test("returns project context when initialized", async () => {
-      const result = (await getProjectContextTool.handler({})) as any;
-
-      expect(result.initialized).toBe(true);
-      expect(result.name).toBe("test-project");
-      expect(result.ref_prefix).toBe("TEST");
-    });
-
-    test("returns initialized false when no project", async () => {
-      // Remove the project.json
-      rmSync(join(FLUX_DIR, "project.json"));
-
-      const result = (await getProjectContextTool.handler({})) as any;
-      expect(result.initialized).toBe(false);
-    });
-  });
-
   describe("get_stats", () => {
     test("returns zeroes for empty project", async () => {
       const result = (await getStatsTool.handler({})) as any;

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,
 };

package/src/server/tools/get-entity.ts

@@ -85,6 +85,10 @@ async function handler(input: unknown) {
     // Add available status transitions
     result.available_transitions = getValidTransitions(entityType, prd.status);
 
+    // Always include dependencies by default
+    const deps = await adapter.getDependencies(parsed.ref);
+    result.dependencies = deps;
+
     // Process includes
     for (const inc of includes) {
       if (!validIncludes.includes(inc)) continue;
@@ -166,6 +170,10 @@ async function handler(input: unknown) {
     result = { ...toMcpEpic(epic) };
     result.available_transitions = getValidTransitions(entityType, epic.status);
 
+    // Always include dependencies by default
+    const deps = await adapter.getDependencies(parsed.ref);
+    result.dependencies = deps;
+
     for (const inc of includes) {
       if (!validIncludes.includes(inc)) continue;
 
@@ -192,11 +200,6 @@ async function handler(input: unknown) {
         result.criteria_count = criteria.length;
         result.criteria_met = criteria.filter((c) => c.isMet).length;
       }
-
-      if (inc === "dependencies") {
-        const deps = await adapter.getDependencies(parsed.ref);
-        result.dependencies = deps;
-      }
     }
   } else {
     const task = await adapter.getTask(parsed.ref);
@@ -205,6 +208,10 @@ async function handler(input: unknown) {
     result = { ...toMcpTask(task) };
     result.available_transitions = getValidTransitions(entityType, task.status);
 
+    // Always include dependencies by default
+    const deps = await adapter.getDependencies(parsed.ref);
+    result.dependencies = deps;
+
     for (const inc of includes) {
       if (!validIncludes.includes(inc)) continue;
 
@@ -218,11 +225,6 @@ async function handler(input: unknown) {
         result.criteria_count = criteria.length;
         result.criteria_met = criteria.filter((c) => c.isMet).length;
       }
-
-      if (inc === "dependencies") {
-        const deps = await adapter.getDependencies(parsed.ref);
-        result.dependencies = deps;
-      }
     }
   }
 

package/src/server/tools/index.ts

@@ -7,11 +7,7 @@ import { z } from "zod";
 import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 
-const TOOLS_WITHOUT_PROJECT = [
-  "init_project",
-  "get_project_context",
-  "get_version",
-];
+const TOOLS_WITHOUT_PROJECT = ["init_project", "get_version"];
 
 export interface ToolDefinition {
   name: string;
@@ -26,10 +22,56 @@ export interface ToolError {
   code: string;
 }
 
+export interface ProjectNotInitializedError extends ToolError {
+  code: "PROJECT_NOT_INITIALIZED";
+  setup: {
+    instructions: string;
+    options: Array<{
+      method: "command" | "tool";
+      name: string;
+      description: string;
+      params?: Record<string, string>;
+    }>;
+  };
+}
+
 export function createError(message: string, code: string): ToolError {
   return { error: true, message, code };
 }
 
+export function createProjectNotInitializedError(
+  cwd: string,
+  projectRoot: string,
+): ProjectNotInitializedError {
+  return {
+    error: true,
+    code: "PROJECT_NOT_INITIALIZED",
+    message: `No Flux project found. Current directory: ${cwd}, resolved project root: ${projectRoot}`,
+    setup: {
+      instructions:
+        "Initialize a Flux project before using Flux tools. Use one of the following options:",
+      options: [
+        {
+          method: "command",
+          name: "/flux",
+          description:
+            "Interactive setup with guided prompts (recommended for first-time setup)",
+        },
+        {
+          method: "tool",
+          name: "init_project",
+          description: "Direct initialization via MCP tool",
+          params: {
+            name: "Project name (required)",
+            vision: "Brief project description (required)",
+            adapter: "local | linear (default: local)",
+          },
+        },
+      ],
+    },
+  };
+}
+
 export function registerTools(server: Server, tools: ToolDefinition[]) {
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: tools.map((t) => ({
@@ -60,13 +102,16 @@ export function registerTools(server: Server, tools: ToolDefinition[]) {
     }
 
     if (!TOOLS_WITHOUT_PROJECT.includes(toolName) && !config.projectExists) {
-      const message = `No Flux project found. Run init_project first or ensure you're in a directory with a .flux folder (or a subdirectory of one). Current directory: ${process.cwd()}, resolved project root: ${config.projectRoot}`;
-      logger.error(message);
+      const error = createProjectNotInitializedError(
+        process.cwd(),
+        config.projectRoot,
+      );
+      logger.error(error.message);
       return {
         content: [
           {
             type: "text",
-            text: JSON.stringify(createError(message, "PROJECT_NOT_FOUND")),
+            text: JSON.stringify(error, null, 2),
           },
         ],
         isError: true,
@@ -104,7 +149,6 @@ export { deleteEntityTool } from "./delete-entity.js";
 export { addDependencyTool, removeDependencyTool } from "./dependencies.js";
 export { getEntityTool } from "./get-entity.js";
 export { getLinearUrlTool } from "./get-linear-url.js";
-export { getProjectContextTool } from "./get-project-context.js";
 export { getStatsTool } from "./get-stats.js";
 export { getVersionTool } from "./get-version.js";
 export { initProjectTool } from "./init-project.js";

package/src/server/tools/init-project.ts

@@ -102,7 +102,7 @@ async function handler(input: unknown) {
 export const initProjectTool: ToolDefinition = {
   name: "init_project",
   description:
-    "Initialize a new Flux project. Required: name, vision. Optional: adapter (local|specflux|linear|notion, default 'local'). Creates .flux/ directory with project.json and SQLite database. Returns {success, project, message}. Fails if .flux/ already exists. Run get_project_context first to check.",
+    "Initialize a new Flux project. Required: name, vision. Optional: adapter (local|specflux|linear|notion, default 'local'). Creates .flux/ directory with project.json and SQLite database. Returns {success, project, message}. Fails if .flux/ already exists.",
   inputSchema,
   handler,
 };

package/src/server/tools/render-status.ts

@@ -23,6 +23,7 @@ interface EpicForSummary {
   status: string;
   task_count: number;
   tasks_completed: number;
+  dependencies: string[];
 }
 
 interface PrdForSummary {
@@ -30,12 +31,14 @@ interface PrdForSummary {
   title: string;
   status: string;
   epics: EpicForSummary[];
+  dependencies: string[];
 }
 
 interface TaskForFull {
   ref: string;
   title: string;
   status: string;
+  dependencies: string[];
 }
 
 interface EpicForFull {
@@ -43,6 +46,7 @@ interface EpicForFull {
   title: string;
   status: string;
   tasks: TaskForFull[];
+  dependencies: string[];
 }
 
 interface PrdForFull {
@@ -50,6 +54,7 @@ interface PrdForFull {
   title: string;
   status: string;
   epics: EpicForFull[];
+  dependencies: string[];
 }
 
 function getProjectInfo(): { name: string; ref_prefix: string } | null {
@@ -110,17 +115,17 @@ async function getSummaryData(adapter: Adapter): Promise<PrdForSummary[]> {
   const result: PrdForSummary[] = [];
 
   for (const prd of nonArchivedPrds) {
-    const epicsResult = await adapter.listEpics(
-      { prdRef: prd.ref },
-      { limit: 100 },
-    );
+    const [prdDeps, epicsResult] = await Promise.all([
+      adapter.getDependencies(prd.ref),
+      adapter.listEpics({ prdRef: prd.ref }, { limit: 100 }),
+    ]);
 
     const epicsWithCounts: EpicForSummary[] = await Promise.all(
       epicsResult.items.map(async (epic) => {
-        const tasksResult = await adapter.listTasks(
-          { epicRef: epic.ref },
-          { limit: 100 },
-        );
+        const [epicDeps, tasksResult] = await Promise.all([
+          adapter.getDependencies(epic.ref),
+          adapter.listTasks({ epicRef: epic.ref }, { limit: 100 }),
+        ]);
         const completedCount = tasksResult.items.filter(
           (t) => t.status === "COMPLETED",
         ).length;
@@ -131,6 +136,7 @@ async function getSummaryData(adapter: Adapter): Promise<PrdForSummary[]> {
           status: epic.status,
           task_count: tasksResult.total,
           tasks_completed: completedCount,
+          dependencies: epicDeps,
         };
       }),
     );
@@ -140,6 +146,7 @@ async function getSummaryData(adapter: Adapter): Promise<PrdForSummary[]> {
       title: prd.title,
       status: prd.status,
       epics: epicsWithCounts,
+      dependencies: prdDeps,
     });
   }
 
@@ -156,27 +163,37 @@ async function getFullTreeData(adapter: Adapter): Promise<PrdForFull[]> {
   const result: PrdForFull[] = [];
 
   for (const prd of allPrds) {
-    const epicsResult = await adapter.listEpics(
-      { prdRef: prd.ref },
-      { limit: 100 },
-    );
+    const [prdDeps, epicsResult] = await Promise.all([
+      adapter.getDependencies(prd.ref),
+      adapter.listEpics({ prdRef: prd.ref }, { limit: 100 }),
+    ]);
 
     const epicsWithTasks: EpicForFull[] = await Promise.all(
       epicsResult.items.map(async (epic) => {
-        const tasksResult = await adapter.listTasks(
-          { epicRef: epic.ref },
-          { limit: 100 },
+        const [epicDeps, tasksResult] = await Promise.all([
+          adapter.getDependencies(epic.ref),
+          adapter.listTasks({ epicRef: epic.ref }, { limit: 100 }),
+        ]);
+
+        // Get dependencies for each task
+        const tasksWithDeps: TaskForFull[] = await Promise.all(
+          tasksResult.items.map(async (t) => {
+            const taskDeps = await adapter.getDependencies(t.ref);
+            return {
+              ref: t.ref,
+              title: t.title,
+              status: t.status,
+              dependencies: taskDeps,
+            };
+          }),
         );
 
         return {
           ref: epic.ref,
           title: epic.title,
           status: epic.status,
-          tasks: tasksResult.items.map((t) => ({
-            ref: t.ref,
-            title: t.title,
-            status: t.status,
-          })),
+          tasks: tasksWithDeps,
+          dependencies: epicDeps,
         };
       }),
     );
@@ -186,6 +203,7 @@ async function getFullTreeData(adapter: Adapter): Promise<PrdForFull[]> {
       title: prd.title,
       status: prd.status,
       epics: epicsWithTasks,
+      dependencies: prdDeps,
     });
   }
 

package/src/utils/status-renderer.ts

@@ -34,12 +34,14 @@ interface Epic {
   status: string;
   task_count: number;
   tasks_completed: number;
+  dependencies?: string[];
 }
 
 interface Task {
   ref: string;
   title: string;
   status: string;
+  dependencies?: string[];
 }
 
 interface EpicWithTasks {
@@ -47,6 +49,7 @@ interface EpicWithTasks {
   title: string;
   status: string;
   tasks: Task[];
+  dependencies?: string[];
 }
 
 interface Prd {
@@ -54,6 +57,7 @@ interface Prd {
   title: string;
   status: string;
   epics: Epic[];
+  dependencies?: string[];
 }
 
 interface PrdWithTasks {
@@ -61,6 +65,7 @@ interface PrdWithTasks {
   title: string;
   status: string;
   epics: EpicWithTasks[];
+  dependencies?: string[];
 }
 
 const STATUS_ORDER: Record<string, number> = {
@@ -117,13 +122,22 @@ export function renderSummaryView(
 
   for (const prd of sortedPrds) {
     const badge = getStatusBadge(prd.status);
-    lines.push(`${prd.ref} ${prd.title}  ${badge}`);
+    const prdBlocked = prd.dependencies && prd.dependencies.length > 0;
+    const prdBlockedBy = prdBlocked
+      ? ` ⚠️ blocked by: ${prd.dependencies?.join(", ")}`
+      : "";
+    lines.push(`${prd.ref} ${prd.title}  ${badge}${prdBlockedBy}`);
 
     for (const epic of prd.epics) {
       const icon = getStatusIcon(epic.status);
+      const epicBlocked = epic.dependencies && epic.dependencies.length > 0;
+      const epicBlockedBy = epicBlocked
+        ? ` ⚠️ blocked by: ${epic.dependencies?.join(", ")}`
+        : "";
+
       if (epic.task_count === 0) {
         lines.push(
-          `  ${icon} ${epic.ref} ${epic.title}  ·········· (no tasks)`,
+          `  ${icon} ${epic.ref} ${epic.title}  ·········· (no tasks)${epicBlockedBy}`,
         );
       } else {
         const epicProgress = renderProgressBar(
@@ -131,7 +145,7 @@ export function renderSummaryView(
           10,
         );
         lines.push(
-          `  ${icon} ${epic.ref} ${epic.title}  ${epicProgress} ${epic.tasks_completed}/${epic.task_count}`,
+          `  ${icon} ${epic.ref} ${epic.title}  ${epicProgress} ${epic.tasks_completed}/${epic.task_count}${epicBlockedBy}`,
         );
       }
     }
@@ -157,23 +171,35 @@ export function renderFullTreeView(prds: PrdWithTasks[]): string {
 
   for (const prd of sortedPrds) {
     const prdBadge = getStatusBadge(prd.status);
+    const prdBlocked = prd.dependencies && prd.dependencies.length > 0;
+    const prdBlockedBy = prdBlocked
+      ? `  ⚠️ blocked by: ${prd.dependencies?.join(", ")}`
+      : "";
     lines.push(`${prd.ref} ${prd.title}`);
-    lines.push(`${prdBadge}`);
+    lines.push(`${prdBadge}${prdBlockedBy}`);
     lines.push("");
 
     for (const epic of prd.epics) {
       const epicIcon = getStatusIcon(epic.status);
-      lines.push(`  ${epicIcon} ${epic.ref} ${epic.title}`);
+      const epicBlocked = epic.dependencies && epic.dependencies.length > 0;
+      const epicBlockedBy = epicBlocked
+        ? `  ⚠️ blocked by: ${epic.dependencies?.join(", ")}`
+        : "";
+      lines.push(`  ${epicIcon} ${epic.ref} ${epic.title}${epicBlockedBy}`);
 
       if (epic.tasks.length > 0) {
         lines.push(`  ┌${"─".repeat(50)}┐`);
 
         for (const task of epic.tasks) {
           const taskIcon = getStatusIcon(task.status);
+          const taskBlocked = task.dependencies && task.dependencies.length > 0;
+          const taskBlockedBy = taskBlocked
+            ? `  ⚠️ blocked by: ${task.dependencies?.join(", ")}`
+            : "";
           const currentMarker =
             task.status === "IN_PROGRESS" ? "  ← CURRENT" : "";
           lines.push(
-            `  │ ${taskIcon} ${task.ref} ${task.title}${currentMarker}`,
+            `  │ ${taskIcon} ${task.ref} ${task.title}${currentMarker}${taskBlockedBy}`,
           );
         }