diff --git a/Backend/internal/bootstrap/service.go b/Backend/internal/bootstrap/service.go
index fca6a4c..1cbad9b 100644
--- a/Backend/internal/bootstrap/service.go
+++ b/Backend/internal/bootstrap/service.go
@@ -50,7 +50,9 @@ var (
 	ErrBootstrapStructureMissing = errors.New("bootstrap structure is incomplete")
 	ErrProjectNotFound           = errors.New("project not found")
 	ErrProjectFolderNotFound     = errors.New("project folder not found")
+	ErrProjectItemNotFound       = errors.New("project item not found")
 	ErrInvalidProjectFolderMove  = errors.New("invalid project folder move")
+	ErrInvalidProjectItemMove    = errors.New("invalid project item move")
 )
 
 type Service struct {
@@ -195,6 +197,15 @@ type ProjectHierarchyFolderRecord struct {
 	Children []ProjectHierarchyFolderRecord `json:"children"`
 }
 
+type ProjectTreeNodeRecord struct {
+	ID       string                  `json:"id"`
+	Path     string                  `json:"path"`
+	Label    string                  `json:"label"`
+	Kind     string                  `json:"kind"`
+	ItemType string                  `json:"itemType,omitempty"`
+	Children []ProjectTreeNodeRecord `json:"children,omitempty"`
+}
+
 type CreateProjectFolderInput struct {
 	ProjectID        string
 	ParentFolderPath string
@@ -221,6 +232,27 @@ type MoveProjectFolderInput struct {
 	TargetIndex      int
 }
 
+type CreateProjectItemInput struct {
+	ProjectID        string
+	ParentFolderPath string
+	Name             string
+	ItemType         string
+}
+
+type DeleteProjectItemInput struct {
+	ProjectID string
+	ItemPath  string
+}
+
+type MoveProjectItemInput struct {
+	ProjectID        string
+	ItemPath         string
+	ItemStableID     string
+	ParentFolderPath string
+	ParentStableID   string
+	TargetIndex      int
+}
+
 type CreateProjectFolderResult struct {
 	ProjectID     string                         `json:"projectId"`
 	CreatedFolder ProjectHierarchyFolderRecord   `json:"createdFolder"`
@@ -250,6 +282,27 @@ type MoveProjectFolderResult struct {
 	Folders                []ProjectHierarchyFolderRecord `json:"folders"`
 }
 
+type CreateProjectItemResult struct {
+	ProjectID   string                `json:"projectId"`
+	CreatedItem ProjectTreeNodeRecord `json:"createdItem"`
+	Nodes       []ProjectTreeNodeRecord `json:"nodes"`
+}
+
+type DeleteProjectItemResult struct {
+	ProjectID           string                  `json:"projectId"`
+	DeletedItemStableID string                  `json:"deletedItemId"`
+	DeletedItemPath     string                  `json:"deletedItemPath"`
+	Nodes               []ProjectTreeNodeRecord `json:"nodes"`
+}
+
+type MoveProjectItemResult struct {
+	ProjectID            string                `json:"projectId"`
+	PreviousItemStableID string                `json:"previousItemId"`
+	PreviousItemPath     string                `json:"previousItemPath"`
+	MovedItem            ProjectTreeNodeRecord `json:"movedItem"`
+	Nodes                []ProjectTreeNodeRecord `json:"nodes"`
+}
+
 type projectHierarchyFolderRow struct {
 	ID         string
 	Path       string
@@ -257,6 +310,15 @@ type projectHierarchyFolderRow struct {
 	Label      string
 }
 
+type projectTreeNodeRow struct {
+	ID         string
+	Path       string
+	ParentPath string
+	Label      string
+	Kind       string
+	ItemType   string
+}
+
 func NewService(db *database.DB, posixRoot string) *Service {
 	return &Service{db: db, posixRoot: strings.TrimSpace(posixRoot)}
 }
@@ -815,6 +877,10 @@ func (service *Service) GetProjectTreeFolders(ctx context.Context, projectID str
 	return service.getProjectHierarchyFoldersByRootPath(ctx, projectID, projectTreeRootPath)
 }
 
+func (service *Service) GetProjectTreeNodes(ctx context.Context, projectID string) ([]ProjectTreeNodeRecord, error) {
+	return service.getProjectTreeNodesByRootPath(ctx, projectID, projectTreeRootPath)
+}
+
 func (service *Service) getProjectHierarchyFoldersByRootPath(
 	ctx context.Context,
 	projectID string,
@@ -870,6 +936,64 @@ func (service *Service) getProjectHierarchyFoldersByRootPath(
 	return applyProjectHierarchyFolderOrdering(folders, folderOrder), nil
 }
 
+func (service *Service) getProjectTreeNodesByRootPath(
+	ctx context.Context,
+	projectID string,
+	rootPath func(projectSlug string) string,
+) ([]ProjectTreeNodeRecord, error) {
+	project, err := service.loadProjectByID(ctx, projectID)
+	if err != nil {
+		return nil, err
+	}
+
+	rootParentPath := rootPath(project.Slug)
+
+	rows, err := service.db.Pool.Query(ctx, `
+		SELECT
+			COALESCE(node_meta.resource_id, ''),
+			directories.path,
+			COALESCE(directories.parent_path, ''),
+			COALESCE(node_meta.resource_name, directories.resource_name, ''),
+			directories.logical_type,
+			COALESCE(node_meta.content_json->>'type', directories.content_json->>'type', '')
+		FROM posix_nodes AS directories
+		LEFT JOIN posix_nodes AS node_meta
+		  ON node_meta.path = directories.path || CASE
+				WHEN directories.logical_type = 'hierarchy_folder' THEN '/folder.json'
+				WHEN directories.logical_type = 'item' THEN '/item.json'
+				ELSE ''
+			END
+		 AND node_meta.node_kind = 'file'::posix_node_kind
+		WHERE directories.node_kind = 'directory'::posix_node_kind
+		  AND directories.logical_type IN ('hierarchy_folder', 'item')
+		  AND directories.project_slug = $1
+		  AND directories.path LIKE $2
+		ORDER BY directories.depth ASC, directories.path ASC;
+	`, project.Slug, rootParentPath+"/%")
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var nodeRows []projectTreeNodeRow
+	for rows.Next() {
+		var row projectTreeNodeRow
+		if err := rows.Scan(&row.ID, &row.Path, &row.ParentPath, &row.Label, &row.Kind, &row.ItemType); err != nil {
+			return nil, err
+		}
+		nodeRows = append(nodeRows, row)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	nodes := buildProjectTreeNodeTree(nodeRows, rootParentPath)
+	folderOrder := service.readProjectFolderOrder(project.Slug, rootParentPath)
+
+	return applyProjectTreeNodeOrdering(nodes, folderOrder), nil
+}
+
 func (service *Service) CreateProjectFolder(ctx context.Context, input CreateProjectFolderInput) (CreateProjectFolderResult, error) {
 	return service.createProjectHierarchyFolder(ctx, input, projectHierarchyRootPath, service.createProjectHierarchyFolderOnDisk)
 }
@@ -902,6 +1026,18 @@ func (service *Service) MoveProjectTreeFolder(ctx context.Context, input MovePro
 	return service.moveProjectHierarchyFolder(ctx, input, projectTreeRootPath, service.moveProjectTreeFolderOnDisk)
 }
 
+func (service *Service) CreateProjectTreeItem(ctx context.Context, input CreateProjectItemInput) (CreateProjectItemResult, error) {
+	return service.createProjectTreeItem(ctx, input, projectTreeRootPath)
+}
+
+func (service *Service) DeleteProjectTreeItem(ctx context.Context, input DeleteProjectItemInput) (DeleteProjectItemResult, error) {
+	return service.deleteProjectTreeItem(ctx, input, projectTreeRootPath)
+}
+
+func (service *Service) MoveProjectTreeItem(ctx context.Context, input MoveProjectItemInput) (MoveProjectItemResult, error) {
+	return service.moveProjectTreeItem(ctx, input, projectTreeRootPath)
+}
+
 func (service *Service) createProjectHierarchyFolder(
 	ctx context.Context,
 	input CreateProjectFolderInput,
@@ -1174,6 +1310,226 @@ func (service *Service) moveProjectHierarchyFolder(
 	}, nil
 }
 
+func (service *Service) createProjectTreeItem(
+	ctx context.Context,
+	input CreateProjectItemInput,
+	rootPath func(projectSlug string) string,
+) (CreateProjectItemResult, error) {
+	project, err := service.loadProjectByID(ctx, strings.TrimSpace(input.ProjectID))
+	if err != nil {
+		return CreateProjectItemResult{}, err
+	}
+
+	currentNodes, err := service.getProjectTreeNodesByRootPath(ctx, project.ID, rootPath)
+	if err != nil {
+		return CreateProjectItemResult{}, err
+	}
+
+	parentOrderID := ""
+	trimmedParentFolderPath := strings.TrimSpace(input.ParentFolderPath)
+	if trimmedParentFolderPath != "" {
+		parentFolder, found := findProjectTreeFolderByPath(currentNodes, trimmedParentFolderPath)
+		if !found {
+			return CreateProjectItemResult{}, ErrProjectFolderNotFound
+		}
+		parentOrderID = parentFolder.ID
+	}
+
+	createdPath, err := service.createProjectTreeItemOnDisk(project.Slug, trimmedParentFolderPath, input.Name, input.ItemType)
+	if err != nil {
+		return CreateProjectItemResult{}, err
+	}
+
+	if err := service.rebuildProjection(ctx); err != nil {
+		return CreateProjectItemResult{}, err
+	}
+
+	nodes, err := service.getProjectTreeNodesByRootPath(ctx, project.ID, rootPath)
+	if err != nil {
+		return CreateProjectItemResult{}, err
+	}
+
+	createdItem, ok := findProjectTreeNodeByPath(nodes, createdPath)
+	if !ok || createdItem.Kind != "item" {
+		return CreateProjectItemResult{}, fmt.Errorf("created project item missing from projection")
+	}
+
+	folderOrder := service.readProjectFolderOrder(project.Slug, rootPath(project.Slug))
+	seedProjectTreeOrderParent(folderOrder, currentNodes, parentOrderID)
+	insertFolderOrder(folderOrder, parentOrderID, createdItem.ID, len(folderOrderChildren(folderOrder, parentOrderID)))
+	if err := service.writeProjectFolderOrder(project.Slug, rootPath(project.Slug), folderOrder); err != nil {
+		return CreateProjectItemResult{}, err
+	}
+
+	nodes, err = service.getProjectTreeNodesByRootPath(ctx, project.ID, rootPath)
+	if err != nil {
+		return CreateProjectItemResult{}, err
+	}
+
+	createdItem, ok = findProjectTreeNodeByPath(nodes, createdPath)
+	if !ok || createdItem.Kind != "item" {
+		return CreateProjectItemResult{}, fmt.Errorf("created project item missing from ordered projection")
+	}
+
+	return CreateProjectItemResult{
+		ProjectID:   project.ID,
+		CreatedItem: createdItem,
+		Nodes:       nodes,
+	}, nil
+}
+
+func (service *Service) deleteProjectTreeItem(
+	ctx context.Context,
+	input DeleteProjectItemInput,
+	rootPath func(projectSlug string) string,
+) (DeleteProjectItemResult, error) {
+	project, err := service.loadProjectByID(ctx, strings.TrimSpace(input.ProjectID))
+	if err != nil {
+		return DeleteProjectItemResult{}, err
+	}
+
+	currentNodes, err := service.getProjectTreeNodesByRootPath(ctx, project.ID, rootPath)
+	if err != nil {
+		return DeleteProjectItemResult{}, err
+	}
+
+	deletedItem, found := findProjectTreeNodeByPath(currentNodes, strings.TrimSpace(input.ItemPath))
+	if !found || deletedItem.Kind != "item" {
+		return DeleteProjectItemResult{}, ErrProjectItemNotFound
+	}
+
+	deletedItemPath, err := service.deleteProjectTreeItemOnDisk(project.Slug, input.ItemPath)
+	if err != nil {
+		return DeleteProjectItemResult{}, err
+	}
+
+	if err := service.rebuildProjection(ctx); err != nil {
+		return DeleteProjectItemResult{}, err
+	}
+
+	nodes, err := service.getProjectTreeNodesByRootPath(ctx, project.ID, rootPath)
+	if err != nil {
+		return DeleteProjectItemResult{}, err
+	}
+
+	if _, found := findProjectTreeNodeByPath(nodes, deletedItemPath); found {
+		return DeleteProjectItemResult{}, fmt.Errorf("deleted project item still present in projection")
+	}
+
+	folderOrder := service.readProjectFolderOrder(project.Slug, rootPath(project.Slug))
+	removeFolderOrderReference(folderOrder, deletedItem.ID)
+	if err := service.writeProjectFolderOrder(project.Slug, rootPath(project.Slug), folderOrder); err != nil {
+		return DeleteProjectItemResult{}, err
+	}
+
+	nodes, err = service.getProjectTreeNodesByRootPath(ctx, project.ID, rootPath)
+	if err != nil {
+		return DeleteProjectItemResult{}, err
+	}
+
+	return DeleteProjectItemResult{
+		ProjectID:           project.ID,
+		DeletedItemStableID: deletedItem.ID,
+		DeletedItemPath:     deletedItemPath,
+		Nodes:               nodes,
+	}, nil
+}
+
+func (service *Service) moveProjectTreeItem(
+	ctx context.Context,
+	input MoveProjectItemInput,
+	rootPath func(projectSlug string) string,
+) (MoveProjectItemResult, error) {
+	project, err := service.loadProjectByID(ctx, strings.TrimSpace(input.ProjectID))
+	if err != nil {
+		return MoveProjectItemResult{}, err
+	}
+
+	currentNodes, err := service.getProjectTreeNodesByRootPath(ctx, project.ID, rootPath)
+	if err != nil {
+		return MoveProjectItemResult{}, err
+	}
+
+	currentItem, found := findProjectTreeNodeByPath(currentNodes, strings.TrimSpace(input.ItemPath))
+	if !found || currentItem.Kind != "item" {
+		return MoveProjectItemResult{}, ErrProjectItemNotFound
+	}
+
+	movedItemStableID := currentItem.ID
+	providedItemStableID := strings.TrimSpace(input.ItemStableID)
+	if providedItemStableID != "" && providedItemStableID != movedItemStableID {
+		return MoveProjectItemResult{}, ErrInvalidProjectItemMove
+	}
+
+	parentOrderID := ""
+	trimmedParentFolderPath := strings.TrimSpace(input.ParentFolderPath)
+	providedParentStableID := strings.TrimSpace(input.ParentStableID)
+	if trimmedParentFolderPath != "" {
+		parentFolder, found := findProjectTreeFolderByPath(currentNodes, trimmedParentFolderPath)
+		if !found {
+			return MoveProjectItemResult{}, ErrProjectFolderNotFound
+		}
+		parentOrderID = parentFolder.ID
+		if providedParentStableID != "" && providedParentStableID != parentOrderID {
+			return MoveProjectItemResult{}, ErrInvalidProjectItemMove
+		}
+	} else if providedParentStableID != "" {
+		return MoveProjectItemResult{}, ErrInvalidProjectItemMove
+	}
+
+	previousItemPath, movedItemPath, err := service.moveProjectTreeItemOnDisk(project.Slug, input.ItemPath, input.ParentFolderPath)
+	if err != nil {
+		return MoveProjectItemResult{}, err
+	}
+
+	if err := service.rebuildProjection(ctx); err != nil {
+		return MoveProjectItemResult{}, err
+	}
+
+	nodes, err := service.getProjectTreeNodesByRootPath(ctx, project.ID, rootPath)
+	if err != nil {
+		return MoveProjectItemResult{}, err
+	}
+
+	movedItem, found := findProjectTreeNodeByPath(nodes, movedItemPath)
+	if !found || movedItem.Kind != "item" {
+		return MoveProjectItemResult{}, fmt.Errorf("moved project item missing from projection")
+	}
+
+	if previousItemPath != movedItemPath {
+		if _, found := findProjectTreeNodeByPath(nodes, previousItemPath); found {
+			return MoveProjectItemResult{}, fmt.Errorf("previous project item path still present in projection")
+		}
+	}
+
+	folderOrder := service.readProjectFolderOrder(project.Slug, rootPath(project.Slug))
+	seedProjectTreeOrderParent(folderOrder, currentNodes, parentOrderID)
+	removeFolderOrderReference(folderOrder, movedItemStableID)
+	removeFolderOrderReference(folderOrder, movedItem.ID)
+	insertFolderOrder(folderOrder, parentOrderID, movedItem.ID, input.TargetIndex)
+	if err := service.writeProjectFolderOrder(project.Slug, rootPath(project.Slug), folderOrder); err != nil {
+		return MoveProjectItemResult{}, err
+	}
+
+	nodes, err = service.getProjectTreeNodesByRootPath(ctx, project.ID, rootPath)
+	if err != nil {
+		return MoveProjectItemResult{}, err
+	}
+
+	movedItem, found = findProjectTreeNodeByPath(nodes, movedItemPath)
+	if !found || movedItem.Kind != "item" {
+		return MoveProjectItemResult{}, fmt.Errorf("moved project item missing from ordered projection")
+	}
+
+	return MoveProjectItemResult{
+		ProjectID:            project.ID,
+		PreviousItemStableID: movedItem.ID,
+		PreviousItemPath:     previousItemPath,
+		MovedItem:            movedItem,
+		Nodes:                nodes,
+	}, nil
+}
+
 func (service *Service) listWorkspaces(ctx context.Context) ([]WorkspaceRecord, error) {
 	rows, err := service.db.Pool.Query(ctx, `
 		SELECT id::text, organization_id::text, name, slug, kind::text, department_id::text, team_id::text, project_id::text
@@ -1796,6 +2152,218 @@ func (service *Service) moveProjectFolderOnDisk(
 	return folderProjectionPath, movedProjectionPath, nil
 }
 
+func (service *Service) createProjectTreeItemOnDisk(
+	projectSlug, parentFolderPath, name, itemType string,
+) (string, error) {
+	posixRoot := strings.TrimSpace(service.posixRoot)
+	if posixRoot == "" {
+		return "", fmt.Errorf("POSIX root is not configured")
+	}
+
+	trimmedName := strings.TrimSpace(name)
+	if trimmedName == "" {
+		return "", fmt.Errorf("item name is required")
+	}
+
+	canonicalItemType := normalizeProjectTreeItemType(itemType)
+	containerProjectionPath := projectTreeRootPath(projectSlug)
+	parentDir := filepath.Join(posixRoot, filepath.FromSlash(containerProjectionPath))
+
+	if trimmedParentFolderPath := strings.TrimSpace(parentFolderPath); trimmedParentFolderPath != "" {
+		containerProjectionPath = trimmedParentFolderPath
+		parentDir = filepath.Join(posixRoot, filepath.FromSlash(containerProjectionPath))
+		info, err := os.Stat(parentDir)
+		if err != nil {
+			if os.IsNotExist(err) {
+				return "", ErrProjectFolderNotFound
+			}
+			return "", fmt.Errorf("stat parent project folder: %w", err)
+		}
+		if !info.IsDir() {
+			return "", ErrProjectFolderNotFound
+		}
+	}
+
+	if err := os.MkdirAll(parentDir, 0o755); err != nil {
+		return "", fmt.Errorf("create parent project item path: %w", err)
+	}
+
+	baseSlug := normalizePOSIXSlug(trimmedName)
+	itemDirName := slugDir("item", baseSlug)
+	itemDir := filepath.Join(parentDir, itemDirName)
+	itemSlug := baseSlug
+
+	for attempt := 2; ; attempt += 1 {
+		if _, err := os.Stat(itemDir); os.IsNotExist(err) {
+			break
+		} else if err != nil {
+			return "", fmt.Errorf("stat candidate project item: %w", err)
+		}
+
+		itemSlug = fmt.Sprintf("%s-%d", baseSlug, attempt)
+		itemDirName = slugDir("item", itemSlug)
+		itemDir = filepath.Join(parentDir, itemDirName)
+	}
+
+	if err := os.MkdirAll(itemDir, 0o755); err != nil {
+		return "", fmt.Errorf("create project item: %w", err)
+	}
+
+	itemID := uuid.NewString()
+	if err := writeJSONFile(filepath.Join(itemDir, "item.json"), map[string]any{
+		"id":   itemID,
+		"name": trimmedName,
+		"slug": itemSlug,
+		"type": canonicalItemType,
+	}); err != nil {
+		return "", fmt.Errorf("write project item.json: %w", err)
+	}
+
+	if err := writeJSONFile(filepath.Join(itemDir, "schema.json"), defaultProjectTreeItemSchema(canonicalItemType)); err != nil {
+		return "", fmt.Errorf("write project schema.json: %w", err)
+	}
+
+	if err := writeJSONFile(filepath.Join(itemDir, "data.json"), defaultProjectTreeItemData(canonicalItemType, trimmedName)); err != nil {
+		return "", fmt.Errorf("write project data.json: %w", err)
+	}
+
+	return filepath.ToSlash(filepath.Join(containerProjectionPath, itemDirName)), nil
+}
+
+func (service *Service) deleteProjectTreeItemOnDisk(projectSlug, itemPath string) (string, error) {
+	posixRoot := strings.TrimSpace(service.posixRoot)
+	if posixRoot == "" {
+		return "", fmt.Errorf("POSIX root is not configured")
+	}
+
+	rootProjectionPath := projectTreeRootPath(projectSlug)
+	itemProjectionPath := strings.TrimPrefix(filepath.ToSlash(filepath.Clean("/"+strings.TrimSpace(itemPath))), "/")
+	if itemProjectionPath == "." || itemProjectionPath == rootProjectionPath || !strings.HasPrefix(itemProjectionPath, rootProjectionPath+"/") {
+		return "", ErrProjectItemNotFound
+	}
+
+	itemDir := filepath.Join(posixRoot, filepath.FromSlash(itemProjectionPath))
+	info, err := os.Stat(itemDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return "", ErrProjectItemNotFound
+		}
+		return "", fmt.Errorf("stat project item: %w", err)
+	}
+	if !info.IsDir() {
+		return "", ErrProjectItemNotFound
+	}
+
+	if err := os.RemoveAll(itemDir); err != nil {
+		return "", fmt.Errorf("delete project item: %w", err)
+	}
+
+	return itemProjectionPath, nil
+}
+
+func (service *Service) moveProjectTreeItemOnDisk(projectSlug, itemPath, parentFolderPath string) (string, string, error) {
+	posixRoot := strings.TrimSpace(service.posixRoot)
+	if posixRoot == "" {
+		return "", "", fmt.Errorf("POSIX root is not configured")
+	}
+
+	rootProjectionPath := projectTreeRootPath(projectSlug)
+	itemProjectionPath := strings.TrimPrefix(filepath.ToSlash(filepath.Clean("/"+strings.TrimSpace(itemPath))), "/")
+	if itemProjectionPath == "." || itemProjectionPath == rootProjectionPath || !strings.HasPrefix(itemProjectionPath, rootProjectionPath+"/") {
+		return "", "", ErrProjectItemNotFound
+	}
+
+	itemDir := filepath.Join(posixRoot, filepath.FromSlash(itemProjectionPath))
+	info, err := os.Stat(itemDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return "", "", ErrProjectItemNotFound
+		}
+		return "", "", fmt.Errorf("stat project item: %w", err)
+	}
+	if !info.IsDir() {
+		return "", "", ErrProjectItemNotFound
+	}
+
+	trimmedParentFolderPath := strings.TrimSpace(parentFolderPath)
+	parentProjectionPath := rootProjectionPath
+	parentDir := filepath.Join(posixRoot, filepath.FromSlash(parentProjectionPath))
+	if trimmedParentFolderPath != "" {
+		parentProjectionPath = strings.TrimPrefix(filepath.ToSlash(filepath.Clean("/"+trimmedParentFolderPath)), "/")
+		if parentProjectionPath == "." || parentProjectionPath == rootProjectionPath || !strings.HasPrefix(parentProjectionPath, rootProjectionPath+"/") {
+			return "", "", ErrProjectFolderNotFound
+		}
+		parentDir = filepath.Join(posixRoot, filepath.FromSlash(parentProjectionPath))
+	}
+
+	parentInfo, err := os.Stat(parentDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return "", "", ErrProjectFolderNotFound
+		}
+		return "", "", fmt.Errorf("stat project item parent: %w", err)
+	}
+	if !parentInfo.IsDir() {
+		return "", "", ErrProjectFolderNotFound
+	}
+
+	currentParentDir := filepath.Dir(itemDir)
+	currentBase := filepath.Base(itemDir)
+	itemPayload := readJSONFileMap(filepath.Join(itemDir, "item.json"))
+	itemID, _ := itemPayload["id"].(string)
+	if strings.TrimSpace(itemID) == "" {
+		itemID = uuid.NewString()
+	}
+	itemName, _ := itemPayload["name"].(string)
+	if strings.TrimSpace(itemName) == "" {
+		itemName = fallbackItemLabel(itemProjectionPath)
+	}
+	itemType, _ := itemPayload["type"].(string)
+	canonicalItemType := normalizeProjectTreeItemType(itemType)
+
+	baseSlug := strings.TrimPrefix(currentBase, "item-")
+	if strings.TrimSpace(baseSlug) == "" {
+		baseSlug = normalizePOSIXSlug(itemName)
+	}
+
+	itemSlug := baseSlug
+	itemDirName := slugDir("item", itemSlug)
+	destinationDir := filepath.Join(parentDir, itemDirName)
+	for attempt := 2; ; attempt += 1 {
+		if samePath(destinationDir, itemDir) {
+			break
+		}
+		if _, err := os.Stat(destinationDir); os.IsNotExist(err) {
+			break
+		} else if err != nil {
+			return "", "", fmt.Errorf("stat candidate moved project item: %w", err)
+		}
+
+		itemSlug = fmt.Sprintf("%s-%d", baseSlug, attempt)
+		itemDirName = slugDir("item", itemSlug)
+		destinationDir = filepath.Join(parentDir, itemDirName)
+	}
+
+	movedProjectionPath := filepath.ToSlash(filepath.Join(parentProjectionPath, itemDirName))
+	if samePath(currentParentDir, parentDir) && currentBase == itemDirName {
+		return itemProjectionPath, itemProjectionPath, nil
+	}
+
+	if err := os.Rename(itemDir, destinationDir); err != nil {
+		return "", "", fmt.Errorf("move project item: %w", err)
+	}
+
+	itemPayload["id"] = itemID
+	itemPayload["name"] = itemName
+	itemPayload["slug"] = itemSlug
+	itemPayload["type"] = canonicalItemType
+	if err := writeJSONFile(filepath.Join(destinationDir, "item.json"), itemPayload); err != nil {
+		return "", "", fmt.Errorf("write moved project item.json: %w", err)
+	}
+
+	return itemProjectionPath, movedProjectionPath, nil
+}
+
 func samePath(left, right string) bool {
 	cleanLeft := filepath.Clean(left)
 	cleanRight := filepath.Clean(right)
@@ -2144,6 +2712,136 @@ func buildProjectHierarchyFolderTree(rows []projectHierarchyFolderRow, rootParen
 	return build(rootParentPath)
 }
 
+func buildProjectTreeNodeTree(rows []projectTreeNodeRow, rootParentPath string) []ProjectTreeNodeRecord {
+	if len(rows) == 0 {
+		return nil
+	}
+
+	nodesByPath := make(map[string]*ProjectTreeNodeRecord, len(rows))
+	childrenByParent := make(map[string][]string)
+
+	for _, row := range rows {
+		nodeKind := normalizeProjectTreeNodeKind(row.Kind)
+		nodeID := strings.TrimSpace(row.ID)
+		if nodeID == "" {
+			nodeID = row.Path
+		}
+		label := strings.TrimSpace(row.Label)
+		if label == "" {
+			if nodeKind == "item" {
+				label = fallbackItemLabel(row.Path)
+			} else {
+				label = fallbackFolderLabel(row.Path)
+			}
+		}
+
+		nodesByPath[row.Path] = &ProjectTreeNodeRecord{
+			ID:       nodeID,
+			Path:     row.Path,
+			Label:    label,
+			Kind:     nodeKind,
+			ItemType: normalizeProjectTreeItemType(row.ItemType),
+			Children: []ProjectTreeNodeRecord{},
+		}
+		childrenByParent[normalizeProjectTreeParentPath(nodeKind, row.ParentPath)] = append(childrenByParent[normalizeProjectTreeParentPath(nodeKind, row.ParentPath)], row.Path)
+	}
+
+	var build func(parentPath string) []ProjectTreeNodeRecord
+	build = func(parentPath string) []ProjectTreeNodeRecord {
+		childPaths := childrenByParent[parentPath]
+		if len(childPaths) == 0 {
+			return nil
+		}
+
+		nodes := make([]ProjectTreeNodeRecord, 0, len(childPaths))
+		for _, childPath := range childPaths {
+			node := nodesByPath[childPath]
+			if node == nil {
+				continue
+			}
+
+			nextNode := ProjectTreeNodeRecord{
+				ID:       node.ID,
+				Path:     node.Path,
+				Label:    node.Label,
+				Kind:     node.Kind,
+				ItemType: node.ItemType,
+			}
+			if node.Kind == "folder" {
+				nextNode.Children = build(node.Path)
+			}
+			nodes = append(nodes, nextNode)
+		}
+
+		return nodes
+	}
+
+	return build(rootParentPath)
+}
+
+func normalizeProjectTreeParentPath(kind, parentPath string) string {
+	if kind == "folder" && strings.HasSuffix(parentPath, "/children") {
+		return filepath.ToSlash(filepath.Dir(parentPath))
+	}
+
+	return parentPath
+}
+
+func normalizeProjectTreeNodeKind(kind string) string {
+	switch strings.TrimSpace(kind) {
+	case "item":
+		return "item"
+	case "folder", "hierarchy_folder":
+		return "folder"
+	default:
+		return "folder"
+	}
+}
+
+func applyProjectTreeNodeOrdering(nodes []ProjectTreeNodeRecord, folderOrder map[string][]string) []ProjectTreeNodeRecord {
+	return applyProjectTreeNodeOrderingForParent(nodes, "", folderOrder)
+}
+
+func applyProjectTreeNodeOrderingForParent(nodes []ProjectTreeNodeRecord, parentID string, folderOrder map[string][]string) []ProjectTreeNodeRecord {
+	if len(nodes) == 0 {
+		return nodes
+	}
+
+	nextNodes := make([]ProjectTreeNodeRecord, len(nodes))
+	copy(nextNodes, nodes)
+	for index := range nextNodes {
+		if nextNodes[index].Kind == "folder" {
+			nextNodes[index].Children = applyProjectTreeNodeOrderingForParent(nextNodes[index].Children, nextNodes[index].ID, folderOrder)
+		}
+	}
+
+	orderIDs := folderOrder[projectFolderOrderParentKey(parentID)]
+	if len(orderIDs) == 0 {
+		return nextNodes
+	}
+
+	rankByID := make(map[string]int, len(orderIDs))
+	for index, id := range orderIDs {
+		if _, exists := rankByID[id]; !exists {
+			rankByID[id] = index
+		}
+	}
+
+	sort.SliceStable(nextNodes, func(left, right int) bool {
+		leftRank, leftOrdered := rankByID[nextNodes[left].ID]
+		rightRank, rightOrdered := rankByID[nextNodes[right].ID]
+		if leftOrdered && rightOrdered {
+			return leftRank < rightRank
+		}
+		if leftOrdered != rightOrdered {
+			return leftOrdered
+		}
+		return false
+	})
+
+	return nextNodes
+}
+
 func findProjectHierarchyFolder(folders []ProjectHierarchyFolderRecord, folderID string) (ProjectHierarchyFolderRecord, bool) {
 	for _, folder := range folders {
 		if folder.ID == folderID {
@@ -2172,6 +2870,41 @@ func findProjectHierarchyFolderByPath(folders []ProjectHierarchyFolderRecord, fo
 	return ProjectHierarchyFolderRecord{}, false
 }
 
+func findProjectTreeNode(nodes []ProjectTreeNodeRecord, nodeID string) (ProjectTreeNodeRecord, bool) {
+	for _, node := range nodes {
+		if node.ID == nodeID {
+			return node, true
+		}
+		if child, ok := findProjectTreeNode(node.Children, nodeID); ok {
+			return child, true
+		}
+	}
+
+	return ProjectTreeNodeRecord{}, false
+}
+
+func findProjectTreeNodeByPath(nodes []ProjectTreeNodeRecord, nodePath string) (ProjectTreeNodeRecord, bool) {
+	for _, node := range nodes {
+		if node.Path == nodePath {
+			return node, true
+		}
+		if child, ok := findProjectTreeNodeByPath(node.Children, nodePath); ok {
+			return child, true
+		}
+	}
+
+	return ProjectTreeNodeRecord{}, false
+}
+
+func findProjectTreeFolderByPath(nodes []ProjectTreeNodeRecord, folderPath string) (ProjectTreeNodeRecord, bool) {
+	node, ok := findProjectTreeNodeByPath(nodes, folderPath)
+	if !ok || node.Kind != "folder" {
+		return ProjectTreeNodeRecord{}, false
+	}
+
+	return node, true
+}
+
 func projectHierarchyRootPath(projectSlug string) string {
 	return filepath.ToSlash(filepath.Join("projects", slugDir("project", projectSlug), "children"))
 }
@@ -2226,6 +2959,80 @@ func fallbackFolderLabel(path string) string {
 	return label
 }
 
+func fallbackItemLabel(path string) string {
+	base := filepath.Base(filepath.FromSlash(path))
+	trimmed := strings.TrimPrefix(base, "item-")
+	parts := strings.FieldsFunc(trimmed, func(r rune) bool { return r == '-' || r == '_' })
+	for index, part := range parts {
+		if part == "" {
+			continue
+		}
+		parts[index] = strings.ToUpper(part[:1]) + part[1:]
+	}
+	label := strings.Join(parts, " ")
+	if label == "" {
+		return base
+	}
+	return label
+}
+
+func normalizeProjectTreeItemType(itemType string) string {
+	switch strings.TrimSpace(strings.ToLower(itemType)) {
+	case "", "board", "core.board", "core.board.kanban", "kanban":
+		return "core.board.kanban"
+	case "core.doc", "doc", "document":
+		return "core.doc"
+	case "core.board.list", "list", "list-board":
+		return "core.board.list"
+	default:
+		return strings.TrimSpace(itemType)
+	}
+}
+
+func seedProjectTreeOrderParent(folderOrder map[string][]string, nodes []ProjectTreeNodeRecord, parentID string) {
+	children := nodes
+	trimmedParentID := strings.TrimSpace(parentID)
+	if trimmedParentID != "" {
+		parent, found := findProjectTreeNode(nodes, trimmedParentID)
+		if !found || parent.Kind != "folder" {
+			return
+		}
+		children = parent.Children
+	}
+
+	parentKey := projectFolderOrderParentKey(parentID)
+	if len(folderOrder[parentKey]) > 0 {
+		return
+	}
+
+	orderedIDs := make([]string, 0, len(children))
+	for _, child := range children {
+		trimmedChildID := strings.TrimSpace(child.ID)
+		if trimmedChildID == "" || slicesContains(orderedIDs, trimmedChildID) {
+			continue
+		}
+		orderedIDs = append(orderedIDs, trimmedChildID)
+	}
+
+	if len(orderedIDs) > 0 {
+		folderOrder[parentKey] = orderedIDs
+	}
+}
+
+func defaultProjectTreeItemSchema(itemType string) map[string]any {
+	return map[string]any{
+		"type":     "object",
+		"itemType": normalizeProjectTreeItemType(itemType),
+	}
+}
+
+func defaultProjectTreeItemData(itemType, name string) map[string]any {
+	return map[string]any{
+		"title":    strings.TrimSpace(name),
+		"itemType": normalizeProjectTreeItemType(itemType),
+	}
+}
+
 func slugDir(prefix, slug string) string {
 	trimmedSlug := strings.TrimSpace(slug)
 	if trimmedSlug == "" {
diff --git a/Backend/internal/httpx/api_project_routes.go b/Backend/internal/httpx/api_project_routes.go
index 0a48cf8..b9a5bd3 100644
--- a/Backend/internal/httpx/api_project_routes.go
+++ b/Backend/internal/httpx/api_project_routes.go
@@ -36,6 +36,24 @@ type moveProjectFolderRequest struct {
 	TargetIndex      int    `json:"targetIndex"`
 }
 
+type createProjectItemRequest struct {
+	Name             string `json:"name"`
+	ParentFolderPath string `json:"parentFolderId"`
+	ItemType         string `json:"itemType"`
+}
+
+type deleteProjectItemRequest struct {
+	ItemPath string `json:"itemId"`
+}
+
+type moveProjectItemRequest struct {
+	ItemPath         string `json:"itemId"`
+	ItemStableID     string `json:"itemNodeId"`
+	ParentFolderPath string `json:"parentFolderId"`
+	ParentStableID   string `json:"parentNodeId"`
+	TargetIndex      int    `json:"targetIndex"`
+}
+
 func (routes apiRoutes) handleProjectFolders(w http.ResponseWriter, r *http.Request) {
 	projectID := strings.TrimSpace(chi.URLParam(r, "projectId"))
 	if projectID == "" {
@@ -238,6 +256,30 @@ func (routes apiRoutes) handleProjectTreeFolders(w http.ResponseWriter, r *http.
 	})
 }
 
+func (routes apiRoutes) handleProjectTree(w http.ResponseWriter, r *http.Request) {
+	projectID := strings.TrimSpace(chi.URLParam(r, "projectId"))
+	if projectID == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Project ID is required.")
+		return
+	}
+
+	nodes, err := routes.bootstrapService().GetProjectTreeNodes(r.Context(), projectID)
+	if err != nil {
+		routes.writeProjectTreeError(w, r, err, "load")
+		return
+	}
+
+	WriteJSON(w, http.StatusOK, map[string]any{
+		"data": map[string]any{
+			"projectId": projectID,
+			"nodes":     nodes,
+		},
+		"meta": map[string]any{
+			"resource": "project-tree",
+		},
+	})
+}
+
 func (routes apiRoutes) handleCreateProjectTreeFolder(w http.ResponseWriter, r *http.Request) {
 	projectID := strings.TrimSpace(chi.URLParam(r, "projectId"))
 	if projectID == "" {
@@ -392,6 +434,124 @@ func (routes apiRoutes) handleMoveProjectTreeFolder(w http.ResponseWriter, r *ht
 	})
 }
 
+func (routes apiRoutes) handleCreateProjectTreeItem(w http.ResponseWriter, r *http.Request) {
+	projectID := strings.TrimSpace(chi.URLParam(r, "projectId"))
+	if projectID == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Project ID is required.")
+		return
+	}
+
+	payload, ok := decodeProjectItemRequest(w, r)
+	if !ok {
+		return
+	}
+
+	payload.Name = strings.TrimSpace(payload.Name)
+	payload.ParentFolderPath = strings.TrimSpace(payload.ParentFolderPath)
+	payload.ItemType = strings.TrimSpace(payload.ItemType)
+	if payload.Name == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Item name is required.")
+		return
+	}
+	if payload.ItemType == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Item type is required.")
+		return
+	}
+
+	result, err := routes.bootstrapService().CreateProjectTreeItem(r.Context(), bootstrapservice.CreateProjectItemInput{
+		ProjectID:        projectID,
+		ParentFolderPath: payload.ParentFolderPath,
+		Name:             payload.Name,
+		ItemType:         payload.ItemType,
+	})
+	if err != nil {
+		routes.writeProjectTreeError(w, r, err, "persist")
+		return
+	}
+
+	WriteJSON(w, http.StatusCreated, map[string]any{
+		"data": result,
+		"meta": map[string]any{
+			"resource":  "project-tree-item-create",
+			"persisted": true,
+		},
+	})
+}
+
+func (routes apiRoutes) handleDeleteProjectTreeItem(w http.ResponseWriter, r *http.Request) {
+	projectID := strings.TrimSpace(chi.URLParam(r, "projectId"))
+	if projectID == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Project ID is required.")
+		return
+	}
+
+	payload := decodeDeleteProjectItemRequest(r)
+	if strings.TrimSpace(payload.ItemPath) == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Item ID is required.")
+		return
+	}
+
+	result, err := routes.bootstrapService().DeleteProjectTreeItem(r.Context(), bootstrapservice.DeleteProjectItemInput{
+		ProjectID: projectID,
+		ItemPath:  payload.ItemPath,
+	})
+	if err != nil {
+		routes.writeProjectTreeError(w, r, err, "delete")
+		return
+	}
+
+	WriteJSON(w, http.StatusOK, map[string]any{
+		"data": result,
+		"meta": map[string]any{
+			"resource":  "project-tree-item-delete",
+			"persisted": true,
+		},
+	})
+}
+
+func (routes apiRoutes) handleMoveProjectTreeItem(w http.ResponseWriter, r *http.Request) {
+	projectID := strings.TrimSpace(chi.URLParam(r, "projectId"))
+	if projectID == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Project ID is required.")
+		return
+	}
+
+	payload, ok := decodeMoveProjectItemRequest(w, r)
+	if !ok {
+		return
+	}
+
+	payload.ItemPath = strings.TrimSpace(payload.ItemPath)
+	payload.ItemStableID = strings.TrimSpace(payload.ItemStableID)
+	payload.ParentFolderPath = strings.TrimSpace(payload.ParentFolderPath)
+	payload.ParentStableID = strings.TrimSpace(payload.ParentStableID)
+	if payload.ItemPath == "" {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", "Item ID is required.")
+		return
+	}
+
+	result, err := routes.bootstrapService().MoveProjectTreeItem(r.Context(), bootstrapservice.MoveProjectItemInput{
+		ProjectID:        projectID,
+		ItemPath:         payload.ItemPath,
+		ItemStableID:     payload.ItemStableID,
+		ParentFolderPath: payload.ParentFolderPath,
+		ParentStableID:   payload.ParentStableID,
+		TargetIndex:      payload.TargetIndex,
+	})
+	if err != nil {
+		routes.writeProjectTreeError(w, r, err, "move")
+		return
+	}
+
+	WriteJSON(w, http.StatusOK, map[string]any{
+		"data": result,
+		"meta": map[string]any{
+			"resource":  "project-tree-item-move",
+			"persisted": true,
+		},
+	})
+}
+
 func (routes apiRoutes) writeProjectFolderError(w http.ResponseWriter, r *http.Request, err error, operation string) {
 	switch {
 	case errors.Is(err, bootstrapservice.ErrProjectNotFound), errors.Is(err, bootstrapservice.ErrProjectFolderNotFound):
@@ -408,6 +568,22 @@ func (routes apiRoutes) writeProjectFolderError(w http.ResponseWriter, r *http.R
 	}
 }
 
+func (routes apiRoutes) writeProjectTreeError(w http.ResponseWriter, r *http.Request, err error, operation string) {
+	switch {
+	case errors.Is(err, bootstrapservice.ErrProjectNotFound), errors.Is(err, bootstrapservice.ErrProjectFolderNotFound), errors.Is(err, bootstrapservice.ErrProjectItemNotFound):
+		WriteError(w, http.StatusNotFound, RequestIDFromContext(r.Context()), "not_found", err.Error())
+	case errors.Is(err, bootstrapservice.ErrInvalidProjectFolderMove), errors.Is(err, bootstrapservice.ErrInvalidProjectItemMove):
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_request", err.Error())
+	default:
+		routes.cfg.Logger.Error(operation+" project tree", "error", err, "path", r.URL.Path)
+		message := "Failed to " + operation + " project tree."
+		if routes.cfg.Config.IsDevelopment() {
+			message = message + " " + err.Error()
+		}
+		WriteError(w, http.StatusInternalServerError, RequestIDFromContext(r.Context()), "project_tree_"+operation+"_failed", message)
+	}
+}
+
 func decodeMoveProjectFolderRequest(w http.ResponseWriter, r *http.Request) (moveProjectFolderRequest, bool) {
 	var payload moveProjectFolderRequest
 
@@ -438,6 +614,12 @@ func decodeDeleteProjectFolderRequest(r *http.Request) deleteProjectFolderReques
 	}
 }
 
+func decodeDeleteProjectItemRequest(r *http.Request) deleteProjectItemRequest {
+	return deleteProjectItemRequest{
+		ItemPath: strings.TrimSpace(r.URL.Query().Get("itemId")),
+	}
+}
+
 func decodeRenameProjectFolderRequest(w http.ResponseWriter, r *http.Request) (renameProjectFolderRequest, bool) {
 	var payload renameProjectFolderRequest
 
@@ -485,3 +667,51 @@ func decodeProjectFolderRequest(w http.ResponseWriter, r *http.Request) (createP
 
 	return payload, true
 }
+
+func decodeProjectItemRequest(w http.ResponseWriter, r *http.Request) (createProjectItemRequest, bool) {
+	var payload createProjectItemRequest
+
+	decoder := json.NewDecoder(r.Body)
+	decoder.DisallowUnknownFields()
+
+	if err := decoder.Decode(&payload); err != nil {
+		if errors.Is(err, io.EOF) {
+			WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_json", "The request body is required and must be valid JSON.")
+			return payload, false
+		}
+
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_json", "The request body must be valid JSON.")
+		return payload, false
+	}
+
+	if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_json", "The request body must contain a single JSON object.")
+		return payload, false
+	}
+
+	return payload, true
+}
+
+func decodeMoveProjectItemRequest(w http.ResponseWriter, r *http.Request) (moveProjectItemRequest, bool) {
+	var payload moveProjectItemRequest
+
+	decoder := json.NewDecoder(r.Body)
+	decoder.DisallowUnknownFields()
+
+	if err := decoder.Decode(&payload); err != nil {
+		if errors.Is(err, io.EOF) {
+			WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_json", "The request body is required and must be valid JSON.")
+			return payload, false
+		}
+
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_json", "The request body must be valid JSON.")
+		return payload, false
+	}
+
+	if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
+		WriteError(w, http.StatusBadRequest, RequestIDFromContext(r.Context()), "invalid_json", "The request body must contain a single JSON object.")
+		return payload, false
+	}
+
+	return payload, true
+}
diff --git a/Backend/internal/httpx/api_routes.go b/Backend/internal/httpx/api_routes.go
index b5e73bf..144251a 100644
--- a/Backend/internal/httpx/api_routes.go
+++ b/Backend/internal/httpx/api_routes.go
@@ -39,11 +39,15 @@ func (routes apiRoutes) Register(router chi.Router) {
 			projectRouter.Patch("/folders", routes.handleRenameProjectFolder)
 			projectRouter.Patch("/folders/move", routes.handleMoveProjectFolder)
 			projectRouter.Delete("/folders", routes.handleDeleteProjectFolder)
+			projectRouter.Get("/tree", routes.handleProjectTree)
 			projectRouter.Get("/tree/folders", routes.handleProjectTreeFolders)
 			projectRouter.Post("/tree/folders", routes.handleCreateProjectTreeFolder)
 			projectRouter.Patch("/tree/folders", routes.handleRenameProjectTreeFolder)
 			projectRouter.Patch("/tree/folders/move", routes.handleMoveProjectTreeFolder)
 			projectRouter.Delete("/tree/folders", routes.handleDeleteProjectTreeFolder)
+			projectRouter.Post("/tree/items", routes.handleCreateProjectTreeItem)
+			projectRouter.Patch("/tree/items/move", routes.handleMoveProjectTreeItem)
+			projectRouter.Delete("/tree/items", routes.handleDeleteProjectTreeItem)
 		})
 
 		if routes.cfg.Config.IsDevelopment() {
diff --git a/Frontend/src/components/shell/MobileWorkspaceBrowser/MobileWorkspaceBrowser.module.scss b/Frontend/src/components/shell/MobileWorkspaceBrowser/MobileWorkspaceBrowser.module.scss
index 68d69a2..ec56c85 100644
--- a/Frontend/src/components/shell/MobileWorkspaceBrowser/MobileWorkspaceBrowser.module.scss
+++ b/Frontend/src/components/shell/MobileWorkspaceBrowser/MobileWorkspaceBrowser.module.scss
@@ -12,13 +12,13 @@
   }
 
 	.sheet {
-    min-height: 100dvh;
+    height: 100dvh;
     display: grid;
     grid-template-rows: auto minmax(0, 1fr);
     background:
       linear-gradient(180deg, color-mix(in srgb, var(--color-surface) 84%, transparent) 0%, transparent 8rem),
       color-mix(in srgb, var(--color-canvas) 97%, black 3%);
-    overflow: clip;
+    overflow: hidden;
   }
 
   .sheetHeader {
@@ -98,15 +98,21 @@
 
   .sheetBody {
     min-height: 0;
-    display: grid;
+    display: flex;
+    flex-direction: column;
+    align-items: stretch;
     gap: var(--space-5);
     padding: var(--space-5) var(--space-5) calc(var(--space-12) + var(--space-10) + env(safe-area-inset-bottom, 0px));
-    overflow: auto;
+    overflow-y: auto;
+    overflow-x: hidden;
+    overscroll-behavior: contain;
+    -webkit-overflow-scrolling: touch;
   }
 
   .sectionBlock {
     display: grid;
     gap: var(--space-2);
+    flex: 0 0 auto;
   }
 
   .treeList,
@@ -185,6 +191,224 @@
   }
 
   .treeListNested > .treeListItem > .treeRow {
-    min-height: calc(var(--control-size-lg) + var(--space-1));
+     min-height: calc(var(--control-size-lg) + var(--space-1));
   }
+
+	.dialogLayer {
+		position: fixed;
+		inset: 0;
+		display: grid;
+		place-items: center;
+		z-index: calc(var(--z-modal, 30) + 2);
+		padding: var(--space-5);
+	}
+
+	.dialogBackdrop {
+		position: absolute;
+		inset: 0;
+		border: 0;
+		background: color-mix(in srgb, black 56%, transparent);
+	}
+
+	.dialogCard {
+		position: relative;
+		width: min(100%, 28rem);
+		display: grid;
+		gap: var(--space-4);
+		padding: var(--space-4);
+		border: 1px solid color-mix(in srgb, var(--color-border) 88%, transparent);
+		border-radius: var(--radius-xl);
+		background: color-mix(in srgb, var(--color-surface) 94%, var(--color-canvas) 6%);
+		box-shadow: var(--shadow-strong);
+	}
+
+	.dialogCopy {
+		display: grid;
+		gap: var(--space-2);
+	}
+
+	.dialogTitle {
+		@include text-title;
+		color: var(--color-text);
+		font-weight: var(--font-weight-semibold);
+	}
+
+	.dialogMessage {
+		@include text-body;
+		margin: 0;
+		color: var(--color-text-subtle);
+	}
+
+	.dialogInput {
+		width: 100%;
+		min-height: var(--control-size-lg);
+		padding: 0 var(--space-3);
+		border: 1px solid color-mix(in srgb, var(--color-border-strong, var(--color-border)) 82%, transparent);
+		border-radius: var(--radius-lg);
+		background: color-mix(in srgb, var(--color-canvas) 92%, var(--color-surface) 8%);
+		color: var(--color-text);
+		font: inherit;
+	}
+
+	.moveSheetLayer {
+		position: fixed;
+		inset: 0;
+		display: block;
+		z-index: calc(var(--z-modal, 30) + 2);
+	}
+
+	.moveSheet {
+		position: absolute;
+		right: 0;
+		bottom: 0;
+		left: 0;
+		max-height: calc(100dvh - (var(--space-12) * 2));
+		display: grid;
+		gap: var(--space-3);
+		padding: var(--space-3) var(--space-3) calc(var(--space-4) + env(safe-area-inset-bottom, 0px));
+		border-top: 1px solid color-mix(in srgb, var(--color-border) 88%, transparent);
+		border-radius: var(--radius-xl) var(--radius-xl) 0 0;
+		background: var(--color-surface);
+		box-shadow: var(--shadow-strong);
+		overflow: auto;
+	}
+
+	.moveSheetHandle {
+		width: var(--space-10);
+		height: var(--space-1);
+		margin: 0 auto;
+		border-radius: var(--radius-pill);
+		background: color-mix(in srgb, var(--color-text-muted) 24%, transparent);
+	}
+
+	.moveSheetHeader {
+		display: grid;
+		gap: var(--space-2);
+		padding-bottom: var(--space-3);
+		border-bottom: 1px solid color-mix(in srgb, var(--color-border) 88%, transparent);
+	}
+
+	.moveSheetHeaderCopy {
+		display: grid;
+		gap: calc(var(--space-1) / 2);
+	}
+
+	.moveSheetEyebrow {
+		@include text-caption;
+		color: var(--color-text-muted);
+		text-transform: uppercase;
+		letter-spacing: 0.06em;
+	}
+
+	.moveSheetTitle {
+		@include text-title;
+		color: var(--color-text);
+		font-weight: var(--font-weight-semibold);
+	}
+
+	.moveSheetMessage {
+		@include text-body;
+		margin: 0;
+		color: var(--color-text-subtle);
+	}
+
+	.moveSection {
+		display: grid;
+		gap: var(--space-2);
+	}
+
+	.moveSectionLabel {
+		@include text-caption;
+		padding-inline: var(--space-1);
+		color: var(--color-text-muted);
+		text-transform: uppercase;
+		letter-spacing: 0.06em;
+	}
+
+	.moveDestinationList {
+		display: grid;
+		overflow: hidden;
+		border: 1px solid color-mix(in srgb, var(--color-border) 88%, transparent);
+		border-radius: var(--radius-lg);
+		background: color-mix(in srgb, var(--color-surface) 88%, var(--color-surface-elevated, var(--color-surface)) 12%);
+		max-height: min(20rem, 45vh);
+		overflow-y: auto;
+	}
+
+	.moveDestinationButton {
+		width: 100%;
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		gap: var(--space-3);
+		min-height: calc(var(--control-size-lg) + var(--space-2));
+		padding: 0 var(--space-3);
+		padding-left: calc(var(--space-3) + (var(--move-depth, 0) * var(--space-4)));
+		border: 0;
+		background: transparent;
+		color: var(--color-text);
+		text-align: left;
+	}
+
+	.moveDestinationButton:active {
+		background: color-mix(in srgb, var(--color-text) 6%, transparent);
+	}
+
+	.moveDestinationButton + .moveDestinationButton {
+		border-top: 1px solid color-mix(in srgb, var(--color-border) 92%, transparent);
+	}
+
+	.moveDestinationLabel {
+		@include text-label;
+		min-width: 0;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.moveDestinationMeta {
+		@include text-caption;
+		color: var(--color-text-muted);
+		flex: 0 0 auto;
+	}
+
+	.moveSheetFooter {
+		display: flex;
+		justify-content: flex-end;
+		padding-top: var(--space-2);
+		border-top: 1px solid color-mix(in srgb, var(--color-border) 88%, transparent);
+	}
+
+	.dialogActions {
+		display: flex;
+		justify-content: flex-end;
+		gap: var(--space-2);
+	}
+
+	.dialogSecondaryButton,
+	.dialogPrimaryButton {
+		min-height: var(--control-size-md);
+		padding: 0 var(--space-3);
+		border-radius: 999px;
+		font: inherit;
+		font-weight: var(--font-weight-semibold);
+	}
+
+	.dialogSecondaryButton {
+		border: 1px solid color-mix(in srgb, var(--color-border) 88%, transparent);
+		background: color-mix(in srgb, var(--color-surface) 92%, transparent);
+		color: var(--color-text-subtle);
+	}
+
+	.dialogPrimaryButton {
+		border: 1px solid color-mix(in srgb, var(--color-border-strong, var(--color-border)) 82%, transparent);
+		background: color-mix(in srgb, var(--color-text) 10%, var(--color-surface) 90%);
+		color: var(--color-text);
+	}
+
+	.dialogDangerButton {
+		border-color: color-mix(in srgb, var(--color-danger-border, var(--color-border-strong, var(--color-border))) 82%, transparent);
+		background: color-mix(in srgb, var(--color-danger-text, #b42318) 12%, var(--color-surface) 88%);
+		color: var(--color-danger-text, #b42318);
+	}
 }
diff --git a/Frontend/src/components/shell/MobileWorkspaceBrowser/MobileWorkspaceBrowser.tsx b/Frontend/src/components/shell/MobileWorkspaceBrowser/MobileWorkspaceBrowser.tsx
index 6e1ffea..79efa1b 100644
--- a/Frontend/src/components/shell/MobileWorkspaceBrowser/MobileWorkspaceBrowser.tsx
+++ b/Frontend/src/components/shell/MobileWorkspaceBrowser/MobileWorkspaceBrowser.tsx
@@ -1,4 +1,5 @@
 import { For, Show, createSignal, type JSX } from "solid-js";
+import { Portal } from "solid-js/web";
 import { ChevronRight, Plus, X } from "../../../lib/icons";
 import { useAppShellData } from "../data/app-shell.context";
 import { createLongPressGesture } from "../createLongPressGesture";
@@ -6,14 +7,17 @@ import {
 	createWorkspaceStaticTarget,
 	createWorkspaceSurfaceTarget,
 	createWorkspaceTreeTarget,
+	getWorkspaceItemTypeDefinition,
 	getWorkspaceNodeIcon,
 	workspaceStaticItems,
 	type SidebarItem,
 	type WorkspaceContextMenuAction,
 	type WorkspaceContextMenuTarget,
+	type WorkspaceItemTypeId,
 	type WorkspaceStaticItem,
 	type WorkspaceTreeNode,
 } from "../data/shell.data";
+import { useWorkspaceTreeData } from "../shared/useWorkspaceTreeData";
 import { WorkspaceMobileActionSheet } from "../WorkspaceMobileActionSheet/WorkspaceMobileActionSheet";
 import styles from "./MobileWorkspaceBrowser.module.scss";
 
@@ -22,6 +26,89 @@ type MobileWorkspaceBrowserProps = {
 	onClose: VoidFunction;
 };
 
+type MobileWorkspaceDialogState =
+	| {
+			kind: "text";
+			title: string;
+			message: string;
+			confirmLabel: string;
+			initialValue: string;
+			onConfirm: (value: string) => void;
+	  }
+	| {
+			kind: "confirm";
+			title: string;
+			message: string;
+			confirmLabel: string;
+			tone?: "danger";
+			onConfirm: () => void;
+	  };
+
+type MobileMoveTargetState = {
+	kind: "folder" | "item";
+	id: string;
+	label: string;
+};
+
+type MobileMoveDestination = {
+	id: string | null;
+	label: string;
+	depth: number;
+	meta?: string;
+};
+
+const collectMoveDestinations = (
+	nodes: readonly WorkspaceTreeNode[],
+	movingTarget: MobileMoveTargetState,
+	depth = 0,
+	ancestorBlocked = false,
+): MobileMoveDestination[] => {
+	const destinations: MobileMoveDestination[] = [];
+
+	for (const node of nodes) {
+		if (node.kind !== "folder") {
+			continue;
+		}
+
+		const isBlockedFolder = movingTarget.kind === "folder" && node.id === movingTarget.id;
+		if (!ancestorBlocked && !isBlockedFolder) {
+			destinations.push({
+				id: node.id,
+				label: node.label,
+				depth,
+				meta: "Folder",
+			});
+		}
+
+		destinations.push(
+			...collectMoveDestinations(node.children ?? [], movingTarget, depth + 1, ancestorBlocked || isBlockedFolder),
+		);
+	}
+
+	return destinations;
+};
+
+const findTreeNodeById = (nodes: readonly WorkspaceTreeNode[], nodeId: string): WorkspaceTreeNode | null => {
+	for (const node of nodes) {
+		if (node.id === nodeId) {
+			return node;
+		}
+
+		if (node.kind !== "folder") {
+			continue;
+		}
+
+		const nestedMatch = findTreeNodeById(node.children ?? [], nodeId);
+		if (nestedMatch) {
+			return nestedMatch;
+		}
+	}
+
+	return null;
+};
+
+const isDangerDialogState = (state: MobileWorkspaceDialogState): boolean => state.kind === "confirm" && state.tone === "danger";
+
 const TreeRow = (props: { node: WorkspaceTreeNode; depth?: number }): JSX.Element => {
 	const depth = props.depth ?? 0;
 	const Icon = getWorkspaceNodeIcon(props.node);
@@ -76,6 +163,7 @@ const StaticRow = (props: { item: SidebarItem }): JSX.Element => {
 		</button>
 	);
 };
+
 const WorkspaceStaticRow = (props: {
 	item: WorkspaceStaticItem;
 	onOpenActionSheet: (target: WorkspaceContextMenuTarget) => void;
@@ -149,21 +237,240 @@ const WorkspaceTreeBranch = (props: {
 export const MobileWorkspaceBrowser = (props: MobileWorkspaceBrowserProps): JSX.Element => {
 	const appShellData = useAppShellData();
 	const [actionSheetTarget, setActionSheetTarget] = createSignal<WorkspaceContextMenuTarget | null>(null);
-	const sectionNodes = () => appShellData.workspaceTree().filter((node) => (node.children?.length ?? 0) > 0);
-	const looseNodes = () => appShellData.workspaceTree().filter((node) => (node.children?.length ?? 0) === 0);
+	const [dialogState, setDialogState] = createSignal<MobileWorkspaceDialogState | null>(null);
+	const [dialogValue, setDialogValue] = createSignal("");
+	const [moveTarget, setMoveTarget] = createSignal<MobileMoveTargetState | null>(null);
+	const { workspaceTreeNodes, createFolder, renameFolder, deleteFolder, moveFolder, createItem, deleteItem, moveItem } = useWorkspaceTreeData({
+		activeProjectId: () => appShellData.activeProject().id,
+		fallbackWorkspaceTree: () => appShellData.workspaceTree(),
+	});
 	const workspaceTarget = () => createWorkspaceSurfaceTarget(appShellData.activeProject());
+
+	const moveDestinations = () => {
+		const target = moveTarget();
+		if (!target) {
+			return [] as MobileMoveDestination[];
+		}
+
+		return [
+			{ id: null, label: "Items root", depth: 0, meta: "Root" },
+			...collectMoveDestinations(workspaceTreeNodes(), target),
+		];
+	};
+
+	const resolveCreateItemType = (actionId: string): WorkspaceItemTypeId | null => {
+		switch (actionId) {
+			case "create-doc":
+				return "core.doc";
+			case "create-board":
+				return "core.board.kanban";
+			case "create-list-board":
+				return "core.board.list";
+			default:
+				return null;
+		}
+	};
+
+	const createPersistedItem = (itemType: WorkspaceItemTypeId, parentId: string | null): void => {
+		const definition = getWorkspaceItemTypeDefinition(itemType);
+		void createItem(definition.defaultCreateLabel, itemType, parentId);
+	};
+
 	const openActionSheet = (target: WorkspaceContextMenuTarget): void => {
 		setActionSheetTarget(target);
 	};
+
 	const closeActionSheet = (): void => {
 		setActionSheetTarget(null);
 	};
+
+	const closeMoveSheet = (): void => {
+		setMoveTarget(null);
+	};
+
 	const openWorkspaceActionSheet = (): void => {
 		openActionSheet(workspaceTarget());
 	};
 
-	const handleActionSelect = (_action: WorkspaceContextMenuAction, _target: WorkspaceContextMenuTarget): void => {
-		// Mobile first pass only establishes the action-sheet IA and long-press behavior.
+	const closeDialog = (): void => {
+		setDialogState(null);
+		setDialogValue("");
+	};
+
+	const openMoveSheet = (target: MobileMoveTargetState): void => {
+		setMoveTarget(target);
+	};
+
+	const openTextDialog = (config: Omit<Extract<MobileWorkspaceDialogState, { kind: "text" }>, "kind">): void => {
+		setDialogValue(config.initialValue);
+		setDialogState({ kind: "text", ...config });
+	};
+
+	const openConfirmDialog = (config: Omit<Extract<MobileWorkspaceDialogState, { kind: "confirm" }>, "kind">): void => {
+		setDialogValue("");
+		setDialogState({ kind: "confirm", ...config });
+	};
+
+	const submitDialog = (): void => {
+		const state = dialogState();
+		if (!state) {
+			return;
+		}
+
+		if (state.kind === "text") {
+			const value = dialogValue().trim();
+			if (!value) {
+				return;
+			}
+
+			closeDialog();
+			state.onConfirm(value);
+			return;
+		}
+
+		closeDialog();
+		state.onConfirm();
+	};
+
+	const handleMoveDestinationSelect = (destinationId: string | null): void => {
+		const target = moveTarget();
+		if (!target) {
+			return;
+		}
+
+		const destinationNode = destinationId ? findTreeNodeById(workspaceTreeNodes(), destinationId) : null;
+		const targetIndex = destinationNode?.kind === "folder"
+			? destinationNode.children?.length ?? 0
+			: destinationId
+				? 0
+				: workspaceTreeNodes().length;
+
+		closeMoveSheet();
+
+		if (target.kind === "folder") {
+			void moveFolder(target.id, destinationId, targetIndex);
+			return;
+		}
+
+		void moveItem(target.id, destinationId, targetIndex);
+	};
+
+	const handleActionSelect = (action: WorkspaceContextMenuAction, target: WorkspaceContextMenuTarget): void => {
+		const createItemType = resolveCreateItemType(action.id);
+		if (createItemType) {
+			switch (target.kind) {
+				case "workspace":
+				case "home":
+					createPersistedItem(createItemType, null);
+					return;
+				case "folder":
+					createPersistedItem(createItemType, target.id);
+					return;
+				case "settings":
+				case "item":
+					return;
+			}
+		}
+
+		switch (action.id) {
+			case "new-folder": {
+				if (target.kind === "settings" || target.kind === "item") {
+					return;
+				}
+
+				openTextDialog({
+					title: "New folder",
+					message: target.kind === "folder" ? `Create a folder inside "${target.label}".` : "Create a folder at the root of Items.",
+					confirmLabel: "Create",
+					initialValue: "Untitled folder",
+					onConfirm: (name) => {
+						void createFolder(name, target.kind === "folder" ? target.id : null);
+					},
+				});
+				return;
+			}
+			case "rename-folder": {
+				if (target.kind !== "folder") {
+					return;
+				}
+
+				openTextDialog({
+					title: "Rename folder",
+					message: `Update the name for "${target.label}".`,
+					confirmLabel: "Save",
+					initialValue: target.label,
+					onConfirm: (name) => {
+						if (name === target.label) {
+							return;
+						}
+						void renameFolder(target.id, name);
+					},
+				});
+				return;
+			}
+			case "move-folder": {
+				if (target.kind !== "folder") {
+					return;
+				}
+
+				openMoveSheet({
+					kind: "folder",
+					id: target.id,
+					label: target.label,
+				});
+				return;
+			}
+			case "delete-folder": {
+				if (target.kind !== "folder") {
+					return;
+				}
+
+				openConfirmDialog({
+					title: "Delete folder?",
+					message: `"${target.label}" and everything inside it will be removed.`,
+					confirmLabel: "Delete",
+					tone: "danger",
+					onConfirm: () => {
+						void deleteFolder(target.id);
+					},
+				});
+				return;
+			}
+			case "move-doc":
+			case "move-board":
+			case "move-list-board": {
+				if (target.kind !== "item") {
+					return;
+				}
+
+				openMoveSheet({
+					kind: "item",
+					id: target.id,
+					label: target.label,
+				});
+				return;
+			}
+			case "delete-doc":
+			case "delete-board":
+			case "delete-list-board": {
+				if (target.kind !== "item") {
+					return;
+				}
+
+				openConfirmDialog({
+					title: "Delete item?",
+					message: `"${target.label}" will be removed from the project tree.`,
+					confirmLabel: "Delete",
+					tone: "danger",
+					onConfirm: () => {
+						void deleteItem(target.id);
+					},
+				});
+				return;
+			}
+			default:
+				return;
+		}
 	};
 
 	const workspaceLongPress = createLongPressGesture({
@@ -212,35 +519,119 @@ export const MobileWorkspaceBrowser = (props: MobileWorkspaceBrowserProps): JSX.
 						<section class={styles.sectionBlock} data-slot="mobile-workspace-section" data-section-id="workspace">
 							<span class={styles.sectionLabel}>Workspace</span>
 							<ul class={styles.treeList} data-slot="mobile-workspace-list" data-section-id="workspace">
-						<For each={workspaceStaticItems}>
-							{(item): JSX.Element => <WorkspaceStaticRow item={item} onOpenActionSheet={openActionSheet} />}
-						</For>
+								<For each={workspaceStaticItems}>
+									{(item): JSX.Element => <WorkspaceStaticRow item={item} onOpenActionSheet={openActionSheet} />}
+								</For>
 							</ul>
 						</section>
 
 						<section class={styles.sectionBlock} data-slot="mobile-workspace-section" data-section-id="items">
 							<span class={styles.sectionLabel}>Items</span>
 							<ul class={styles.treeList} data-slot="mobile-workspace-list" data-section-id="items">
-								<WorkspaceTreeBranch nodes={sectionNodes()} onOpenActionSheet={openActionSheet} />
+								<WorkspaceTreeBranch nodes={workspaceTreeNodes()} onOpenActionSheet={openActionSheet} />
 							</ul>
 						</section>
-
-						<Show when={looseNodes().length > 0}>
-							<section class={styles.sectionBlock} data-slot="mobile-workspace-section" data-section-id="more">
-								<span class={styles.sectionLabel}>More</span>
-								<ul class={styles.treeList} data-slot="mobile-workspace-list" data-section-id="more">
-									<WorkspaceTreeBranch nodes={looseNodes()} onOpenActionSheet={openActionSheet} />
-								</ul>
-							</section>
-						</Show>
 					</div>
 				</section>
 
-				<WorkspaceMobileActionSheet
-					target={actionSheetTarget()}
-					onClose={closeActionSheet}
-					onSelect={handleActionSelect}
-				/>
+				<WorkspaceMobileActionSheet target={actionSheetTarget()} onClose={closeActionSheet} onSelect={handleActionSelect} />
+
+				<Show when={moveTarget()}>
+					{(state): JSX.Element => (
+						<Portal>
+							<div class={styles.moveSheetLayer} data-ui="mobile-workspace-move-sheet">
+								<button class={styles.dialogBackdrop} type="button" aria-label="Close move sheet" onClick={closeMoveSheet} />
+								<section class={styles.moveSheet} aria-label={`Move ${state().label}`}>
+									<div class={styles.moveSheetHandle} aria-hidden="true" />
+									<div class={styles.moveSheetHeader}>
+										<div class={styles.moveSheetHeaderCopy}>
+											<span class={styles.moveSheetEyebrow}>Move {state().kind}</span>
+											<strong class={styles.moveSheetTitle}>{state().label}</strong>
+											<p class={styles.moveSheetMessage}>Choose a new location in the project tree.</p>
+										</div>
+									</div>
+
+									<div class={styles.moveSection}>
+										<span class={styles.moveSectionLabel}>Destination</span>
+										<div class={styles.moveDestinationList}>
+											<For each={moveDestinations()}>
+												{(destination): JSX.Element => (
+													<button
+														type="button"
+														class={styles.moveDestinationButton}
+														style={{ "--move-depth": `${destination.depth}` }}
+														onClick={(): void => handleMoveDestinationSelect(destination.id)}
+													>
+														<span class={styles.moveDestinationLabel}>{destination.label}</span>
+														<Show when={destination.meta}>
+															<span class={styles.moveDestinationMeta}>{destination.meta}</span>
+														</Show>
+													</button>
+												)}
+											</For>
+										</div>
+									</div>
+
+									<div class={styles.moveSheetFooter}>
+										<button class={styles.dialogSecondaryButton} type="button" onClick={closeMoveSheet}>
+											Cancel
+										</button>
+									</div>
+								</section>
+							</div>
+						</Portal>
+					)}
+				</Show>
+
+				<Show when={dialogState()}>
+					{(state): JSX.Element => (
+						<Portal>
+							<div class={styles.dialogLayer} data-ui="mobile-workspace-dialog">
+								<button class={styles.dialogBackdrop} type="button" aria-label="Close dialog" onClick={closeDialog} />
+								<section class={styles.dialogCard} aria-label={state().title}>
+									<div class={styles.dialogCopy}>
+										<strong class={styles.dialogTitle}>{state().title}</strong>
+										<p class={styles.dialogMessage}>{state().message}</p>
+									</div>
+
+									<Show when={state().kind === "text"}>
+										<input
+											class={styles.dialogInput}
+											type="text"
+											value={dialogValue()}
+											onInput={(event): void => {
+												setDialogValue(event.currentTarget.value);
+											}}
+											onKeyDown={(event): void => {
+												if (event.key === "Enter") {
+													event.preventDefault();
+													submitDialog();
+												}
+											}}
+											autofocus
+										/>
+									</Show>
+
+									<div class={styles.dialogActions}>
+										<button class={styles.dialogSecondaryButton} type="button" onClick={closeDialog}>
+											Cancel
+										</button>
+										<button
+											classList={{
+												[styles.dialogPrimaryButton]: true,
+												[styles.dialogDangerButton]: isDangerDialogState(state()),
+											}}
+											type="button"
+											onClick={submitDialog}
+										>
+											{state().confirmLabel}
+										</button>
+									</div>
+								</section>
+							</div>
+						</Portal>
+					)}
+				</Show>
 			</div>
 		</Show>
 	);
diff --git a/Frontend/src/components/shell/ProjectContextMenu/createProjectContextMenuController.ts b/Frontend/src/components/shell/ProjectContextMenu/createProjectContextMenuController.ts
index 12a8b84..3110220 100644
--- a/Frontend/src/components/shell/ProjectContextMenu/createProjectContextMenuController.ts
+++ b/Frontend/src/components/shell/ProjectContextMenu/createProjectContextMenuController.ts
@@ -70,6 +70,15 @@ export const createProjectContextMenuController = () => {
 		setMenuState({ target, x: event.clientX, y: event.clientY });
 	};
 
+	const openMenuFromElement = (element: HTMLElement, target: ProjectMenuTarget): void => {
+		const rect = element.getBoundingClientRect();
+		setMenuState({
+			target,
+			x: rect.left + rect.width / 2,
+			y: rect.top + rect.height / 2,
+		});
+	};
+
 	createEffect(() => {
 		if (!menuState() || typeof window === "undefined") {
 			return;
@@ -112,6 +121,7 @@ export const createProjectContextMenuController = () => {
 	return {
 		menuState,
 		openMenu,
+		openMenuFromElement,
 		closeMenu,
 		setMenuRef: (element: HTMLDivElement): void => {
 			menuRef = element;
diff --git a/Frontend/src/components/shell/ProjectSelector/ProjectSelector.module.scss b/Frontend/src/components/shell/ProjectSelector/ProjectSelector.module.scss
index cc8419a..4e44aa7 100644
--- a/Frontend/src/components/shell/ProjectSelector/ProjectSelector.module.scss
+++ b/Frontend/src/components/shell/ProjectSelector/ProjectSelector.module.scss
@@ -315,6 +315,26 @@
 	@include treeNav.item-meta;
 }
 
+.dragGhostLayer {
+	@include treeNav.drag-ghost-layer;
+}
+
+.dragGhost {
+	@include treeNav.drag-ghost;
+}
+
+.dragGhostCopy {
+	@include treeNav.drag-ghost-copy;
+}
+
+.dragGhostTitle {
+	@include treeNav.drag-ghost-title;
+}
+
+.dragGhostMeta {
+	@include treeNav.drag-ghost-meta;
+}
+
 @media (max-width: 720px) {
   .rootCompact .scrim,
   .rootCompact .drawer {
diff --git a/Frontend/src/components/shell/ProjectSelector/ProjectSelector.tsx b/Frontend/src/components/shell/ProjectSelector/ProjectSelector.tsx
index 683ddf4..7d5c7ac 100644
--- a/Frontend/src/components/shell/ProjectSelector/ProjectSelector.tsx
+++ b/Frontend/src/components/shell/ProjectSelector/ProjectSelector.tsx
@@ -1,7 +1,8 @@
 // Path: Frontend/src/components/shell/ProjectSelector/ProjectSelector.tsx
 
 import { For, Show, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
-import { ChevronDown, ChevronRight, Folder, LayoutGrid, ListCollapse, UnfoldVertical } from "../../../lib/icons";
+import { Portal } from "solid-js/web";
+import { ChevronDown, ChevronRight, Folder, LayoutGrid, ListCollapse, Plus, UnfoldVertical } from "../../../lib/icons";
 import { ProjectContextMenu } from "../ProjectContextMenu/ProjectContextMenu";
 import { useAppShellData } from "../data/app-shell.context";
 import { resolveAPIBase } from "../../../lib/api";
@@ -85,6 +86,11 @@ type ProjectDragState = {
 	dropTarget: ProjectDragTarget | null;
 };
 
+type DragGhostPosition = {
+	x: number;
+	y: number;
+};
+
 const LONG_PRESS_MS = 320;
 
 const getProjectTreeNodeId = (node: ProjectTreeNode): string =>
@@ -378,6 +384,7 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 	const [pendingFolderRename, setPendingFolderRename] = createSignal<PendingProjectFolderRename | null>(null);
 	const [pendingFolderRenameName, setPendingFolderRenameName] = createSignal("");
 	const [dragState, setDragState] = createSignal<ProjectDragState | null>(null);
+	const [dragGhostPosition, setDragGhostPosition] = createSignal<DragGhostPosition>({ x: 0, y: 0 });
 	const [suppressNextTreeClick, setSuppressNextTreeClick] = createSignal(false);
 	let rootRef: HTMLDivElement | undefined;
 	let triggerRef: HTMLButtonElement | undefined;
@@ -395,6 +402,28 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 		}
 	};
 
+	const updateDragGhostPosition = (x: number, y: number): void => {
+		setDragGhostPosition({ x: x + 18, y: y + 18 });
+	};
+
+	const draggedNode = (): ProjectTreeNode | null => {
+		const currentDragState = dragState();
+		if (!currentDragState) {
+			return null;
+		}
+
+		return findTreeNodeLocation(projectTreeNodes(), currentDragState.draggedNodeId, projectTreeAdapter)?.node ?? null;
+	};
+
+	const draggedNodeMeta = (): string => {
+		const node = draggedNode();
+		if (!node) {
+			return "";
+		}
+
+		return node.kind === "folder" ? "Folder" : "Project";
+	};
+
 	const suppressTreeClickTemporarily = (): void => {
 		setSuppressNextTreeClick(true);
 
@@ -653,22 +682,32 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 			triggerRef?.focus();
 		};
 
+		const handlePointerMove = (event: PointerEvent): void => {
+			if (!dragState()) {
+				return;
+			}
+
+			updateDragGhostPosition(event.clientX, event.clientY);
+		};
+
 		document.addEventListener("pointerdown", handlePointerDown);
 		window.addEventListener("pointerup", handlePointerUp);
 		window.addEventListener("pointercancel", handlePointerUp);
+		window.addEventListener("pointermove", handlePointerMove);
 		window.addEventListener("keydown", handleEscape);
 
-		onCleanup(() => {
-			clearLongPressTimer();
-			if (suppressClickTimer !== undefined) {
-				window.clearTimeout(suppressClickTimer);
-			}
-			document.removeEventListener("pointerdown", handlePointerDown);
-			window.removeEventListener("pointerup", handlePointerUp);
-			window.removeEventListener("pointercancel", handlePointerUp);
-			window.removeEventListener("keydown", handleEscape);
+			onCleanup(() => {
+				clearLongPressTimer();
+				if (suppressClickTimer !== undefined) {
+					window.clearTimeout(suppressClickTimer);
+				}
+				document.removeEventListener("pointerdown", handlePointerDown);
+				window.removeEventListener("pointerup", handlePointerUp);
+				window.removeEventListener("pointercancel", handlePointerUp);
+				window.removeEventListener("pointermove", handlePointerMove);
+				window.removeEventListener("keydown", handleEscape);
+			});
 		});
-	});
 
 	const toggleOpen = (): void => {
 		if (!props.isOpen) {
@@ -941,6 +980,10 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 		contextMenu.openMenu(event, createProjectSurfaceTarget("Projects"));
 	};
 
+	const openRootCreateMenu = (element: HTMLElement): void => {
+		contextMenu.openMenuFromElement(element, createProjectSurfaceTarget("Projects"));
+	};
+
 	const treeControlLabel = (): string =>
 		areAllFoldersCollapsed() ? "Expand all folders" : "Collapse all folders";
 
@@ -949,6 +992,7 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 			return;
 		}
 
+		updateDragGhostPosition(event.clientX, event.clientY);
 		clearLongPressTimer();
 		longPressTimer = window.setTimeout(() => {
 			suppressTreeClickTemporarily();
@@ -1062,6 +1106,18 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 								</Show>
 
 								<div class={styles.treeControls}>
+									<button
+										type="button"
+										class={styles.treeControlButton}
+										onClick={(event): void => {
+											event.stopPropagation();
+											openRootCreateMenu(event.currentTarget);
+										}}
+										aria-label="Create in Projects"
+										title="Create"
+									>
+										<Plus size={16} strokeWidth={2.25} />
+									</button>
 									<button
 										type="button"
 										class={styles.treeControlButton}
@@ -1129,6 +1185,32 @@ export const ProjectSelector = (props: ProjectSelectorProps): JSX.Element => {
 				onClose={contextMenu.closeMenu}
 				onSelect={handleContextActionSelect}
 			/>
+
+			<Show when={draggedNode()} keyed>
+				{(node): JSX.Element => {
+					const GhostIcon = node.kind === "folder" ? Folder : LayoutGrid;
+
+					return (
+						<Portal>
+							<div class={styles.dragGhostLayer} aria-hidden="true">
+								<div
+									class={styles.dragGhost}
+									style={{
+										"--drag-ghost-x": `${dragGhostPosition().x}px`,
+										"--drag-ghost-y": `${dragGhostPosition().y}px`,
+									}}
+								>
+									<GhostIcon class={styles.icon} size={18} strokeWidth={2} />
+									<div class={styles.dragGhostCopy}>
+										<div class={styles.dragGhostTitle}>{node.kind === "folder" ? node.label : node.item.name}</div>
+										<div class={styles.dragGhostMeta}>{draggedNodeMeta()}</div>
+									</div>
+								</div>
+							</div>
+						</Portal>
+					);
+				}}
+			</Show>
 		</div>
 	);
 };
diff --git a/Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.module.scss b/Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.module.scss
index f5a9b0e..8a96b06 100644
--- a/Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.module.scss
+++ b/Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.module.scss
@@ -124,6 +124,53 @@
   padding: 0 var(--space-3);
 }
 
+.treeSectionHeader {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: var(--space-2);
+	margin-top: var(--space-3);
+	margin-bottom: var(--space-2);
+	padding-right: var(--space-1);
+}
+
+.treeSectionHeader .treeSectionLabel {
+	margin: 0;
+}
+
+.treeControls {
+	display: inline-flex;
+	align-items: center;
+	gap: var(--space-1);
+	justify-content: flex-end;
+	padding-right: var(--space-2);
+}
+
+.treeControlButton {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: calc(var(--control-size-md) - var(--space-1));
+	height: calc(var(--control-size-md) - var(--space-1));
+	padding: 0;
+	border: 1px solid color-mix(in srgb, var(--color-border) 46%, transparent);
+	border-radius: var(--radius-pill);
+	background: color-mix(in srgb, var(--color-surface) 95%, transparent);
+	color: var(--color-text-muted);
+	transition:
+		border-color 160ms var(--easing-standard),
+		background 160ms var(--easing-standard),
+		color 160ms var(--easing-standard);
+}
+
+.treeControlButton:hover,
+.treeControlButton:focus-visible {
+	border-color: color-mix(in srgb, var(--color-border-strong) 56%, transparent);
+	background: var(--color-surface-hover);
+	color: var(--color-text);
+	outline: none;
+}
+
 .treeList {
 	@include treeNav.tree-list;
 }
@@ -214,6 +261,26 @@
 	@include treeNav.item-meta;
 }
 
+.dragGhostLayer {
+	@include treeNav.drag-ghost-layer;
+}
+
+.dragGhost {
+	@include treeNav.drag-ghost;
+}
+
+.dragGhostCopy {
+	@include treeNav.drag-ghost-copy;
+}
+
+.dragGhostTitle {
+	@include treeNav.drag-ghost-title;
+}
+
+.dragGhostMeta {
+	@include treeNav.drag-ghost-meta;
+}
+
 .sidebarCollapsed {
   gap: var(--space-3);
   padding: var(--space-3) var(--space-2);
@@ -247,6 +314,7 @@
 
 .sidebarCollapsed .label,
 .sidebarCollapsed .itemMeta,
+.sidebarCollapsed .treeSectionHeader,
 .sidebarCollapsed .treeSectionLabel,
 .sidebarCollapsed .treeList {
   display: none;
diff --git a/Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.tsx b/Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.tsx
index 99d8609..3e92f5b 100644
--- a/Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.tsx
+++ b/Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.tsx
@@ -1,8 +1,8 @@
 // Path: Frontend/src/components/shell/WorkspaceSidebar/WorkspaceSidebar.tsx
 
 import { For, Show, createEffect, createSignal, onCleanup, onMount, type JSX } from "solid-js";
-import { resolveAPIBase } from "../../../lib/api";
-import { ChevronLeft, ChevronRight, Folder, ListCollapse, UnfoldVertical } from "../../../lib/icons";
+import { Portal } from "solid-js/web";
+import { ChevronLeft, ChevronRight, Folder, ListCollapse, Plus, UnfoldVertical } from "../../../lib/icons";
 import { useAppShellData } from "../data/app-shell.context";
 import { ProjectSelector } from "../ProjectSelector/ProjectSelector";
 import {
@@ -21,13 +21,16 @@ import {
 	createWorkspaceSurfaceTarget,
 	createWorkspaceTreeTarget,
 	getWorkspaceNodeIcon,
+	getWorkspaceItemTypeDefinition,
 	workspaceSidebarHeaderActions,
 	workspaceStaticItems,
 	type WorkspaceContextMenuAction,
 	type WorkspaceContextMenuTarget,
+	type WorkspaceItemTypeId,
 	type WorkspaceStaticItem,
 	type WorkspaceTreeNode,
 } from "../data/shell.data";
+import { useWorkspaceTreeData } from "../shared/useWorkspaceTreeData";
 import { WorkspaceContextMenu } from "../WorkspaceContextMenu/WorkspaceContextMenu";
 import { createWorkspaceContextMenuController } from "../WorkspaceContextMenu/createWorkspaceContextMenuController";
 import styles from "./WorkspaceSidebar.module.scss";
@@ -50,23 +53,9 @@ type WorkspaceDragState = {
 	dropTarget: WorkspaceDragTarget | null;
 };
 
-type PersistedWorkspaceFolderRecord = {
-	id: string;
-	path: string;
-	label: string;
-	children?: PersistedWorkspaceFolderRecord[];
-};
-
-type WorkspaceFoldersResponse = {
-	data?: {
-		folders?: PersistedWorkspaceFolderRecord[];
-		renamedFolder?: PersistedWorkspaceFolderRecord;
-		movedFolder?: PersistedWorkspaceFolderRecord;
-		previousFolderId?: string;
-		previousFolderPath?: string;
-	};
-	error?: string;
-	message?: string;
+type DragGhostPosition = {
+	x: number;
+	y: number;
 };
 
 type PendingWorkspaceFolderRename = {
@@ -78,21 +67,6 @@ const LONG_PRESS_MS = 320;
 
 const getWorkspaceTreeNodeId = (node: WorkspaceTreeNode): string => node.id;
 
-const buildPersistedWorkspaceFolderNodes = (
-	folders: readonly PersistedWorkspaceFolderRecord[],
-): WorkspaceTreeNode[] =>
-	folders.map((folder) => ({
-		id: folder.id,
-		path: folder.path,
-		label: folder.label,
-		kind: "folder",
-		icon: Folder,
-		children: buildPersistedWorkspaceFolderNodes(folder.children ?? []),
-	}));
-
-const readPersistedWorkspaceFolders = (body: WorkspaceFoldersResponse): PersistedWorkspaceFolderRecord[] =>
-	Array.isArray(body.data?.folders) ? body.data.folders : [];
-
 const countWorkspaceFolderSiblingsBeforeIndex = (
 	siblings: readonly WorkspaceTreeNode[],
 	index: number,
@@ -378,17 +352,31 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 	const appShellData = useAppShellData();
 	const activeProject = () => appShellData.activeProject();
 	const [isProjectDrawerOpen, setIsProjectDrawerOpen] = createSignal(false);
-	const [workspaceTreeNodes, setWorkspaceTreeNodes] = createSignal<readonly WorkspaceTreeNode[]>(appShellData.workspaceTree());
-	const [persistedFolders, setPersistedFolders] = createSignal<readonly PersistedWorkspaceFolderRecord[]>([]);
 	const [collapsedFolderIds, setCollapsedFolderIds] = createSignal<readonly string[]>([]);
 	const [pendingFolderDraft, setPendingFolderDraft] = createSignal<PendingWorkspaceFolderDraft | null>(null);
 	const [pendingFolderName, setPendingFolderName] = createSignal("");
 	const [pendingFolderRename, setPendingFolderRename] = createSignal<PendingWorkspaceFolderRename | null>(null);
 	const [pendingFolderRenameName, setPendingFolderRenameName] = createSignal("");
 	const [dragState, setDragState] = createSignal<WorkspaceDragState | null>(null);
+	const [dragGhostPosition, setDragGhostPosition] = createSignal<DragGhostPosition>({ x: 0, y: 0 });
 	const [suppressNextTreeClick, setSuppressNextTreeClick] = createSignal(false);
 	let lastSelectedProjectId: string | null = null;
-	let latestPersistedFoldersRequest = 0;
+	const {
+		workspaceTreeNodes,
+		setWorkspaceTreeNodes,
+		resolveFolderPath,
+		resolveItemPath,
+		createFolder,
+		renameFolder,
+		deleteFolder,
+		moveFolder,
+		createItem,
+		deleteItem,
+		moveItem,
+	} = useWorkspaceTreeData({
+		activeProjectId: () => activeProject()?.id ?? "",
+		fallbackWorkspaceTree: () => appShellData.workspaceTree(),
+	});
 	const contextMenu = createWorkspaceContextMenuController();
 	let longPressTimer: number | undefined;
 	let suppressClickTimer: number | undefined;
@@ -430,54 +418,32 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 		setPendingFolderRenameName("");
 		setDragState(null);
 	};
-	const syncWorkspaceTree = (): void => {
-		const nextTree = activeProject()?.id
-			? buildPersistedWorkspaceFolderNodes(persistedFolders())
-			: appShellData.workspaceTree();
-		const availableFolderIds = new Set(collectBranchNodeIds(nextTree, workspaceTreeAdapter));
-
-		setWorkspaceTreeNodes(nextTree);
+	const syncCollapsedFolderIds = (): void => {
+		const availableFolderIds = new Set(collectBranchNodeIds(workspaceTreeNodes(), workspaceTreeAdapter));
 		setCollapsedFolderIds((current) => current.filter((id) => availableFolderIds.has(id)));
 	};
-	const loadPersistedFolders = async (projectId: string): Promise<void> => {
-		const requestId = latestPersistedFoldersRequest + 1;
-		latestPersistedFoldersRequest = requestId;
-
-		if (!projectId) {
-			setPersistedFolders([]);
-			return;
+	const updateDragGhostPosition = (x: number, y: number): void => {
+		setDragGhostPosition({ x: x + 18, y: y + 18 });
+	};
+	const draggedNode = (): WorkspaceTreeNode | null => {
+		const currentDragState = dragState();
+		if (!currentDragState) {
+			return null;
 		}
 
-		if (!isUuidString(projectId)) {
-			setPersistedFolders([]);
-			return;
+		return findTreeNodeLocation(workspaceTreeNodes(), currentDragState.draggedNodeId, workspaceTreeAdapter)?.node ?? null;
+	};
+	const draggedNodeMeta = (): string => {
+		const node = draggedNode();
+		if (!node) {
+			return "";
 		}
 
-		try {
-			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders`, {
-				headers: {
-					Accept: "application/json",
-				},
-			});
-			const body = (await response.json()) as WorkspaceFoldersResponse;
-
-			if (requestId !== latestPersistedFoldersRequest) {
-				return;
-			}
-
-			if (!response.ok) {
-				throw new Error(body.message || "Failed to load project tree folders.");
-			}
-
-			setPersistedFolders(readPersistedWorkspaceFolders(body));
-		} catch (error) {
-			if (requestId !== latestPersistedFoldersRequest) {
-				return;
-			}
-
-			console.error(error);
-			setPersistedFolders([]);
+		if (node.kind === "folder") {
+			return "Folder";
 		}
+
+		return getWorkspaceItemTypeDefinition(node.itemType).label;
 	};
 	const clearLongPressTimer = (): void => {
 		if (longPressTimer !== undefined) {
@@ -499,7 +465,7 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 	};
 
 	createEffect(() => {
-		syncWorkspaceTree();
+		syncCollapsedFolderIds();
 	});
 
 	createEffect(() => {
@@ -518,11 +484,15 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 		resetWorkspaceTreeInteractionState();
 	});
 
-	createEffect(() => {
-		void loadPersistedFolders(activeProject()?.id ?? "");
-	});
-
 	onMount(() => {
+		const handlePointerMove = (event: PointerEvent): void => {
+			if (!dragState()) {
+				return;
+			}
+
+			updateDragGhostPosition(event.clientX, event.clientY);
+		};
+
 		const handlePointerUp = (): void => {
 			clearLongPressTimer();
 
@@ -541,13 +511,11 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 			const currentNodes = workspaceTreeNodes();
 			const draggedLocation = findTreeNodeLocation(currentNodes, nextDragState.draggedNodeId, workspaceTreeAdapter);
 			const canPersistMove = isUuidString(activeProject()?.id ?? "");
-			const draggedFolderPath = draggedLocation?.node.kind === "folder" ? draggedLocation.node.path ?? null : null;
 			const previewNodes = moveTreeNode(currentNodes, nextDragState.draggedNodeId, nextDragState.dropTarget as WorkspaceDragTarget, workspaceTreeAdapter);
 			const previewLocation = findTreeNodeLocation(previewNodes, nextDragState.draggedNodeId, workspaceTreeAdapter);
 			const persistedParentLocation = previewLocation?.parentId
 				? findTreeNodeLocation(previewNodes, previewLocation.parentId, workspaceTreeAdapter)
 				: null;
-			const persistedParentFolderPath = persistedParentLocation?.node.kind === "folder" ? persistedParentLocation.node.path ?? null : null;
 			const previewSiblings = previewLocation?.parentId
 				? persistedParentLocation?.node.kind === "folder"
 					? persistedParentLocation.node.children ?? []
@@ -563,16 +531,24 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 			if (
 				canPersistMove &&
 				draggedLocation?.node.kind === "folder" &&
-				draggedFolderPath &&
 				(!previewLocation?.parentId || persistedParentLocation?.node.kind === "folder")
 			) {
-				void movePersistedFolder(
-					draggedFolderPath,
-					persistedParentFolderPath,
+				void moveFolder(
 					draggedLocation.node.id,
 					persistedParentLocation?.node.kind === "folder" ? persistedParentLocation.node.id : null,
 					targetIndex,
 				);
+			} else if (
+				canPersistMove &&
+				draggedLocation?.node.kind === "item" &&
+				resolveItemPath(draggedLocation.node.id) &&
+				(!previewLocation?.parentId || persistedParentLocation?.node.kind === "folder")
+			) {
+				void moveItem(
+					draggedLocation.node.id,
+					persistedParentLocation?.node.kind === "folder" ? persistedParentLocation.node.id : null,
+					previewLocation?.index ?? 0,
+				);
 			} else {
 				setWorkspaceTreeNodes((current) =>
 					moveTreeNode(current, nextDragState.draggedNodeId, nextDragState.dropTarget as WorkspaceDragTarget, workspaceTreeAdapter),
@@ -596,18 +572,20 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 
 		window.addEventListener("pointerup", handlePointerUp);
 		window.addEventListener("pointercancel", handlePointerUp);
+		window.addEventListener("pointermove", handlePointerMove);
 		window.addEventListener("keydown", handleEscape);
 
-		onCleanup(() => {
-			clearLongPressTimer();
-			if (suppressClickTimer !== undefined) {
-				window.clearTimeout(suppressClickTimer);
-			}
-			window.removeEventListener("pointerup", handlePointerUp);
-			window.removeEventListener("pointercancel", handlePointerUp);
-			window.removeEventListener("keydown", handleEscape);
+			onCleanup(() => {
+				clearLongPressTimer();
+				if (suppressClickTimer !== undefined) {
+					window.clearTimeout(suppressClickTimer);
+				}
+				window.removeEventListener("pointerup", handlePointerUp);
+				window.removeEventListener("pointercancel", handlePointerUp);
+				window.removeEventListener("pointermove", handlePointerMove);
+				window.removeEventListener("keydown", handleEscape);
+			});
 		});
-	});
 
 	const beginFolderDraft = (parentId: string | null, depth: number): void => {
 		if (parentId) {
@@ -627,11 +605,6 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 		setPendingFolderRenameName(label);
 	};
 
-	const resolveFolderPath = (folderId: string): string | null => {
-		const location = findTreeNodeLocation(workspaceTreeNodes(), folderId, workspaceTreeAdapter);
-		return location?.node.kind === "folder" ? location.node.path ?? null : null;
-	};
-
 	const submitPendingFolder = async (): Promise<void> => {
 		const name = pendingFolderName().trim();
 		const draft = pendingFolderDraft();
@@ -658,104 +631,17 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 			return;
 		}
 
-		try {
-			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders`, {
-				method: "POST",
-				headers: {
-					Accept: "application/json",
-					"Content-Type": "application/json",
-				},
-				body: JSON.stringify({
-					name,
-					parentFolderId: parentFolderPath,
-				}),
-			});
-
-			const body = (await response.json()) as WorkspaceFoldersResponse;
-
-			if (!response.ok) {
-				throw new Error(body.message || "Failed to create project tree folder.");
-			}
-
-			setPersistedFolders(readPersistedWorkspaceFolders(body));
+		const created = await createFolder(name, draft.parentId);
+		if (created) {
 			setPendingFolderDraft(null);
 			setPendingFolderName("");
-		} catch (error) {
-			console.error(error);
 		}
 	};
 
 	const deletePersistedFolder = async (folderId: string): Promise<void> => {
-		const projectId = activeProject()?.id ?? "";
-		const folderPath = resolveFolderPath(folderId);
-		if (!folderId || !projectId || !isUuidString(projectId)) {
-			return;
-		}
-		if (!folderPath) {
-			return;
-		}
-
-		try {
-			const response = await fetch(
-				`${resolveAPIBase()}/projects/${projectId}/tree/folders?folderId=${encodeURIComponent(folderPath)}`,
-				{
-					method: "DELETE",
-					headers: {
-						Accept: "application/json",
-					},
-				},
-			);
-
-			const body = (await response.json()) as WorkspaceFoldersResponse;
-
-			if (!response.ok) {
-				throw new Error(body.message || "Failed to delete project tree folder.");
-			}
-
-			setPersistedFolders(readPersistedWorkspaceFolders(body));
+		const deleted = await deleteFolder(folderId);
+		if (deleted) {
 			setCollapsedFolderIds((current) => current.filter((id) => id !== folderId));
-		} catch (error) {
-			console.error(error);
-		}
-	};
-
-	const movePersistedFolder = async (
-		folderPath: string,
-		parentFolderPath: string | null,
-		folderStableId: string,
-		parentStableId: string | null,
-		targetIndex: number,
-	): Promise<void> => {
-		const projectId = activeProject()?.id ?? "";
-		if (!folderPath || !folderStableId || !projectId || !isUuidString(projectId)) {
-			return;
-		}
-
-		try {
-			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders/move`, {
-				method: "PATCH",
-				headers: {
-					Accept: "application/json",
-					"Content-Type": "application/json",
-				},
-				body: JSON.stringify({
-					folderId: folderPath,
-					folderNodeId: folderStableId,
-					parentFolderId: parentFolderPath,
-					parentNodeId: parentStableId,
-					targetIndex,
-				}),
-			});
-
-			const body = (await response.json()) as WorkspaceFoldersResponse;
-
-			if (!response.ok) {
-				throw new Error(body.message || "Failed to move project tree folder.");
-			}
-
-			setPersistedFolders(readPersistedWorkspaceFolders(body));
-		} catch (error) {
-			console.error(error);
 		}
 	};
 
@@ -785,30 +671,10 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 			return;
 		}
 
-		try {
-			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders`, {
-				method: "PATCH",
-				headers: {
-					Accept: "application/json",
-					"Content-Type": "application/json",
-				},
-				body: JSON.stringify({
-					folderId: folderPath,
-					name,
-				}),
-			});
-
-			const body = (await response.json()) as WorkspaceFoldersResponse;
-
-			if (!response.ok) {
-				throw new Error(body.message || "Failed to rename project tree folder.");
-			}
-
-			setPersistedFolders(readPersistedWorkspaceFolders(body));
+		const renamed = await renameFolder(draft.folderId, name);
+		if (renamed) {
 			setPendingFolderRename(null);
 			setPendingFolderRenameName("");
-		} catch (error) {
-			console.error(error);
 		}
 	};
 
@@ -833,11 +699,34 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 		}
 	};
 
+	const openWorkspaceCreateMenu = (element: HTMLElement): void => {
+		contextMenu.openMenuFromElement(element, sidebarContextMenuTarget);
+	};
+
+	const resolveCreateItemType = (actionId: string): WorkspaceItemTypeId | null => {
+		switch (actionId) {
+			case "create-doc":
+				return "core.doc";
+			case "create-board":
+				return "core.board.kanban";
+			case "create-list-board":
+				return "core.board.list";
+			default:
+				return null;
+		}
+	};
+
+	const createPersistedItem = async (itemType: WorkspaceItemTypeId, parentId: string | null): Promise<void> => {
+		const definition = getWorkspaceItemTypeDefinition(itemType);
+		await createItem(definition.defaultCreateLabel, itemType, parentId);
+	};
+
 	const handleNodePointerDown = (event: PointerEvent, nodeId: string): void => {
 		if (event.button !== 0 || pendingFolderDraft()) {
 			return;
 		}
 
+		updateDragGhostPosition(event.clientX, event.clientY);
 		clearLongPressTimer();
 		longPressTimer = window.setTimeout(() => {
 			suppressTreeClickTemporarily();
@@ -875,6 +764,22 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 	};
 
 	const handleContextActionSelect = (action: WorkspaceContextMenuAction, target: WorkspaceContextMenuTarget): void => {
+		const createItemType = resolveCreateItemType(action.id);
+		if (createItemType) {
+			switch (target.kind) {
+				case "workspace":
+				case "home":
+					void createPersistedItem(createItemType, null);
+					return;
+				case "folder":
+					void createPersistedItem(createItemType, target.id);
+					return;
+				case "settings":
+				case "item":
+					return;
+			}
+		}
+
 		switch (action.id) {
 			case "new-folder":
 				switch (target.kind) {
@@ -900,6 +805,13 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 					beginFolderRename(target.id, target.label, findTreeNodeDepth(workspaceTreeNodes(), target.id, workspaceTreeAdapter) ?? 0);
 				}
 				return;
+			case "delete-doc":
+			case "delete-board":
+			case "delete-list-board":
+				if (target.kind === "item") {
+					void deleteItem(target.id);
+				}
+				return;
 			default:
 				return;
 		}
@@ -1012,7 +924,23 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 						</ul>
 
 						<Show when={!props.collapsed}>
-							<div class={styles.treeSectionLabel}>Items</div>
+							<div class={styles.treeSectionHeader}>
+								<div class={styles.treeSectionLabel}>Items</div>
+								<div class={styles.treeControls}>
+									<button
+										type="button"
+										class={styles.treeControlButton}
+										onClick={(event): void => {
+											event.stopPropagation();
+											openWorkspaceCreateMenu(event.currentTarget);
+										}}
+										aria-label="Create in Items"
+										title="Create"
+									>
+										<Plus size={16} strokeWidth={2.25} />
+									</button>
+								</div>
+							</div>
 						</Show>
 
 						<div data-slot="workspace-tree-root">
@@ -1058,6 +986,32 @@ export const WorkspaceSidebar = (props: WorkspaceSidebarProps): JSX.Element => {
 				onClose={contextMenu.closeMenu}
 				onSelect={handleContextActionSelect}
 			/>
+
+			<Show when={draggedNode()} keyed>
+				{(node): JSX.Element => {
+					const GhostIcon = getWorkspaceNodeIcon(node);
+
+					return (
+						<Portal>
+							<div class={styles.dragGhostLayer} aria-hidden="true">
+								<div
+									class={styles.dragGhost}
+									style={{
+										"--drag-ghost-x": `${dragGhostPosition().x}px`,
+										"--drag-ghost-y": `${dragGhostPosition().y}px`,
+									}}
+								>
+									<GhostIcon class={styles.icon} size={18} strokeWidth={2} />
+									<div class={styles.dragGhostCopy}>
+										<div class={styles.dragGhostTitle}>{node.label}</div>
+										<div class={styles.dragGhostMeta}>{draggedNodeMeta()}</div>
+									</div>
+								</div>
+							</div>
+						</Portal>
+					);
+				}}
+			</Show>
 		</>
 	);
 };
diff --git a/Frontend/src/components/shell/data/shell.data.ts b/Frontend/src/components/shell/data/shell.data.ts
index 3799efa..0479831 100644
--- a/Frontend/src/components/shell/data/shell.data.ts
+++ b/Frontend/src/components/shell/data/shell.data.ts
@@ -140,6 +140,7 @@ export type WorkspaceFolderNode = {
 
 export type WorkspaceItemNode = {
 	id: string;
+	path?: string;
 	label: string;
 	kind: "item";
 	itemType: WorkspaceItemTypeId;
@@ -559,6 +560,7 @@ export const getWorkspaceContextMenuSections = (
 					id: "organize",
 					label: undefined,
 					items: [
+						{ id: "move-folder", label: "Move…", shortcut: { modifiers: ["meta"], key: "m" } },
 						{ id: "delete-folder", label: "Delete", shortcut: { modifiers: ["meta"], key: "delete" }, tone: "danger" },
 					],
 				},
@@ -580,6 +582,7 @@ export const getWorkspaceContextMenuSections = (
 					id: "organize",
 					label: undefined,
 					items: [
+						{ id: `move-${actionPrefix}`, label: "Move…", shortcut: { modifiers: ["meta"], key: "m" } },
 						{ id: `delete-${actionPrefix}`, label: "Delete", shortcut: { modifiers: ["meta"], key: "delete" }, tone: "danger" },
 					],
 				},
diff --git a/Frontend/src/components/shell/shared/_tree-nav.scss b/Frontend/src/components/shell/shared/_tree-nav.scss
index e9c46c6..b5f250c 100644
--- a/Frontend/src/components/shell/shared/_tree-nav.scss
+++ b/Frontend/src/components/shell/shared/_tree-nav.scss
@@ -57,6 +57,7 @@
 	display: grid;
 	position: relative;
 	isolation: isolate;
+	cursor: grab;
 	grid-template-columns: auto auto minmax(0, 1fr) auto;
 	align-items: center;
 	gap: var(--space-2);
@@ -71,7 +72,12 @@
 	transition:
 		color 160ms var(--easing-standard),
 		box-shadow 160ms var(--easing-standard),
-		transform 180ms var(--easing-standard);
+		transform 180ms var(--easing-standard),
+		opacity 160ms var(--easing-standard);
+
+	&:active {
+		cursor: grabbing;
+	}
 
 	&::after {
 		content: "";
@@ -108,48 +114,61 @@
 }
 
 @mixin item-dragging {
-	opacity: 0.45;
-	transform: scale(0.985);
-	box-shadow: none;
+	cursor: grabbing;
+	opacity: 0.88;
+	transform: translateX(2px) scale(0.992);
+	color: var(--color-text);
+
+	&::after {
+		border-color: color-mix(in srgb, var(--color-accent-strong) 24%, var(--color-border));
+		background: color-mix(in srgb, var(--color-surface) 90%, var(--color-accent-soft) 10%);
+		box-shadow:
+			0 10px 24px color-mix(in srgb, black 10%, transparent),
+			inset 0 1px 0 color-mix(in srgb, white 6%, transparent);
+	}
+}
+
+@mixin item-drop-boundary($edge) {
+	&::before {
+		content: "";
+		position: absolute;
+		left: calc(var(--space-3) + (var(--tree-depth, 0) * var(--space-4)));
+		right: var(--space-3);
+		#{$edge}: calc(-1 * ((8px - 3px) / 2));
+		height: 8px;
+		border-radius: 999px;
+		background:
+			radial-gradient(circle, color-mix(in srgb, var(--color-accent-strong) 92%, white 8%) 0 3px, transparent 4px)
+				left center / 8px 8px no-repeat,
+			linear-gradient(
+				to right,
+				color-mix(in srgb, var(--color-accent-strong) 88%, white 12%),
+				color-mix(in srgb, var(--color-accent-strong) 72%, transparent)
+			)
+			center / 100% 3px no-repeat;
+		pointer-events: none;
+		z-index: 2;
+	}
 }
 
 @mixin item-drop-before {
-	&::before {
-		content: "";
-		position: absolute;
-		left: calc(var(--space-3) + (var(--tree-depth, 0) * var(--space-4)));
-		right: var(--space-3);
-		top: calc((var(--space-1) * -0.5) - 1px);
-		height: 2px;
-		border-radius: 999px;
-		background: color-mix(in srgb, var(--color-accent-strong) 78%, transparent);
-		pointer-events: none;
-		z-index: 2;
-	}
+	@include item-drop-boundary(top);
 }
 
 @mixin item-drop-after {
-	&::before {
-		content: "";
-		position: absolute;
-		left: calc(var(--space-3) + (var(--tree-depth, 0) * var(--space-4)));
-		right: var(--space-3);
-		bottom: calc((var(--space-1) * -0.5) - 1px);
-		height: 2px;
-		border-radius: 999px;
-		background: color-mix(in srgb, var(--color-accent-strong) 78%, transparent);
-		pointer-events: none;
-		z-index: 2;
-	}
+	@include item-drop-boundary(bottom);
 }
 
 @mixin item-drop-inside {
 	color: var(--color-text);
 
 	&::after {
-		border-color: color-mix(in srgb, var(--color-accent-strong) 55%, transparent);
-		background: color-mix(in srgb, var(--color-accent-soft) 36%, var(--color-surface));
-		box-shadow: inset 0 1px 0 color-mix(in srgb, white 4%, transparent);
+		border-color: color-mix(in srgb, var(--color-accent-strong) 72%, transparent);
+		background: color-mix(in srgb, var(--color-accent-soft) 48%, var(--color-surface));
+		box-shadow:
+			0 0 0 1px color-mix(in srgb, var(--color-accent-strong) 18%, transparent),
+			inset 0 1px 0 color-mix(in srgb, white 4%, transparent),
+			inset 4px 0 0 color-mix(in srgb, var(--color-accent-strong) 78%, transparent);
 	}
 }
 
@@ -186,3 +205,71 @@
 	@include text-caption;
 	color: var(--color-text-muted);
 }
+
+@mixin drag-ghost-layer {
+	position: fixed;
+	inset: 0;
+	pointer-events: none;
+	z-index: 60;
+}
+
+@mixin drag-ghost {
+	position: fixed;
+	top: 0;
+	left: 0;
+	display: inline-flex;
+	align-items: center;
+	gap: var(--space-2);
+	min-height: calc(var(--control-size-lg) - var(--space-2));
+	max-width: min(24rem, calc(100vw - (var(--space-6) * 2)));
+	padding: var(--space-2) var(--space-3);
+	border-radius: var(--radius-lg);
+	border: 1px solid color-mix(in srgb, var(--color-accent-strong) 18%, var(--color-border));
+	background: color-mix(in srgb, var(--color-surface) 92%, var(--color-accent-soft) 8%);
+	box-shadow:
+		0 18px 38px color-mix(in srgb, black 16%, transparent),
+		0 6px 14px color-mix(in srgb, black 8%, transparent),
+		inset 0 1px 0 color-mix(in srgb, white 8%, transparent);
+	color: var(--color-text);
+	transform: translate3d(var(--drag-ghost-x, 0), var(--drag-ghost-y, 0), 0);
+	will-change: transform;
+	backdrop-filter: blur(12px);
+	-webkit-backdrop-filter: blur(12px);
+
+	&::after {
+		content: "";
+		position: absolute;
+		inset: 0;
+		border-radius: inherit;
+		background: linear-gradient(
+			180deg,
+			color-mix(in srgb, white 10%, transparent),
+			transparent 42%
+		);
+		pointer-events: none;
+	}
+
+	> * {
+		position: relative;
+		z-index: 1;
+	}
+	}
+
+@mixin drag-ghost-copy {
+	min-width: 0;
+	display: grid;
+	gap: 0.1rem;
+}
+
+@mixin drag-ghost-title {
+	@include text-label;
+	min-width: 0;
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
+@mixin drag-ghost-meta {
+	@include text-caption;
+	color: var(--color-text-muted);
+}
diff --git a/Frontend/src/components/shell/shared/useWorkspaceTreeData.ts b/Frontend/src/components/shell/shared/useWorkspaceTreeData.ts
new file mode 100644
index 0000000..20057f9
--- /dev/null
+++ b/Frontend/src/components/shell/shared/useWorkspaceTreeData.ts
@@ -0,0 +1,393 @@
+import { createEffect, createSignal, type Accessor, type Setter } from "solid-js";
+import { resolveAPIBase } from "../../../lib/api";
+import { Folder } from "../../../lib/icons";
+import type { WorkspaceItemTypeId, WorkspaceTreeNode } from "../data/shell.data";
+import { isUuidString } from "./navTreeDnd";
+
+type PersistedWorkspaceTreeNodeRecord = {
+	id: string;
+	path: string;
+	label: string;
+	kind: "folder" | "item";
+	itemType?: string;
+	children?: PersistedWorkspaceTreeNodeRecord[];
+};
+
+type WorkspaceTreeResponse = {
+	data?: {
+		nodes?: PersistedWorkspaceTreeNodeRecord[];
+	};
+	error?: string;
+	message?: string;
+};
+
+type WorkspaceMutationResponse = {
+	error?: string;
+	message?: string;
+};
+
+const buildPersistedWorkspaceTreeNodes = (
+	nodes: readonly PersistedWorkspaceTreeNodeRecord[],
+): WorkspaceTreeNode[] =>
+	nodes.map((node) =>
+		node.kind === "folder"
+			? {
+				id: node.id,
+				path: node.path,
+				label: node.label,
+				kind: "folder",
+				icon: Folder,
+				children: buildPersistedWorkspaceTreeNodes(node.children ?? []),
+			}
+			: {
+				id: node.id,
+				path: node.path,
+				label: node.label,
+				kind: "item",
+				itemType: node.itemType ?? "core.board.kanban",
+			}
+	);
+
+const readPersistedWorkspaceTreeNodes = (body: WorkspaceTreeResponse): PersistedWorkspaceTreeNodeRecord[] =>
+	Array.isArray(body.data?.nodes) ? body.data.nodes : [];
+
+const findNodeById = (nodes: readonly WorkspaceTreeNode[], nodeId: string): WorkspaceTreeNode | null => {
+	for (const node of nodes) {
+		if (node.id === nodeId) {
+			return node;
+		}
+
+		if (node.kind !== "folder") {
+			continue;
+		}
+
+		const nestedMatch = findNodeById(node.children ?? [], nodeId);
+		if (nestedMatch) {
+			return nestedMatch;
+		}
+	}
+
+	return null;
+};
+
+type UseWorkspaceTreeDataOptions = {
+	activeProjectId: Accessor<string>;
+	fallbackWorkspaceTree: Accessor<readonly WorkspaceTreeNode[]>;
+};
+
+type UseWorkspaceTreeDataResult = {
+	workspaceTreeNodes: Accessor<readonly WorkspaceTreeNode[]>;
+	setWorkspaceTreeNodes: Setter<readonly WorkspaceTreeNode[]>;
+	resolveFolderPath: (folderId: string) => string | null;
+	resolveItemPath: (itemId: string) => string | null;
+	createFolder: (name: string, parentId: string | null) => Promise<boolean>;
+	renameFolder: (folderId: string, name: string) => Promise<boolean>;
+	deleteFolder: (folderId: string) => Promise<boolean>;
+	moveFolder: (folderId: string, parentId: string | null, targetIndex: number) => Promise<boolean>;
+	createItem: (name: string, itemType: WorkspaceItemTypeId, parentId: string | null) => Promise<boolean>;
+	deleteItem: (itemId: string) => Promise<boolean>;
+	moveItem: (itemId: string, parentId: string | null, targetIndex: number) => Promise<boolean>;
+};
+
+export const useWorkspaceTreeData = (
+	options: UseWorkspaceTreeDataOptions,
+): UseWorkspaceTreeDataResult => {
+	const [persistedNodes, setPersistedNodes] = createSignal<readonly PersistedWorkspaceTreeNodeRecord[]>([]);
+	const [workspaceTreeNodes, setWorkspaceTreeNodes] = createSignal<readonly WorkspaceTreeNode[]>(
+		options.fallbackWorkspaceTree(),
+	);
+	let latestPersistedTreeRequest = 0;
+
+	const syncWorkspaceTree = (): void => {
+		const nextTree = options.activeProjectId()
+			? buildPersistedWorkspaceTreeNodes(persistedNodes())
+			: options.fallbackWorkspaceTree();
+
+		setWorkspaceTreeNodes(nextTree);
+	};
+
+	const loadPersistedTree = async (projectId: string): Promise<boolean> => {
+		const requestId = latestPersistedTreeRequest + 1;
+		latestPersistedTreeRequest = requestId;
+
+		if (!projectId || !isUuidString(projectId)) {
+			setPersistedNodes([]);
+			return false;
+		}
+
+		try {
+			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree`, {
+				headers: {
+					Accept: "application/json",
+				},
+			});
+			const body = (await response.json()) as WorkspaceTreeResponse;
+
+			if (requestId !== latestPersistedTreeRequest) {
+				return false;
+			}
+
+			if (!response.ok) {
+				throw new Error(body.message || "Failed to load project tree.");
+			}
+
+			setPersistedNodes(readPersistedWorkspaceTreeNodes(body));
+			return true;
+		} catch (error) {
+			if (requestId !== latestPersistedTreeRequest) {
+				return false;
+			}
+
+			console.error(error);
+			setPersistedNodes([]);
+			return false;
+		}
+	};
+
+	const resolveFolderPath = (folderId: string): string | null => {
+		const node = findNodeById(workspaceTreeNodes(), folderId);
+		return node?.kind === "folder" ? node.path ?? null : null;
+	};
+
+	const resolveItemPath = (itemId: string): string | null => {
+		const node = findNodeById(workspaceTreeNodes(), itemId);
+		return node?.kind === "item" ? node.path ?? null : null;
+	};
+
+	const refreshAfterMutation = async (projectId: string, response: Response): Promise<boolean> => {
+		const body = (await response.json()) as WorkspaceMutationResponse;
+		if (!response.ok) {
+			throw new Error(body.message || "Failed to persist project tree mutation.");
+		}
+
+		return loadPersistedTree(projectId);
+	};
+
+	const createFolder = async (name: string, parentId: string | null): Promise<boolean> => {
+		const projectId = options.activeProjectId();
+		if (!projectId || !isUuidString(projectId)) {
+			return false;
+		}
+
+		const parentFolderPath = parentId ? resolveFolderPath(parentId) : null;
+		if (parentId && !parentFolderPath) {
+			return false;
+		}
+
+		try {
+			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders`, {
+				method: "POST",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					name,
+					parentFolderId: parentFolderPath,
+				}),
+			});
+
+			return refreshAfterMutation(projectId, response);
+		} catch (error) {
+			console.error(error);
+			return false;
+		}
+	};
+
+	const renameFolder = async (folderId: string, name: string): Promise<boolean> => {
+		const projectId = options.activeProjectId();
+		const folderPath = resolveFolderPath(folderId);
+		if (!projectId || !isUuidString(projectId) || !folderPath) {
+			return false;
+		}
+
+		try {
+			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders`, {
+				method: "PATCH",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					folderId: folderPath,
+					name,
+				}),
+			});
+
+			return refreshAfterMutation(projectId, response);
+		} catch (error) {
+			console.error(error);
+			return false;
+		}
+	};
+
+	const deleteFolder = async (folderId: string): Promise<boolean> => {
+		const projectId = options.activeProjectId();
+		const folderPath = resolveFolderPath(folderId);
+		if (!projectId || !isUuidString(projectId) || !folderPath) {
+			return false;
+		}
+
+		try {
+			const response = await fetch(
+				`${resolveAPIBase()}/projects/${projectId}/tree/folders?folderId=${encodeURIComponent(folderPath)}`,
+				{
+					method: "DELETE",
+					headers: {
+						Accept: "application/json",
+					},
+				},
+			);
+
+			return refreshAfterMutation(projectId, response);
+		} catch (error) {
+			console.error(error);
+			return false;
+		}
+	};
+
+	const moveFolder = async (folderId: string, parentId: string | null, targetIndex: number): Promise<boolean> => {
+		const projectId = options.activeProjectId();
+		const folderPath = resolveFolderPath(folderId);
+		const parentFolderPath = parentId ? resolveFolderPath(parentId) : null;
+		if (!projectId || !isUuidString(projectId) || !folderPath) {
+			return false;
+		}
+
+		try {
+			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/folders/move`, {
+				method: "PATCH",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					folderId: folderPath,
+					folderNodeId: folderId,
+					parentFolderId: parentFolderPath,
+					parentNodeId: parentId,
+					targetIndex,
+				}),
+			});
+
+			return refreshAfterMutation(projectId, response);
+		} catch (error) {
+			console.error(error);
+			return false;
+		}
+	};
+
+	const createItem = async (
+		name: string,
+		itemType: WorkspaceItemTypeId,
+		parentId: string | null,
+	): Promise<boolean> => {
+		const projectId = options.activeProjectId();
+		if (!projectId || !isUuidString(projectId)) {
+			return false;
+		}
+
+		const parentFolderPath = parentId ? resolveFolderPath(parentId) : null;
+		if (parentId && !parentFolderPath) {
+			return false;
+		}
+
+		try {
+			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/items`, {
+				method: "POST",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					name,
+					itemType,
+					parentFolderId: parentFolderPath,
+				}),
+			});
+
+			return refreshAfterMutation(projectId, response);
+		} catch (error) {
+			console.error(error);
+			return false;
+		}
+	};
+
+	const deleteItem = async (itemId: string): Promise<boolean> => {
+		const projectId = options.activeProjectId();
+		const itemPath = resolveItemPath(itemId);
+		if (!projectId || !isUuidString(projectId) || !itemPath) {
+			return false;
+		}
+
+		try {
+			const response = await fetch(
+				`${resolveAPIBase()}/projects/${projectId}/tree/items?itemId=${encodeURIComponent(itemPath)}`,
+				{
+					method: "DELETE",
+					headers: {
+						Accept: "application/json",
+					},
+				},
+			);
+
+			return refreshAfterMutation(projectId, response);
+		} catch (error) {
+			console.error(error);
+			return false;
+		}
+	};
+
+	const moveItem = async (itemId: string, parentId: string | null, targetIndex: number): Promise<boolean> => {
+		const projectId = options.activeProjectId();
+		const itemPath = resolveItemPath(itemId);
+		const parentFolderPath = parentId ? resolveFolderPath(parentId) : null;
+		if (!projectId || !isUuidString(projectId) || !itemPath) {
+			return false;
+		}
+
+		try {
+			const response = await fetch(`${resolveAPIBase()}/projects/${projectId}/tree/items/move`, {
+				method: "PATCH",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					itemId: itemPath,
+					itemNodeId: itemId,
+					parentFolderId: parentFolderPath,
+					parentNodeId: parentId,
+					targetIndex,
+				}),
+			});
+
+			return refreshAfterMutation(projectId, response);
+		} catch (error) {
+			console.error(error);
+			return false;
+		}
+	};
+
+	createEffect(() => {
+		syncWorkspaceTree();
+	});
+
+	createEffect(() => {
+		void loadPersistedTree(options.activeProjectId());
+	});
+
+	return {
+		workspaceTreeNodes,
+		setWorkspaceTreeNodes,
+		resolveFolderPath,
+		resolveItemPath,
+		createFolder,
+		renameFolder,
+		deleteFolder,
+		moveFolder,
+		createItem,
+		deleteItem,
+		moveItem,
+	};
+};