@allpepper/task-orchestrator 1.1.3 → 1.2.0

package/src/repos/tasks.ts

@@ -355,8 +355,8 @@ export function deleteTask(id: string): Result<boolean> {
     db.run('BEGIN TRANSACTION');
 
     try {
-      // Delete related dependencies
-      execute('DELETE FROM dependencies WHERE from_task_id = ? OR to_task_id = ?', [id, id]);
+      // Delete related dependencies (scoped to task entity type)
+      execute('DELETE FROM dependencies WHERE (from_entity_id = ? OR to_entity_id = ?) AND entity_type = ?', [id, id, 'task']);
 
       // Delete related sections
       execute('DELETE FROM sections WHERE entity_type = ? AND entity_id = ?', [EntityType.TASK, id]);

package/src/server.ts

@@ -18,6 +18,8 @@ import {
   registerRenameTagTool,
   registerGetNextTaskTool,
   registerGetBlockedTasksTool,
+  registerGetNextFeatureTool,
+  registerGetBlockedFeaturesTool,
   registerGetNextStatusTool,
   registerQueryWorkflowStateTool,
   registerSetupProjectTool,
@@ -47,6 +49,8 @@ registerGetTagUsageTool(server);
 registerRenameTagTool(server);
 registerGetNextTaskTool(server);
 registerGetBlockedTasksTool(server);
+registerGetNextFeatureTool(server);
+registerGetBlockedFeaturesTool(server);
 registerGetNextStatusTool(server);
 registerQueryWorkflowStateTool(server);
 registerSetupProjectTool(server);
@@ -105,6 +109,8 @@ if (useHttp) {
       registerRenameTagTool(sessionServer);
       registerGetNextTaskTool(sessionServer);
       registerGetBlockedTasksTool(sessionServer);
+      registerGetNextFeatureTool(sessionServer);
+      registerGetBlockedFeaturesTool(sessionServer);
       registerGetNextStatusTool(sessionServer);
       registerQueryWorkflowStateTool(sessionServer);
       registerSetupProjectTool(sessionServer);

package/src/services/status-validator.ts

@@ -1,5 +1,7 @@
 import { ProjectStatus, FeatureStatus, TaskStatus } from '../domain/types';
 
+type TransitionMap = Record<string, string[]>;
+
 // Valid statuses per container type
 const PROJECT_STATUSES = Object.values(ProjectStatus);
 const FEATURE_STATUSES = Object.values(FeatureStatus);
@@ -12,44 +14,44 @@ const TASK_STATUSES = Object.values(TaskStatus);
  * They allow transitions back to earlier workflow stages (BACKLOG/PENDING for tasks,
  * PLANNING for projects) to support reinstating cancelled or deferred work.
  */
-const PROJECT_TRANSITIONS: Record<string, string[]> = {
-  PLANNING: ['IN_DEVELOPMENT', 'ON_HOLD', 'CANCELLED'],
-  IN_DEVELOPMENT: ['COMPLETED', 'ON_HOLD', 'CANCELLED'],
-  ON_HOLD: ['PLANNING', 'IN_DEVELOPMENT', 'CANCELLED'],
-  COMPLETED: ['ARCHIVED'],
-  CANCELLED: ['PLANNING'], // Non-terminal: allows reinstating cancelled projects
-  ARCHIVED: [],
+export const PROJECT_TRANSITIONS: Record<ProjectStatus, ProjectStatus[]> = {
+  [ProjectStatus.PLANNING]: [ProjectStatus.IN_DEVELOPMENT, ProjectStatus.ON_HOLD, ProjectStatus.CANCELLED],
+  [ProjectStatus.IN_DEVELOPMENT]: [ProjectStatus.COMPLETED, ProjectStatus.ON_HOLD, ProjectStatus.CANCELLED],
+  [ProjectStatus.ON_HOLD]: [ProjectStatus.PLANNING, ProjectStatus.IN_DEVELOPMENT, ProjectStatus.CANCELLED],
+  [ProjectStatus.COMPLETED]: [ProjectStatus.ARCHIVED],
+  [ProjectStatus.CANCELLED]: [ProjectStatus.PLANNING], // Non-terminal: allows reinstating cancelled projects
+  [ProjectStatus.ARCHIVED]: [],
 };
 
-const FEATURE_TRANSITIONS: Record<string, string[]> = {
-  DRAFT: ['PLANNING'],
-  PLANNING: ['IN_DEVELOPMENT', 'ON_HOLD'],
-  IN_DEVELOPMENT: ['TESTING', 'BLOCKED', 'ON_HOLD'],
-  TESTING: ['VALIDATING', 'IN_DEVELOPMENT'],
-  VALIDATING: ['PENDING_REVIEW', 'IN_DEVELOPMENT'],
-  PENDING_REVIEW: ['DEPLOYED', 'IN_DEVELOPMENT'],
-  BLOCKED: ['IN_DEVELOPMENT', 'ON_HOLD'],
-  ON_HOLD: ['PLANNING', 'IN_DEVELOPMENT'],
-  DEPLOYED: ['COMPLETED'],
-  COMPLETED: ['ARCHIVED'],
-  ARCHIVED: [],
+export const FEATURE_TRANSITIONS: Record<FeatureStatus, FeatureStatus[]> = {
+  [FeatureStatus.DRAFT]: [FeatureStatus.PLANNING],
+  [FeatureStatus.PLANNING]: [FeatureStatus.IN_DEVELOPMENT, FeatureStatus.ON_HOLD],
+  [FeatureStatus.IN_DEVELOPMENT]: [FeatureStatus.TESTING, FeatureStatus.BLOCKED, FeatureStatus.ON_HOLD],
+  [FeatureStatus.TESTING]: [FeatureStatus.VALIDATING, FeatureStatus.IN_DEVELOPMENT],
+  [FeatureStatus.VALIDATING]: [FeatureStatus.PENDING_REVIEW, FeatureStatus.IN_DEVELOPMENT],
+  [FeatureStatus.PENDING_REVIEW]: [FeatureStatus.DEPLOYED, FeatureStatus.IN_DEVELOPMENT],
+  [FeatureStatus.BLOCKED]: [FeatureStatus.IN_DEVELOPMENT, FeatureStatus.ON_HOLD],
+  [FeatureStatus.ON_HOLD]: [FeatureStatus.PLANNING, FeatureStatus.IN_DEVELOPMENT],
+  [FeatureStatus.DEPLOYED]: [FeatureStatus.COMPLETED],
+  [FeatureStatus.COMPLETED]: [FeatureStatus.ARCHIVED],
+  [FeatureStatus.ARCHIVED]: [],
 };
 
-const TASK_TRANSITIONS: Record<string, string[]> = {
-  BACKLOG: ['PENDING'],
-  PENDING: ['IN_PROGRESS', 'BLOCKED', 'ON_HOLD', 'CANCELLED', 'DEFERRED'],
-  IN_PROGRESS: ['IN_REVIEW', 'TESTING', 'BLOCKED', 'ON_HOLD', 'COMPLETED'],
-  IN_REVIEW: ['CHANGES_REQUESTED', 'COMPLETED'],
-  CHANGES_REQUESTED: ['IN_PROGRESS'],
-  TESTING: ['READY_FOR_QA', 'IN_PROGRESS'],
-  READY_FOR_QA: ['INVESTIGATING', 'DEPLOYED', 'COMPLETED'],
-  INVESTIGATING: ['IN_PROGRESS', 'BLOCKED'],
-  BLOCKED: ['PENDING', 'IN_PROGRESS'],
-  ON_HOLD: ['PENDING', 'IN_PROGRESS'],
-  DEPLOYED: ['COMPLETED'],
-  COMPLETED: [], // Terminal: no transitions allowed
-  CANCELLED: ['BACKLOG', 'PENDING'], // Non-terminal: allows reinstating cancelled tasks
-  DEFERRED: ['BACKLOG', 'PENDING'], // Non-terminal: allows resuming deferred tasks
+export const TASK_TRANSITIONS: Record<TaskStatus, TaskStatus[]> = {
+  [TaskStatus.BACKLOG]: [TaskStatus.PENDING],
+  [TaskStatus.PENDING]: [TaskStatus.IN_PROGRESS, TaskStatus.BLOCKED, TaskStatus.ON_HOLD, TaskStatus.CANCELLED, TaskStatus.DEFERRED],
+  [TaskStatus.IN_PROGRESS]: [TaskStatus.IN_REVIEW, TaskStatus.TESTING, TaskStatus.BLOCKED, TaskStatus.ON_HOLD, TaskStatus.COMPLETED],
+  [TaskStatus.IN_REVIEW]: [TaskStatus.CHANGES_REQUESTED, TaskStatus.COMPLETED],
+  [TaskStatus.CHANGES_REQUESTED]: [TaskStatus.IN_PROGRESS],
+  [TaskStatus.TESTING]: [TaskStatus.READY_FOR_QA, TaskStatus.IN_PROGRESS],
+  [TaskStatus.READY_FOR_QA]: [TaskStatus.INVESTIGATING, TaskStatus.DEPLOYED, TaskStatus.COMPLETED],
+  [TaskStatus.INVESTIGATING]: [TaskStatus.IN_PROGRESS, TaskStatus.BLOCKED],
+  [TaskStatus.BLOCKED]: [TaskStatus.PENDING, TaskStatus.IN_PROGRESS],
+  [TaskStatus.ON_HOLD]: [TaskStatus.PENDING, TaskStatus.IN_PROGRESS],
+  [TaskStatus.DEPLOYED]: [TaskStatus.COMPLETED],
+  [TaskStatus.COMPLETED]: [], // Terminal: no transitions allowed
+  [TaskStatus.CANCELLED]: [TaskStatus.BACKLOG, TaskStatus.PENDING], // Non-terminal: allows reinstating cancelled tasks
+  [TaskStatus.DEFERRED]: [TaskStatus.BACKLOG, TaskStatus.PENDING], // Non-terminal: allows resuming deferred tasks
 };
 
 // Terminal statuses (no transitions out)
@@ -77,7 +79,7 @@ export function getValidStatuses(containerType: ContainerType): string[] {
   }
 }
 
-export function getTransitions(containerType: ContainerType): Record<string, string[]> {
+export function getTransitions(containerType: ContainerType): TransitionMap {
   switch (containerType) {
     case 'project': return PROJECT_TRANSITIONS;
     case 'feature': return FEATURE_TRANSITIONS;

package/src/services/workflow.ts

@@ -6,6 +6,7 @@ import { getTask } from '../repos/tasks';
 import { getDependencies } from '../repos/dependencies';
 import { searchTasks } from '../repos/tasks';
 import type { Result } from '../domain/types';
+import { DependencyEntityType } from '../domain/types';
 import { ok, err } from '../repos/base';
 
 export interface WorkflowState {
@@ -16,8 +17,8 @@ export interface WorkflowState {
   isTerminal: boolean;
   cascadeEvents?: string[];
   blockingDependencies?: Array<{
-    taskId: string;
-    taskTitle: string;
+    entityId: string;
+    entityName: string;
     status: string;
   }>;
 }
@@ -60,22 +61,23 @@ export function getWorkflowState(containerType: ContainerType, id: string): Resu
     isTerminal,
   };
 
-  // 4. For tasks, check blocking dependencies
+  // 4. For tasks and features, check blocking dependencies
   if (containerType === 'task') {
-    const depsResult = getDependencies(id, 'dependents');
+    // 'dependents' finds deps where to_entity_id = id, i.e. deps where this entity is the blocked one
+    const depsResult = getDependencies(id, 'dependents', DependencyEntityType.TASK);
     if (depsResult.success) {
       const blockers = depsResult.data
         .filter(d => d.type === 'BLOCKS')
         .map(d => {
-          const taskResult = getTask(d.fromTaskId);
+          const taskResult = getTask(d.fromEntityId);
           if (taskResult.success) {
             return {
-              taskId: d.fromTaskId,
-              taskTitle: taskResult.data.title,
+              entityId: d.fromEntityId,
+              entityName: taskResult.data.title,
               status: taskResult.data.status,
             };
           }
-          return { taskId: d.fromTaskId, taskTitle: 'Unknown', status: 'UNKNOWN' };
+          return { entityId: d.fromEntityId, entityName: 'Unknown', status: 'UNKNOWN' };
         })
         .filter(b => b.status !== 'COMPLETED' && b.status !== 'CANCELLED');
 
@@ -85,6 +87,31 @@ export function getWorkflowState(containerType: ContainerType, id: string): Resu
     }
   }
 
+  if (containerType === 'feature') {
+    // 'dependents' finds deps where to_entity_id = id, i.e. deps where this entity is the blocked one
+    const depsResult = getDependencies(id, 'dependents', DependencyEntityType.FEATURE);
+    if (depsResult.success) {
+      const blockers = depsResult.data
+        .filter(d => d.type === 'BLOCKS')
+        .map(d => {
+          const featureResult = getFeature(d.fromEntityId);
+          if (featureResult.success) {
+            return {
+              entityId: d.fromEntityId,
+              entityName: featureResult.data.name,
+              status: featureResult.data.status,
+            };
+          }
+          return { entityId: d.fromEntityId, entityName: 'Unknown', status: 'UNKNOWN' };
+        })
+        .filter(b => b.status !== 'COMPLETED' && b.status !== 'ARCHIVED');
+
+      if (blockers.length > 0) {
+        state.blockingDependencies = blockers;
+      }
+    }
+  }
+
   // 5. Detect cascade events for features/projects
   if (containerType === 'feature') {
     const tasksResult = searchTasks({ featureId: id });

package/src/tools/get-blocked-features.ts

@@ -0,0 +1,63 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { createSuccessResponse, createErrorResponse, optionalUuidSchema } from './registry';
+import { getBlocked } from '../repos/dependencies';
+import { DependencyEntityType } from '../domain/types';
+
+/**
+ * Register the get_blocked_features MCP tool.
+ *
+ * Returns all blocked features, either with status 'BLOCKED' or features
+ * that have incomplete blocking dependencies.
+ */
+export function registerGetBlockedFeaturesTool(server: McpServer): void {
+  server.tool(
+    'get_blocked_features',
+    'Get all blocked features. Returns features that either have status BLOCKED or have incomplete blocking dependencies (features that block them but are not completed/archived). Results are sorted by priority (descending) then creation time (ascending).',
+    {
+      projectId: optionalUuidSchema.describe('Filter by project ID')
+    },
+    async (params: any) => {
+      try {
+        const result = getBlocked({
+          entityType: DependencyEntityType.FEATURE,
+          projectId: params.projectId
+        });
+
+        if (!result.success) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify(createErrorResponse(result.error, result.code), null, 2)
+            }]
+          };
+        }
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify(
+              createSuccessResponse(
+                `Found ${result.data.length} blocked feature(s)`,
+                result.data
+              ),
+              null,
+              2
+            )
+          }]
+        };
+      } catch (error: any) {
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify(
+              createErrorResponse('Failed to get blocked features', error.message),
+              null,
+              2
+            )
+          }]
+        };
+      }
+    }
+  );
+}

package/src/tools/get-blocked-tasks.ts

@@ -1,7 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { createSuccessResponse, createErrorResponse, optionalUuidSchema } from './registry';
-import { getBlockedTasks } from '../repos/dependencies';
+import { getBlocked } from '../repos/dependencies';
+import { DependencyEntityType } from '../domain/types';
 
 /**
  * Register the get_blocked_tasks MCP tool.
@@ -19,7 +20,8 @@ export function registerGetBlockedTasksTool(server: McpServer): void {
     },
     async (params: any) => {
       try {
-        const result = getBlockedTasks({
+        const result = getBlocked({
+          entityType: DependencyEntityType.TASK,
           projectId: params.projectId,
           featureId: params.featureId
         });

package/src/tools/get-next-feature.ts

@@ -0,0 +1,75 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { createSuccessResponse, createErrorResponse, optionalUuidSchema } from './registry';
+import { getNext } from '../repos/dependencies';
+import { DependencyEntityType } from '../domain/types';
+
+/**
+ * Register the get_next_feature MCP tool.
+ *
+ * Recommends the next feature to work on by priority,
+ * excluding blocked features.
+ */
+export function registerGetNextFeatureTool(server: McpServer): void {
+  server.tool(
+    'get_next_feature',
+    'Get the next recommended feature to work on. Returns the highest priority DRAFT or PLANNING feature that has no incomplete blocking dependencies. Features are prioritized by priority (HIGH > MEDIUM > LOW), then by creation time.',
+    {
+      projectId: optionalUuidSchema.describe('Filter by project ID'),
+      priority: z.string().optional().describe('Filter by priority (HIGH, MEDIUM, LOW)')
+    },
+    async (params: any) => {
+      try {
+        const result = getNext({
+          entityType: DependencyEntityType.FEATURE,
+          projectId: params.projectId,
+          priority: params.priority
+        });
+
+        if (!result.success) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify(createErrorResponse(result.error, result.code), null, 2)
+            }]
+          };
+        }
+
+        if (result.data === null) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify(
+                createSuccessResponse('No available features found matching the criteria', null),
+                null,
+                2
+              )
+            }]
+          };
+        }
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify(
+              createSuccessResponse('Next feature retrieved successfully', result.data),
+              null,
+              2
+            )
+          }]
+        };
+      } catch (error: any) {
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify(
+              createErrorResponse('Failed to get next feature', error.message),
+              null,
+              2
+            )
+          }]
+        };
+      }
+    }
+  );
+}

package/src/tools/get-next-status.ts

@@ -2,53 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { createSuccessResponse, createErrorResponse } from './registry';
 import { ProjectStatus, FeatureStatus, TaskStatus } from '../domain/types';
-
-/**
- * Status transition maps for each container type
- *
- * Note: CANCELLED and DEFERRED are intentionally non-terminal statuses.
- * They allow transitions back to earlier workflow stages (BACKLOG/PENDING for tasks,
- * PLANNING for projects) to support reinstating cancelled or deferred work.
- */
-const PROJECT_TRANSITIONS: Record<ProjectStatus, ProjectStatus[]> = {
-  [ProjectStatus.PLANNING]: [ProjectStatus.IN_DEVELOPMENT, ProjectStatus.ON_HOLD, ProjectStatus.CANCELLED],
-  [ProjectStatus.IN_DEVELOPMENT]: [ProjectStatus.COMPLETED, ProjectStatus.ON_HOLD, ProjectStatus.CANCELLED],
-  [ProjectStatus.ON_HOLD]: [ProjectStatus.PLANNING, ProjectStatus.IN_DEVELOPMENT, ProjectStatus.CANCELLED],
-  [ProjectStatus.COMPLETED]: [ProjectStatus.ARCHIVED],
-  [ProjectStatus.CANCELLED]: [ProjectStatus.PLANNING], // Non-terminal: allows reinstating cancelled projects
-  [ProjectStatus.ARCHIVED]: []
-};
-
-const FEATURE_TRANSITIONS: Record<FeatureStatus, FeatureStatus[]> = {
-  [FeatureStatus.DRAFT]: [FeatureStatus.PLANNING],
-  [FeatureStatus.PLANNING]: [FeatureStatus.IN_DEVELOPMENT, FeatureStatus.ON_HOLD],
-  [FeatureStatus.IN_DEVELOPMENT]: [FeatureStatus.TESTING, FeatureStatus.BLOCKED, FeatureStatus.ON_HOLD],
-  [FeatureStatus.TESTING]: [FeatureStatus.VALIDATING, FeatureStatus.IN_DEVELOPMENT],
-  [FeatureStatus.VALIDATING]: [FeatureStatus.PENDING_REVIEW, FeatureStatus.IN_DEVELOPMENT],
-  [FeatureStatus.PENDING_REVIEW]: [FeatureStatus.DEPLOYED, FeatureStatus.IN_DEVELOPMENT],
-  [FeatureStatus.BLOCKED]: [FeatureStatus.IN_DEVELOPMENT, FeatureStatus.ON_HOLD],
-  [FeatureStatus.ON_HOLD]: [FeatureStatus.PLANNING, FeatureStatus.IN_DEVELOPMENT],
-  [FeatureStatus.DEPLOYED]: [FeatureStatus.COMPLETED],
-  [FeatureStatus.COMPLETED]: [FeatureStatus.ARCHIVED],
-  [FeatureStatus.ARCHIVED]: []
-};
-
-const TASK_TRANSITIONS: Record<TaskStatus, TaskStatus[]> = {
-  [TaskStatus.BACKLOG]: [TaskStatus.PENDING],
-  [TaskStatus.PENDING]: [TaskStatus.IN_PROGRESS, TaskStatus.BLOCKED, TaskStatus.ON_HOLD, TaskStatus.CANCELLED, TaskStatus.DEFERRED],
-  [TaskStatus.IN_PROGRESS]: [TaskStatus.IN_REVIEW, TaskStatus.TESTING, TaskStatus.BLOCKED, TaskStatus.ON_HOLD, TaskStatus.COMPLETED],
-  [TaskStatus.IN_REVIEW]: [TaskStatus.CHANGES_REQUESTED, TaskStatus.COMPLETED],
-  [TaskStatus.CHANGES_REQUESTED]: [TaskStatus.IN_PROGRESS],
-  [TaskStatus.TESTING]: [TaskStatus.READY_FOR_QA, TaskStatus.IN_PROGRESS],
-  [TaskStatus.READY_FOR_QA]: [TaskStatus.INVESTIGATING, TaskStatus.DEPLOYED, TaskStatus.COMPLETED],
-  [TaskStatus.INVESTIGATING]: [TaskStatus.IN_PROGRESS, TaskStatus.BLOCKED],
-  [TaskStatus.BLOCKED]: [TaskStatus.PENDING, TaskStatus.IN_PROGRESS],
-  [TaskStatus.ON_HOLD]: [TaskStatus.PENDING, TaskStatus.IN_PROGRESS],
-  [TaskStatus.DEPLOYED]: [TaskStatus.COMPLETED],
-  [TaskStatus.COMPLETED]: [], // Terminal: no transitions allowed
-  [TaskStatus.CANCELLED]: [TaskStatus.BACKLOG, TaskStatus.PENDING], // Non-terminal: allows reinstating cancelled tasks
-  [TaskStatus.DEFERRED]: [TaskStatus.BACKLOG, TaskStatus.PENDING] // Non-terminal: allows resuming deferred tasks
-};
+import { PROJECT_TRANSITIONS, FEATURE_TRANSITIONS, TASK_TRANSITIONS } from '../services/status-validator';
 
 /**
  * Register the get_next_status MCP tool.

package/src/tools/get-next-task.ts

@@ -1,7 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { createSuccessResponse, createErrorResponse, optionalUuidSchema } from './registry';
-import { getNextTask } from '../repos/dependencies';
+import { getNext } from '../repos/dependencies';
+import { DependencyEntityType } from '../domain/types';
 
 /**
  * Register the get_next_task MCP tool.
@@ -20,7 +21,8 @@ export function registerGetNextTaskTool(server: McpServer): void {
     },
     async (params: any) => {
       try {
-        const result = getNextTask({
+        const result = getNext({
+          entityType: DependencyEntityType.TASK,
           projectId: params.projectId,
           featureId: params.featureId,
           priority: params.priority

package/src/tools/index.ts

@@ -23,6 +23,8 @@ export { registerRenameTagTool } from './rename-tag';
 // Workflow tools
 export { registerGetNextTaskTool } from './get-next-task';
 export { registerGetBlockedTasksTool } from './get-blocked-tasks';
+export { registerGetNextFeatureTool } from './get-next-feature';
+export { registerGetBlockedFeaturesTool } from './get-blocked-features';
 export { registerGetNextStatusTool } from './get-next-status';
 export { registerQueryWorkflowStateTool } from './query-workflow-state';
 

package/src/tools/manage-dependency.ts

@@ -2,7 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { createSuccessResponse, createErrorResponse, uuidSchema, optionalUuidSchema } from './registry';
 import { createDependency, deleteDependency } from '../repos/dependencies';
-import { DependencyType } from '../domain/types';
+import { DependencyType, DependencyEntityType } from '../domain/types';
 
 /**
  * Register the manage_dependency MCP tool.
@@ -14,17 +14,21 @@ import { DependencyType } from '../domain/types';
 export function registerManageDependencyTool(server: McpServer): void {
   server.tool(
     'manage_dependency',
-    'Manage dependencies between tasks (create, delete)',
+    'Manage dependencies between entities of the same type (create, delete). Supports task-to-task and feature-to-feature dependencies.',
     {
       operation: z
         .enum(['create', 'delete'])
         .describe('Operation to perform: create or delete'),
       id: optionalUuidSchema
         .describe('Dependency ID (required for delete operation)'),
-      fromTaskId: optionalUuidSchema
-        .describe('Source task ID (required for create operation)'),
-      toTaskId: optionalUuidSchema
-        .describe('Target task ID (required for create operation)'),
+      fromId: optionalUuidSchema
+        .describe('Source entity ID (required for create operation)'),
+      toId: optionalUuidSchema
+        .describe('Target entity ID (required for create operation)'),
+      containerType: z
+        .enum(['task', 'feature'])
+        .optional()
+        .describe('Entity type for the dependency (required for create operation)'),
       type: z
         .enum(['BLOCKS', 'IS_BLOCKED_BY', 'RELATES_TO'])
         .optional()
@@ -36,16 +40,31 @@ export function registerManageDependencyTool(server: McpServer): void {
 
         // Handle create operation
         if (operation === 'create') {
-          const { fromTaskId, toTaskId, type } = params;
+          const { fromId, toId, type, containerType } = params;
 
           // Validate required parameters for create
-          if (!fromTaskId) {
+          if (!fromId) {
+            return {
+              content: [
+                {
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('fromId is required for create operation'),
+                    null,
+                    2
+                  ),
+                },
+              ],
+            };
+          }
+
+          if (!toId) {
             return {
               content: [
                 {
                   type: 'text' as const,
                   text: JSON.stringify(
-                    createErrorResponse('fromTaskId is required for create operation'),
+                    createErrorResponse('toId is required for create operation'),
                     null,
                     2
                   ),
@@ -54,13 +73,13 @@ export function registerManageDependencyTool(server: McpServer): void {
             };
           }
 
-          if (!toTaskId) {
+          if (!containerType) {
             return {
               content: [
                 {
                   type: 'text' as const,
                   text: JSON.stringify(
-                    createErrorResponse('toTaskId is required for create operation'),
+                    createErrorResponse('containerType is required for create operation'),
                     null,
                     2
                   ),
@@ -85,9 +104,10 @@ export function registerManageDependencyTool(server: McpServer): void {
           }
 
           const result = createDependency({
-            fromTaskId,
-            toTaskId,
+            fromEntityId: fromId,
+            toEntityId: toId,
             type: type as DependencyType,
+            entityType: containerType as DependencyEntityType,
           });
 
           if (result.success === false) {

package/src/tools/query-dependencies.ts

@@ -2,6 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { createSuccessResponse, createErrorResponse, uuidSchema } from './registry';
 import { getDependencies } from '../repos/dependencies';
+import { DependencyEntityType } from '../domain/types';
 
 /**
  * Register the query_dependencies MCP tool.
@@ -13,9 +14,12 @@ import { getDependencies } from '../repos/dependencies';
 export function registerQueryDependenciesTool(server: McpServer): void {
   server.tool(
     'query_dependencies',
-    'Query dependencies for a task',
+    'Query dependencies for an entity (task or feature)',
     {
-      taskId: uuidSchema.describe('Task ID'),
+      id: uuidSchema.describe('Entity ID (task or feature)'),
+      containerType: z
+        .enum(['task', 'feature'])
+        .describe('Entity type to query dependencies for'),
       direction: z
         .enum(['dependencies', 'dependents', 'both'])
         .optional()
@@ -24,7 +28,7 @@ export function registerQueryDependenciesTool(server: McpServer): void {
     },
     async (params) => {
       try {
-        const result = getDependencies(params.taskId, params.direction);
+        const result = getDependencies(params.id, params.direction, params.containerType as DependencyEntityType);
 
         if (result.success === false) {
           return {